Initial commit (by create-cloudflare CLI)

cool-dawn-3d3b/node_modules/zod/lib/ZodError.d.ts

@@ -0,0 +1,163 @@
+import type { TypeOf, ZodType } from ".";
+import { Primitive } from "./helpers/typeAliases";
+import { util, ZodParsedType } from "./helpers/util";
+declare type allKeys<T> = T extends any ? keyof T : never;
+export declare type inferFlattenedErrors<T extends ZodType<any, any, any>, U = string> = typeToFlattenedError<TypeOf<T>, U>;
+export declare type typeToFlattenedError<T, U = string> = {
+    formErrors: U[];
+    fieldErrors: {
+        [P in allKeys<T>]?: U[];
+    };
+};
+export declare const ZodIssueCode: {
+    invalid_type: "invalid_type";
+    invalid_literal: "invalid_literal";
+    custom: "custom";
+    invalid_union: "invalid_union";
+    invalid_union_discriminator: "invalid_union_discriminator";
+    invalid_enum_value: "invalid_enum_value";
+    unrecognized_keys: "unrecognized_keys";
+    invalid_arguments: "invalid_arguments";
+    invalid_return_type: "invalid_return_type";
+    invalid_date: "invalid_date";
+    invalid_string: "invalid_string";
+    too_small: "too_small";
+    too_big: "too_big";
+    invalid_intersection_types: "invalid_intersection_types";
+    not_multiple_of: "not_multiple_of";
+    not_finite: "not_finite";
+};
+export declare type ZodIssueCode = keyof typeof ZodIssueCode;
+export declare type ZodIssueBase = {
+    path: (string | number)[];
+    message?: string;
+};
+export interface ZodInvalidTypeIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_type;
+    expected: ZodParsedType;
+    received: ZodParsedType;
+}
+export interface ZodInvalidLiteralIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_literal;
+    expected: unknown;
+    received: unknown;
+}
+export interface ZodUnrecognizedKeysIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.unrecognized_keys;
+    keys: string[];
+}
+export interface ZodInvalidUnionIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_union;
+    unionErrors: ZodError[];
+}
+export interface ZodInvalidUnionDiscriminatorIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_union_discriminator;
+    options: Primitive[];
+}
+export interface ZodInvalidEnumValueIssue extends ZodIssueBase {
+    received: string | number;
+    code: typeof ZodIssueCode.invalid_enum_value;
+    options: (string | number)[];
+}
+export interface ZodInvalidArgumentsIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_arguments;
+    argumentsError: ZodError;
+}
+export interface ZodInvalidReturnTypeIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_return_type;
+    returnTypeError: ZodError;
+}
+export interface ZodInvalidDateIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_date;
+}
+export declare type StringValidation = "email" | "url" | "emoji" | "uuid" | "regex" | "cuid" | "cuid2" | "ulid" | "datetime" | "ip" | {
+    includes: string;
+    position?: number;
+} | {
+    startsWith: string;
+} | {
+    endsWith: string;
+};
+export interface ZodInvalidStringIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_string;
+    validation: StringValidation;
+}
+export interface ZodTooSmallIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.too_small;
+    minimum: number | bigint;
+    inclusive: boolean;
+    exact?: boolean;
+    type: "array" | "string" | "number" | "set" | "date" | "bigint";
+}
+export interface ZodTooBigIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.too_big;
+    maximum: number | bigint;
+    inclusive: boolean;
+    exact?: boolean;
+    type: "array" | "string" | "number" | "set" | "date" | "bigint";
+}
+export interface ZodInvalidIntersectionTypesIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_intersection_types;
+}
+export interface ZodNotMultipleOfIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.not_multiple_of;
+    multipleOf: number | bigint;
+}
+export interface ZodNotFiniteIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.not_finite;
+}
+export interface ZodCustomIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.custom;
+    params?: {
+        [k: string]: any;
+    };
+}
+export declare type DenormalizedError = {
+    [k: string]: DenormalizedError | string[];
+};
+export declare type ZodIssueOptionalMessage = ZodInvalidTypeIssue | ZodInvalidLiteralIssue | ZodUnrecognizedKeysIssue | ZodInvalidUnionIssue | ZodInvalidUnionDiscriminatorIssue | ZodInvalidEnumValueIssue | ZodInvalidArgumentsIssue | ZodInvalidReturnTypeIssue | ZodInvalidDateIssue | ZodInvalidStringIssue | ZodTooSmallIssue | ZodTooBigIssue | ZodInvalidIntersectionTypesIssue | ZodNotMultipleOfIssue | ZodNotFiniteIssue | ZodCustomIssue;
+export declare type ZodIssue = ZodIssueOptionalMessage & {
+    fatal?: boolean;
+    message: string;
+};
+export declare const quotelessJson: (obj: any) => string;
+declare type recursiveZodFormattedError<T> = T extends [any, ...any[]] ? {
+    [K in keyof T]?: ZodFormattedError<T[K]>;
+} : T extends any[] ? {
+    [k: number]: ZodFormattedError<T[number]>;
+} : T extends object ? {
+    [K in keyof T]?: ZodFormattedError<T[K]>;
+} : unknown;
+export declare type ZodFormattedError<T, U = string> = {
+    _errors: U[];
+} & recursiveZodFormattedError<NonNullable<T>>;
+export declare type inferFormattedError<T extends ZodType<any, any, any>, U = string> = ZodFormattedError<TypeOf<T>, U>;
+export declare class ZodError<T = any> extends Error {
+    issues: ZodIssue[];
+    get errors(): ZodIssue[];
+    constructor(issues: ZodIssue[]);
+    format(): ZodFormattedError<T>;
+    format<U>(mapper: (issue: ZodIssue) => U): ZodFormattedError<T, U>;
+    static create: (issues: ZodIssue[]) => ZodError<any>;
+    toString(): string;
+    get message(): string;
+    get isEmpty(): boolean;
+    addIssue: (sub: ZodIssue) => void;
+    addIssues: (subs?: ZodIssue[]) => void;
+    flatten(): typeToFlattenedError<T>;
+    flatten<U>(mapper?: (issue: ZodIssue) => U): typeToFlattenedError<T, U>;
+    get formErrors(): typeToFlattenedError<T, string>;
+}
+declare type stripPath<T extends object> = T extends any ? util.OmitKeys<T, "path"> : never;
+export declare type IssueData = stripPath<ZodIssueOptionalMessage> & {
+    path?: (string | number)[];
+    fatal?: boolean;
+};
+export declare type ErrorMapCtx = {
+    defaultError: string;
+    data: any;
+};
+export declare type ZodErrorMap = (issue: ZodIssueOptionalMessage, _ctx: ErrorMapCtx) => {
+    message: string;
+};
+export {};

cool-dawn-3d3b/node_modules/zod/lib/ZodError.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZodError = exports.quotelessJson = exports.ZodIssueCode = void 0;
+const util_1 = require("./helpers/util");
+exports.ZodIssueCode = util_1.util.arrayToEnum([
+    "invalid_type",
+    "invalid_literal",
+    "custom",
+    "invalid_union",
+    "invalid_union_discriminator",
+    "invalid_enum_value",
+    "unrecognized_keys",
+    "invalid_arguments",
+    "invalid_return_type",
+    "invalid_date",
+    "invalid_string",
+    "too_small",
+    "too_big",
+    "invalid_intersection_types",
+    "not_multiple_of",
+    "not_finite",
+]);
+const quotelessJson = (obj) => {
+    const json = JSON.stringify(obj, null, 2);
+    return json.replace(/"([^"]+)":/g, "$1:");
+};
+exports.quotelessJson = quotelessJson;
+class ZodError extends Error {
+    constructor(issues) {
+        super();
+        this.issues = [];
+        this.addIssue = (sub) => {
+            this.issues = [...this.issues, sub];
+        };
+        this.addIssues = (subs = []) => {
+            this.issues = [...this.issues, ...subs];
+        };
+        const actualProto = new.target.prototype;
+        if (Object.setPrototypeOf) {
+            Object.setPrototypeOf(this, actualProto);
+        }
+        else {
+            this.__proto__ = actualProto;
+        }
+        this.name = "ZodError";
+        this.issues = issues;
+    }
+    get errors() {
+        return this.issues;
+    }
+    format(_mapper) {
+        const mapper = _mapper ||
+            function (issue) {
+                return issue.message;
+            };
+        const fieldErrors = { _errors: [] };
+        const processError = (error) => {
+            for (const issue of error.issues) {
+                if (issue.code === "invalid_union") {
+                    issue.unionErrors.map(processError);
+                }
+                else if (issue.code === "invalid_return_type") {
+                    processError(issue.returnTypeError);
+                }
+                else if (issue.code === "invalid_arguments") {
+                    processError(issue.argumentsError);
+                }
+                else if (issue.path.length === 0) {
+                    fieldErrors._errors.push(mapper(issue));
+                }
+                else {
+                    let curr = fieldErrors;
+                    let i = 0;
+                    while (i < issue.path.length) {
+                        const el = issue.path[i];
+                        const terminal = i === issue.path.length - 1;
+                        if (!terminal) {
+                            curr[el] = curr[el] || { _errors: [] };
+                        }
+                        else {
+                            curr[el] = curr[el] || { _errors: [] };
+                            curr[el]._errors.push(mapper(issue));
+                        }
+                        curr = curr[el];
+                        i++;
+                    }
+                }
+            }
+        };
+        processError(this);
+        return fieldErrors;
+    }
+    toString() {
+        return this.message;
+    }
+    get message() {
+        return JSON.stringify(this.issues, util_1.util.jsonStringifyReplacer, 2);
+    }
+    get isEmpty() {
+        return this.issues.length === 0;
+    }
+    flatten(mapper = (issue) => issue.message) {
+        const fieldErrors = {};
+        const formErrors = [];
+        for (const sub of this.issues) {
+            if (sub.path.length > 0) {
+                fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
+                fieldErrors[sub.path[0]].push(mapper(sub));
+            }
+            else {
+                formErrors.push(mapper(sub));
+            }
+        }
+        return { formErrors, fieldErrors };
+    }
+    get formErrors() {
+        return this.flatten();
+    }
+}
+exports.ZodError = ZodError;
+ZodError.create = (issues) => {
+    const error = new ZodError(issues);
+    return error;
+};

cool-dawn-3d3b/node_modules/zod/lib/__tests__/Mocker.d.ts

@@ -0,0 +1,17 @@
+export declare class Mocker {
+    pick: (...args: any[]) => any;
+    get string(): string;
+    get number(): number;
+    get bigint(): bigint;
+    get boolean(): boolean;
+    get date(): Date;
+    get symbol(): symbol;
+    get null(): null;
+    get undefined(): undefined;
+    get stringOptional(): any;
+    get stringNullable(): any;
+    get numberOptional(): any;
+    get numberNullable(): any;
+    get booleanOptional(): any;
+    get booleanNullable(): any;
+}

cool-dawn-3d3b/node_modules/zod/lib/__tests__/Mocker.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Mocker = void 0;
+function getRandomInt(max) {
+    return Math.floor(Math.random() * Math.floor(max));
+}
+const testSymbol = Symbol("test");
+class Mocker {
+    constructor() {
+        this.pick = (...args) => {
+            return args[getRandomInt(args.length)];
+        };
+    }
+    get string() {
+        return Math.random().toString(36).substring(7);
+    }
+    get number() {
+        return Math.random() * 100;
+    }
+    get bigint() {
+        return BigInt(Math.floor(Math.random() * 10000));
+    }
+    get boolean() {
+        return Math.random() < 0.5;
+    }
+    get date() {
+        return new Date(Math.floor(Date.now() * Math.random()));
+    }
+    get symbol() {
+        return testSymbol;
+    }
+    get null() {
+        return null;
+    }
+    get undefined() {
+        return undefined;
+    }
+    get stringOptional() {
+        return this.pick(this.string, this.undefined);
+    }
+    get stringNullable() {
+        return this.pick(this.string, this.null);
+    }
+    get numberOptional() {
+        return this.pick(this.number, this.undefined);
+    }
+    get numberNullable() {
+        return this.pick(this.number, this.null);
+    }
+    get booleanOptional() {
+        return this.pick(this.boolean, this.undefined);
+    }
+    get booleanNullable() {
+        return this.pick(this.boolean, this.null);
+    }
+}
+exports.Mocker = Mocker;

cool-dawn-3d3b/node_modules/zod/lib/benchmarks/discriminatedUnion.d.ts

@@ -0,0 +1,5 @@
+import Benchmark from "benchmark";
+declare const _default: {
+    suites: Benchmark.Suite[];
+};
+export default _default;

cool-dawn-3d3b/node_modules/zod/lib/benchmarks/discriminatedUnion.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const benchmark_1 = __importDefault(require("benchmark"));
+const index_1 = require("../index");
+const doubleSuite = new benchmark_1.default.Suite("z.discriminatedUnion: double");
+const manySuite = new benchmark_1.default.Suite("z.discriminatedUnion: many");
+const aSchema = index_1.z.object({
+    type: index_1.z.literal("a"),
+});
+const objA = {
+    type: "a",
+};
+const bSchema = index_1.z.object({
+    type: index_1.z.literal("b"),
+});
+const objB = {
+    type: "b",
+};
+const cSchema = index_1.z.object({
+    type: index_1.z.literal("c"),
+});
+const objC = {
+    type: "c",
+};
+const dSchema = index_1.z.object({
+    type: index_1.z.literal("d"),
+});
+const double = index_1.z.discriminatedUnion("type", [aSchema, bSchema]);
+const many = index_1.z.discriminatedUnion("type", [aSchema, bSchema, cSchema, dSchema]);
+doubleSuite
+    .add("valid: a", () => {
+    double.parse(objA);
+})
+    .add("valid: b", () => {
+    double.parse(objB);
+})
+    .add("invalid: null", () => {
+    try {
+        double.parse(null);
+    }
+    catch (err) { }
+})
+    .add("invalid: wrong shape", () => {
+    try {
+        double.parse(objC);
+    }
+    catch (err) { }
+})
+    .on("cycle", (e) => {
+    console.log(`${doubleSuite.name}: ${e.target}`);
+});
+manySuite
+    .add("valid: a", () => {
+    many.parse(objA);
+})
+    .add("valid: c", () => {
+    many.parse(objC);
+})
+    .add("invalid: null", () => {
+    try {
+        many.parse(null);
+    }
+    catch (err) { }
+})
+    .add("invalid: wrong shape", () => {
+    try {
+        many.parse({ type: "unknown" });
+    }
+    catch (err) { }
+})
+    .on("cycle", (e) => {
+    console.log(`${manySuite.name}: ${e.target}`);
+});
+exports.default = {
+    suites: [doubleSuite, manySuite],
+};

cool-dawn-3d3b/node_modules/zod/lib/benchmarks/index.d.ts

@@ -0,0 +1 @@
+export {};

cool-dawn-3d3b/node_modules/zod/lib/benchmarks/index.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const discriminatedUnion_1 = __importDefault(require("./discriminatedUnion"));
+const object_1 = __importDefault(require("./object"));
+const primitives_1 = __importDefault(require("./primitives"));
+const realworld_1 = __importDefault(require("./realworld"));
+const string_1 = __importDefault(require("./string"));
+const union_1 = __importDefault(require("./union"));
+const argv = process.argv.slice(2);
+let suites = [];
+if (!argv.length) {
+    suites = [
+        ...realworld_1.default.suites,
+        ...primitives_1.default.suites,
+        ...string_1.default.suites,
+        ...object_1.default.suites,
+        ...union_1.default.suites,
+        ...discriminatedUnion_1.default.suites,
+    ];
+}
+else {
+    if (argv.includes("--realworld")) {
+        suites.push(...realworld_1.default.suites);
+    }
+    if (argv.includes("--primitives")) {
+        suites.push(...primitives_1.default.suites);
+    }
+    if (argv.includes("--string")) {
+        suites.push(...string_1.default.suites);
+    }
+    if (argv.includes("--object")) {
+        suites.push(...object_1.default.suites);
+    }
+    if (argv.includes("--union")) {
+        suites.push(...union_1.default.suites);
+    }
+    if (argv.includes("--discriminatedUnion")) {
+        suites.push(...discriminatedUnion_1.default.suites);
+    }
+}
+for (const suite of suites) {
+    suite.run();
+}

cool-dawn-3d3b/node_modules/zod/lib/benchmarks/object.d.ts

@@ -0,0 +1,5 @@
+import Benchmark from "benchmark";
+declare const _default: {
+    suites: Benchmark.Suite[];
+};
+export default _default;

cool-dawn-3d3b/node_modules/zod/lib/benchmarks/object.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const benchmark_1 = __importDefault(require("benchmark"));
+const index_1 = require("../index");
+const emptySuite = new benchmark_1.default.Suite("z.object: empty");
+const shortSuite = new benchmark_1.default.Suite("z.object: short");
+const longSuite = new benchmark_1.default.Suite("z.object: long");
+const empty = index_1.z.object({});
+const short = index_1.z.object({
+    string: index_1.z.string(),
+});
+const long = index_1.z.object({
+    string: index_1.z.string(),
+    number: index_1.z.number(),
+    boolean: index_1.z.boolean(),
+});
+emptySuite
+    .add("valid", () => {
+    empty.parse({});
+})
+    .add("valid: extra keys", () => {
+    empty.parse({ string: "string" });
+})
+    .add("invalid: null", () => {
+    try {
+        empty.parse(null);
+    }
+    catch (err) { }
+})
+    .on("cycle", (e) => {
+    console.log(`${emptySuite.name}: ${e.target}`);
+});
+shortSuite
+    .add("valid", () => {
+    short.parse({ string: "string" });
+})
+    .add("valid: extra keys", () => {
+    short.parse({ string: "string", number: 42 });
+})
+    .add("invalid: null", () => {
+    try {
+        short.parse(null);
+    }
+    catch (err) { }
+})
+    .on("cycle", (e) => {
+    console.log(`${shortSuite.name}: ${e.target}`);
+});
+longSuite
+    .add("valid", () => {
+    long.parse({ string: "string", number: 42, boolean: true });
+})
+    .add("valid: extra keys", () => {
+    long.parse({ string: "string", number: 42, boolean: true, list: [] });
+})
+    .add("invalid: null", () => {
+    try {
+        long.parse(null);
+    }
+    catch (err) { }
+})
+    .on("cycle", (e) => {
+    console.log(`${longSuite.name}: ${e.target}`);
+});
+exports.default = {
+    suites: [emptySuite, shortSuite, longSuite],
+};

cool-dawn-3d3b/node_modules/zod/lib/benchmarks/primitives.d.ts

@@ -0,0 +1,5 @@
+import Benchmark from "benchmark";
+declare const _default: {
+    suites: Benchmark.Suite[];
+};
+export default _default;

cool-dawn-3d3b/node_modules/zod/lib/benchmarks/primitives.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const benchmark_1 = __importDefault(require("benchmark"));
+const Mocker_1 = require("../__tests__/Mocker");
+const index_1 = require("../index");
+const val = new Mocker_1.Mocker();
+const enumSuite = new benchmark_1.default.Suite("z.enum");
+const enumSchema = index_1.z.enum(["a", "b", "c"]);
+enumSuite
+    .add("valid", () => {
+    enumSchema.parse("a");
+})
+    .add("invalid", () => {
+    try {
+        enumSchema.parse("x");
+    }
+    catch (e) { }
+})
+    .on("cycle", (e) => {
+    console.log(`z.enum: ${e.target}`);
+});
+const undefinedSuite = new benchmark_1.default.Suite("z.undefined");
+const undefinedSchema = index_1.z.undefined();
+undefinedSuite
+    .add("valid", () => {
+    undefinedSchema.parse(undefined);
+})
+    .add("invalid", () => {
+    try {
+        undefinedSchema.parse(1);
+    }
+    catch (e) { }
+})
+    .on("cycle", (e) => {
+    console.log(`z.undefined: ${e.target}`);
+});
+const literalSuite = new benchmark_1.default.Suite("z.literal");
+const short = "short";
+const bad = "bad";
+const literalSchema = index_1.z.literal("short");
+literalSuite
+    .add("valid", () => {
+    literalSchema.parse(short);
+})
+    .add("invalid", () => {
+    try {
+        literalSchema.parse(bad);
+    }
+    catch (e) { }
+})
+    .on("cycle", (e) => {
+    console.log(`z.literal: ${e.target}`);
+});
+const numberSuite = new benchmark_1.default.Suite("z.number");
+const numberSchema = index_1.z.number().int();
+numberSuite
+    .add("valid", () => {
+    numberSchema.parse(1);
+})
+    .add("invalid type", () => {
+    try {
+        numberSchema.parse("bad");
+    }
+    catch (e) { }
+})
+    .add("invalid number", () => {
+    try {
+        numberSchema.parse(0.5);
+    }
+    catch (e) { }
+})
+    .on("cycle", (e) => {
+    console.log(`z.number: ${e.target}`);
+});
+const dateSuite = new benchmark_1.default.Suite("z.date");
+const plainDate = index_1.z.date();
+const minMaxDate = index_1.z
+    .date()
+    .min(new Date("2021-01-01"))
+    .max(new Date("2030-01-01"));
+dateSuite
+    .add("valid", () => {
+    plainDate.parse(new Date());
+})
+    .add("invalid", () => {
+    try {
+        plainDate.parse(1);
+    }
+    catch (e) { }
+})
+    .add("valid min and max", () => {
+    minMaxDate.parse(new Date("2023-01-01"));
+})
+    .add("invalid min", () => {
+    try {
+        minMaxDate.parse(new Date("2019-01-01"));
+    }
+    catch (e) { }
+})
+    .add("invalid max", () => {
+    try {
+        minMaxDate.parse(new Date("2031-01-01"));
+    }
+    catch (e) { }
+})
+    .on("cycle", (e) => {
+    console.log(`z.date: ${e.target}`);
+});
+const symbolSuite = new benchmark_1.default.Suite("z.symbol");
+const symbolSchema = index_1.z.symbol();
+symbolSuite
+    .add("valid", () => {
+    symbolSchema.parse(val.symbol);
+})
+    .add("invalid", () => {
+    try {
+        symbolSchema.parse(1);
+    }
+    catch (e) { }
+})
+    .on("cycle", (e) => {
+    console.log(`z.symbol: ${e.target}`);
+});
+exports.default = {
+    suites: [
+        enumSuite,
+        undefinedSuite,
+        literalSuite,
+        numberSuite,
+        dateSuite,
+        symbolSuite,
+    ],
+};

cool-dawn-3d3b/node_modules/zod/lib/benchmarks/realworld.d.ts

@@ -0,0 +1,5 @@
+import Benchmark from "benchmark";
+declare const _default: {
+    suites: Benchmark.Suite[];
+};
+export default _default;

cool-dawn-3d3b/node_modules/zod/lib/benchmarks/realworld.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const benchmark_1 = __importDefault(require("benchmark"));
+const index_1 = require("../index");
+const shortSuite = new benchmark_1.default.Suite("realworld");
+const People = index_1.z.array(index_1.z.object({
+    type: index_1.z.literal("person"),
+    hair: index_1.z.enum(["blue", "brown"]),
+    active: index_1.z.boolean(),
+    name: index_1.z.string(),
+    age: index_1.z.number().int(),
+    hobbies: index_1.z.array(index_1.z.string()),
+    address: index_1.z.object({
+        street: index_1.z.string(),
+        zip: index_1.z.string(),
+        country: index_1.z.string(),
+    }),
+}));
+let i = 0;
+function num() {
+    return ++i;
+}
+function str() {
+    return (++i % 100).toString(16);
+}
+function array(fn) {
+    return Array.from({ length: ++i % 10 }, () => fn());
+}
+const people = Array.from({ length: 100 }, () => {
+    return {
+        type: "person",
+        hair: i % 2 ? "blue" : "brown",
+        active: !!(i % 2),
+        name: str(),
+        age: num(),
+        hobbies: array(str),
+        address: {
+            street: str(),
+            zip: str(),
+            country: str(),
+        },
+    };
+});
+shortSuite
+    .add("valid", () => {
+    People.parse(people);
+})
+    .on("cycle", (e) => {
+    console.log(`${shortSuite.name}: ${e.target}`);
+});
+exports.default = {
+    suites: [shortSuite],
+};

cool-dawn-3d3b/node_modules/zod/lib/benchmarks/string.d.ts

@@ -0,0 +1,5 @@
+import Benchmark from "benchmark";
+declare const _default: {
+    suites: Benchmark.Suite[];
+};
+export default _default;

cool-dawn-3d3b/node_modules/zod/lib/benchmarks/string.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const benchmark_1 = __importDefault(require("benchmark"));
+const index_1 = require("../index");
+const SUITE_NAME = "z.string";
+const suite = new benchmark_1.default.Suite(SUITE_NAME);
+const empty = "";
+const short = "short";
+const long = "long".repeat(256);
+const manual = (str) => {
+    if (typeof str !== "string") {
+        throw new Error("Not a string");
+    }
+    return str;
+};
+const stringSchema = index_1.z.string();
+const optionalStringSchema = index_1.z.string().optional();
+const optionalNullableStringSchema = index_1.z.string().optional().nullable();
+suite
+    .add("empty string", () => {
+    stringSchema.parse(empty);
+})
+    .add("short string", () => {
+    stringSchema.parse(short);
+})
+    .add("long string", () => {
+    stringSchema.parse(long);
+})
+    .add("optional string", () => {
+    optionalStringSchema.parse(long);
+})
+    .add("nullable string", () => {
+    optionalNullableStringSchema.parse(long);
+})
+    .add("nullable (null) string", () => {
+    optionalNullableStringSchema.parse(null);
+})
+    .add("invalid: null", () => {
+    try {
+        stringSchema.parse(null);
+    }
+    catch (err) { }
+})
+    .add("manual parser: long", () => {
+    manual(long);
+})
+    .on("cycle", (e) => {
+    console.log(`${SUITE_NAME}: ${e.target}`);
+});
+exports.default = {
+    suites: [suite],
+};

cool-dawn-3d3b/node_modules/zod/lib/benchmarks/union.d.ts

@@ -0,0 +1,5 @@
+import Benchmark from "benchmark";
+declare const _default: {
+    suites: Benchmark.Suite[];
+};
+export default _default;

cool-dawn-3d3b/node_modules/zod/lib/benchmarks/union.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const benchmark_1 = __importDefault(require("benchmark"));
+const index_1 = require("../index");
+const doubleSuite = new benchmark_1.default.Suite("z.union: double");
+const manySuite = new benchmark_1.default.Suite("z.union: many");
+const aSchema = index_1.z.object({
+    type: index_1.z.literal("a"),
+});
+const objA = {
+    type: "a",
+};
+const bSchema = index_1.z.object({
+    type: index_1.z.literal("b"),
+});
+const objB = {
+    type: "b",
+};
+const cSchema = index_1.z.object({
+    type: index_1.z.literal("c"),
+});
+const objC = {
+    type: "c",
+};
+const dSchema = index_1.z.object({
+    type: index_1.z.literal("d"),
+});
+const double = index_1.z.union([aSchema, bSchema]);
+const many = index_1.z.union([aSchema, bSchema, cSchema, dSchema]);
+doubleSuite
+    .add("valid: a", () => {
+    double.parse(objA);
+})
+    .add("valid: b", () => {
+    double.parse(objB);
+})
+    .add("invalid: null", () => {
+    try {
+        double.parse(null);
+    }
+    catch (err) { }
+})
+    .add("invalid: wrong shape", () => {
+    try {
+        double.parse(objC);
+    }
+    catch (err) { }
+})
+    .on("cycle", (e) => {
+    console.log(`${doubleSuite.name}: ${e.target}`);
+});
+manySuite
+    .add("valid: a", () => {
+    many.parse(objA);
+})
+    .add("valid: c", () => {
+    many.parse(objC);
+})
+    .add("invalid: null", () => {
+    try {
+        many.parse(null);
+    }
+    catch (err) { }
+})
+    .add("invalid: wrong shape", () => {
+    try {
+        many.parse({ type: "unknown" });
+    }
+    catch (err) { }
+})
+    .on("cycle", (e) => {
+    console.log(`${manySuite.name}: ${e.target}`);
+});
+exports.default = {
+    suites: [doubleSuite, manySuite],
+};

cool-dawn-3d3b/node_modules/zod/lib/errors.d.ts

@@ -0,0 +1,5 @@
+import defaultErrorMap from "./locales/en";
+import type { ZodErrorMap } from "./ZodError";
+export { defaultErrorMap };
+export declare function setErrorMap(map: ZodErrorMap): void;
+export declare function getErrorMap(): ZodErrorMap;

cool-dawn-3d3b/node_modules/zod/lib/errors.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getErrorMap = exports.setErrorMap = exports.defaultErrorMap = void 0;
+const en_1 = __importDefault(require("./locales/en"));
+exports.defaultErrorMap = en_1.default;
+let overrideErrorMap = en_1.default;
+function setErrorMap(map) {
+    overrideErrorMap = map;
+}
+exports.setErrorMap = setErrorMap;
+function getErrorMap() {
+    return overrideErrorMap;
+}
+exports.getErrorMap = getErrorMap;

cool-dawn-3d3b/node_modules/zod/lib/external.d.ts

@@ -0,0 +1,6 @@
+export * from "./errors";
+export * from "./helpers/parseUtil";
+export * from "./helpers/typeAliases";
+export * from "./helpers/util";
+export * from "./types";
+export * from "./ZodError";

cool-dawn-3d3b/node_modules/zod/lib/external.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./errors"), exports);
+__exportStar(require("./helpers/parseUtil"), exports);
+__exportStar(require("./helpers/typeAliases"), exports);
+__exportStar(require("./helpers/util"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./ZodError"), exports);

cool-dawn-3d3b/node_modules/zod/lib/helpers/enumUtil.d.ts

@@ -0,0 +1,8 @@
+export declare namespace enumUtil {
+    type UnionToIntersectionFn<T> = (T extends unknown ? (k: () => T) => void : never) extends (k: infer Intersection) => void ? Intersection : never;
+    type GetUnionLast<T> = UnionToIntersectionFn<T> extends () => infer Last ? Last : never;
+    type UnionToTuple<T, Tuple extends unknown[] = []> = [T] extends [never] ? Tuple : UnionToTuple<Exclude<T, GetUnionLast<T>>, [GetUnionLast<T>, ...Tuple]>;
+    type CastToStringTuple<T> = T extends [string, ...string[]] ? T : never;
+    export type UnionToTupleString<T> = CastToStringTuple<UnionToTuple<T>>;
+    export {};
+}

cool-dawn-3d3b/node_modules/zod/lib/helpers/enumUtil.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

cool-dawn-3d3b/node_modules/zod/lib/helpers/errorUtil.d.ts

@@ -0,0 +1,9 @@
+export declare namespace errorUtil {
+    type ErrMessage = string | {
+        message?: string;
+    };
+    const errToObj: (message?: ErrMessage | undefined) => {
+        message?: string | undefined;
+    };
+    const toString: (message?: ErrMessage | undefined) => string | undefined;
+}

cool-dawn-3d3b/node_modules/zod/lib/helpers/errorUtil.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorUtil = void 0;
+var errorUtil;
+(function (errorUtil) {
+    errorUtil.errToObj = (message) => typeof message === "string" ? { message } : message || {};
+    errorUtil.toString = (message) => typeof message === "string" ? message : message === null || message === void 0 ? void 0 : message.message;
+})(errorUtil = exports.errorUtil || (exports.errorUtil = {}));

cool-dawn-3d3b/node_modules/zod/lib/helpers/parseUtil.d.ts

@@ -0,0 +1,78 @@
+import type { IssueData, ZodErrorMap, ZodIssue } from "../ZodError";
+import type { ZodParsedType } from "./util";
+export declare const makeIssue: (params: {
+    data: any;
+    path: (string | number)[];
+    errorMaps: ZodErrorMap[];
+    issueData: IssueData;
+}) => ZodIssue;
+export declare type ParseParams = {
+    path: (string | number)[];
+    errorMap: ZodErrorMap;
+    async: boolean;
+};
+export declare type ParsePathComponent = string | number;
+export declare type ParsePath = ParsePathComponent[];
+export declare const EMPTY_PATH: ParsePath;
+export interface ParseContext {
+    readonly common: {
+        readonly issues: ZodIssue[];
+        readonly contextualErrorMap?: ZodErrorMap;
+        readonly async: boolean;
+    };
+    readonly path: ParsePath;
+    readonly schemaErrorMap?: ZodErrorMap;
+    readonly parent: ParseContext | null;
+    readonly data: any;
+    readonly parsedType: ZodParsedType;
+}
+export declare type ParseInput = {
+    data: any;
+    path: (string | number)[];
+    parent: ParseContext;
+};
+export declare function addIssueToContext(ctx: ParseContext, issueData: IssueData): void;
+export declare type ObjectPair = {
+    key: SyncParseReturnType<any>;
+    value: SyncParseReturnType<any>;
+};
+export declare class ParseStatus {
+    value: "aborted" | "dirty" | "valid";
+    dirty(): void;
+    abort(): void;
+    static mergeArray(status: ParseStatus, results: SyncParseReturnType<any>[]): SyncParseReturnType;
+    static mergeObjectAsync(status: ParseStatus, pairs: {
+        key: ParseReturnType<any>;
+        value: ParseReturnType<any>;
+    }[]): Promise<SyncParseReturnType<any>>;
+    static mergeObjectSync(status: ParseStatus, pairs: {
+        key: SyncParseReturnType<any>;
+        value: SyncParseReturnType<any>;
+        alwaysSet?: boolean;
+    }[]): SyncParseReturnType;
+}
+export interface ParseResult {
+    status: "aborted" | "dirty" | "valid";
+    data: any;
+}
+export declare type INVALID = {
+    status: "aborted";
+};
+export declare const INVALID: INVALID;
+export declare type DIRTY<T> = {
+    status: "dirty";
+    value: T;
+};
+export declare const DIRTY: <T>(value: T) => DIRTY<T>;
+export declare type OK<T> = {
+    status: "valid";
+    value: T;
+};
+export declare const OK: <T>(value: T) => OK<T>;
+export declare type SyncParseReturnType<T = any> = OK<T> | DIRTY<T> | INVALID;
+export declare type AsyncParseReturnType<T> = Promise<SyncParseReturnType<T>>;
+export declare type ParseReturnType<T> = SyncParseReturnType<T> | AsyncParseReturnType<T>;
+export declare const isAborted: (x: ParseReturnType<any>) => x is INVALID;
+export declare const isDirty: <T>(x: ParseReturnType<T>) => x is OK<T> | DIRTY<T>;
+export declare const isValid: <T>(x: ParseReturnType<T>) => x is OK<T> | DIRTY<T>;
+export declare const isAsync: <T>(x: ParseReturnType<T>) => x is AsyncParseReturnType<T>;

cool-dawn-3d3b/node_modules/zod/lib/helpers/parseUtil.js

@@ -0,0 +1,115 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAsync = exports.isValid = exports.isDirty = exports.isAborted = exports.OK = exports.DIRTY = exports.INVALID = exports.ParseStatus = exports.addIssueToContext = exports.EMPTY_PATH = exports.makeIssue = void 0;
+const errors_1 = require("../errors");
+const en_1 = __importDefault(require("../locales/en"));
+const makeIssue = (params) => {
+    const { data, path, errorMaps, issueData } = params;
+    const fullPath = [...path, ...(issueData.path || [])];
+    const fullIssue = {
+        ...issueData,
+        path: fullPath,
+    };
+    let errorMessage = "";
+    const maps = errorMaps
+        .filter((m) => !!m)
+        .slice()
+        .reverse();
+    for (const map of maps) {
+        errorMessage = map(fullIssue, { data, defaultError: errorMessage }).message;
+    }
+    return {
+        ...issueData,
+        path: fullPath,
+        message: issueData.message || errorMessage,
+    };
+};
+exports.makeIssue = makeIssue;
+exports.EMPTY_PATH = [];
+function addIssueToContext(ctx, issueData) {
+    const issue = (0, exports.makeIssue)({
+        issueData: issueData,
+        data: ctx.data,
+        path: ctx.path,
+        errorMaps: [
+            ctx.common.contextualErrorMap,
+            ctx.schemaErrorMap,
+            (0, errors_1.getErrorMap)(),
+            en_1.default,
+        ].filter((x) => !!x),
+    });
+    ctx.common.issues.push(issue);
+}
+exports.addIssueToContext = addIssueToContext;
+class ParseStatus {
+    constructor() {
+        this.value = "valid";
+    }
+    dirty() {
+        if (this.value === "valid")
+            this.value = "dirty";
+    }
+    abort() {
+        if (this.value !== "aborted")
+            this.value = "aborted";
+    }
+    static mergeArray(status, results) {
+        const arrayValue = [];
+        for (const s of results) {
+            if (s.status === "aborted")
+                return exports.INVALID;
+            if (s.status === "dirty")
+                status.dirty();
+            arrayValue.push(s.value);
+        }
+        return { status: status.value, value: arrayValue };
+    }
+    static async mergeObjectAsync(status, pairs) {
+        const syncPairs = [];
+        for (const pair of pairs) {
+            syncPairs.push({
+                key: await pair.key,
+                value: await pair.value,
+            });
+        }
+        return ParseStatus.mergeObjectSync(status, syncPairs);
+    }
+    static mergeObjectSync(status, pairs) {
+        const finalObject = {};
+        for (const pair of pairs) {
+            const { key, value } = pair;
+            if (key.status === "aborted")
+                return exports.INVALID;
+            if (value.status === "aborted")
+                return exports.INVALID;
+            if (key.status === "dirty")
+                status.dirty();
+            if (value.status === "dirty")
+                status.dirty();
+            if (key.value !== "__proto__" &&
+                (typeof value.value !== "undefined" || pair.alwaysSet)) {
+                finalObject[key.value] = value.value;
+            }
+        }
+        return { status: status.value, value: finalObject };
+    }
+}
+exports.ParseStatus = ParseStatus;
+exports.INVALID = Object.freeze({
+    status: "aborted",
+});
+const DIRTY = (value) => ({ status: "dirty", value });
+exports.DIRTY = DIRTY;
+const OK = (value) => ({ status: "valid", value });
+exports.OK = OK;
+const isAborted = (x) => x.status === "aborted";
+exports.isAborted = isAborted;
+const isDirty = (x) => x.status === "dirty";
+exports.isDirty = isDirty;
+const isValid = (x) => x.status === "valid";
+exports.isValid = isValid;
+const isAsync = (x) => typeof Promise !== "undefined" && x instanceof Promise;
+exports.isAsync = isAsync;

cool-dawn-3d3b/node_modules/zod/lib/helpers/partialUtil.d.ts

@@ -0,0 +1,8 @@
+import type { ZodArray, ZodNullable, ZodObject, ZodOptional, ZodRawShape, ZodTuple, ZodTupleItems, ZodTypeAny } from "../index";
+export declare namespace partialUtil {
+    type DeepPartial<T extends ZodTypeAny> = T extends ZodObject<ZodRawShape> ? ZodObject<{
+        [k in keyof T["shape"]]: ZodOptional<DeepPartial<T["shape"][k]>>;
+    }, T["_def"]["unknownKeys"], T["_def"]["catchall"]> : T extends ZodArray<infer Type, infer Card> ? ZodArray<DeepPartial<Type>, Card> : T extends ZodOptional<infer Type> ? ZodOptional<DeepPartial<Type>> : T extends ZodNullable<infer Type> ? ZodNullable<DeepPartial<Type>> : T extends ZodTuple<infer Items> ? {
+        [k in keyof Items]: Items[k] extends ZodTypeAny ? DeepPartial<Items[k]> : never;
+    } extends infer PI ? PI extends ZodTupleItems ? ZodTuple<PI> : never : never : T;
+}

cool-dawn-3d3b/node_modules/zod/lib/helpers/partialUtil.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

cool-dawn-3d3b/node_modules/zod/lib/helpers/typeAliases.d.ts

@@ -0,0 +1,2 @@
+export declare type Primitive = string | number | symbol | bigint | boolean | null | undefined;
+export declare type Scalars = Primitive | Primitive[];

cool-dawn-3d3b/node_modules/zod/lib/helpers/typeAliases.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

cool-dawn-3d3b/node_modules/zod/lib/helpers/util.d.ts

@@ -0,0 +1,68 @@
+export declare namespace util {
+    type AssertEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2 ? true : false;
+    export type isAny<T> = 0 extends 1 & T ? true : false;
+    export const assertEqual: <A, B>(val: AssertEqual<A, B>) => AssertEqual<A, B>;
+    export function assertIs<T>(_arg: T): void;
+    export function assertNever(_x: never): never;
+    export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+    export type OmitKeys<T, K extends string> = Pick<T, Exclude<keyof T, K>>;
+    export type MakePartial<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+    export const arrayToEnum: <T extends string, U extends [T, ...T[]]>(items: U) => { [k in U[number]]: k; };
+    export const getValidEnumValues: (obj: any) => any[];
+    export const objectValues: (obj: any) => any[];
+    export const objectKeys: ObjectConstructor["keys"];
+    export const find: <T>(arr: T[], checker: (arg: T) => any) => T | undefined;
+    export type identity<T> = objectUtil.identity<T>;
+    export type flatten<T> = objectUtil.flatten<T>;
+    export type noUndefined<T> = T extends undefined ? never : T;
+    export const isInteger: NumberConstructor["isInteger"];
+    export function joinValues<T extends any[]>(array: T, separator?: string): string;
+    export const jsonStringifyReplacer: (_: string, value: any) => any;
+    export {};
+}
+export declare namespace objectUtil {
+    export type MergeShapes<U, V> = {
+        [k in Exclude<keyof U, keyof V>]: U[k];
+    } & V;
+    type requiredKeys<T extends object> = {
+        [k in keyof T]: undefined extends T[k] ? never : k;
+    }[keyof T];
+    export type addQuestionMarks<T extends object, R extends keyof T = requiredKeys<T>> = Pick<Required<T>, R> & Partial<T>;
+    export type identity<T> = T;
+    export type flatten<T> = identity<{
+        [k in keyof T]: T[k];
+    }>;
+    export type noNeverKeys<T> = {
+        [k in keyof T]: [T[k]] extends [never] ? never : k;
+    }[keyof T];
+    export type noNever<T> = identity<{
+        [k in noNeverKeys<T>]: k extends keyof T ? T[k] : never;
+    }>;
+    export const mergeShapes: <U, T>(first: U, second: T) => T & U;
+    export type extendShape<A, B> = flatten<Omit<A, keyof B> & B>;
+    export {};
+}
+export declare const ZodParsedType: {
+    function: "function";
+    number: "number";
+    string: "string";
+    nan: "nan";
+    integer: "integer";
+    float: "float";
+    boolean: "boolean";
+    date: "date";
+    bigint: "bigint";
+    symbol: "symbol";
+    undefined: "undefined";
+    null: "null";
+    array: "array";
+    object: "object";
+    unknown: "unknown";
+    promise: "promise";
+    void: "void";
+    never: "never";
+    map: "map";
+    set: "set";
+};
+export declare type ZodParsedType = keyof typeof ZodParsedType;
+export declare const getParsedType: (data: any) => ZodParsedType;

cool-dawn-3d3b/node_modules/zod/lib/helpers/util.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getParsedType = exports.ZodParsedType = exports.objectUtil = exports.util = void 0;
+var util;
+(function (util) {
+    util.assertEqual = (val) => val;
+    function assertIs(_arg) { }
+    util.assertIs = assertIs;
+    function assertNever(_x) {
+        throw new Error();
+    }
+    util.assertNever = assertNever;
+    util.arrayToEnum = (items) => {
+        const obj = {};
+        for (const item of items) {
+            obj[item] = item;
+        }
+        return obj;
+    };
+    util.getValidEnumValues = (obj) => {
+        const validKeys = util.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
+        const filtered = {};
+        for (const k of validKeys) {
+            filtered[k] = obj[k];
+        }
+        return util.objectValues(filtered);
+    };
+    util.objectValues = (obj) => {
+        return util.objectKeys(obj).map(function (e) {
+            return obj[e];
+        });
+    };
+    util.objectKeys = typeof Object.keys === "function"
+        ? (obj) => Object.keys(obj)
+        : (object) => {
+            const keys = [];
+            for (const key in object) {
+                if (Object.prototype.hasOwnProperty.call(object, key)) {
+                    keys.push(key);
+                }
+            }
+            return keys;
+        };
+    util.find = (arr, checker) => {
+        for (const item of arr) {
+            if (checker(item))
+                return item;
+        }
+        return undefined;
+    };
+    util.isInteger = typeof Number.isInteger === "function"
+        ? (val) => Number.isInteger(val)
+        : (val) => typeof val === "number" && isFinite(val) && Math.floor(val) === val;
+    function joinValues(array, separator = " | ") {
+        return array
+            .map((val) => (typeof val === "string" ? `'${val}'` : val))
+            .join(separator);
+    }
+    util.joinValues = joinValues;
+    util.jsonStringifyReplacer = (_, value) => {
+        if (typeof value === "bigint") {
+            return value.toString();
+        }
+        return value;
+    };
+})(util = exports.util || (exports.util = {}));
+var objectUtil;
+(function (objectUtil) {
+    objectUtil.mergeShapes = (first, second) => {
+        return {
+            ...first,
+            ...second,
+        };
+    };
+})(objectUtil = exports.objectUtil || (exports.objectUtil = {}));
+exports.ZodParsedType = util.arrayToEnum([
+    "string",
+    "nan",
+    "number",
+    "integer",
+    "float",
+    "boolean",
+    "date",
+    "bigint",
+    "symbol",
+    "function",
+    "undefined",
+    "null",
+    "array",
+    "object",
+    "unknown",
+    "promise",
+    "void",
+    "never",
+    "map",
+    "set",
+]);
+const getParsedType = (data) => {
+    const t = typeof data;
+    switch (t) {
+        case "undefined":
+            return exports.ZodParsedType.undefined;
+        case "string":
+            return exports.ZodParsedType.string;
+        case "number":
+            return isNaN(data) ? exports.ZodParsedType.nan : exports.ZodParsedType.number;
+        case "boolean":
+            return exports.ZodParsedType.boolean;
+        case "function":
+            return exports.ZodParsedType.function;
+        case "bigint":
+            return exports.ZodParsedType.bigint;
+        case "symbol":
+            return exports.ZodParsedType.symbol;
+        case "object":
+            if (Array.isArray(data)) {
+                return exports.ZodParsedType.array;
+            }
+            if (data === null) {
+                return exports.ZodParsedType.null;
+            }
+            if (data.then &&
+                typeof data.then === "function" &&
+                data.catch &&
+                typeof data.catch === "function") {
+                return exports.ZodParsedType.promise;
+            }
+            if (typeof Map !== "undefined" && data instanceof Map) {
+                return exports.ZodParsedType.map;
+            }
+            if (typeof Set !== "undefined" && data instanceof Set) {
+                return exports.ZodParsedType.set;
+            }
+            if (typeof Date !== "undefined" && data instanceof Date) {
+                return exports.ZodParsedType.date;
+            }
+            return exports.ZodParsedType.object;
+        default:
+            return exports.ZodParsedType.unknown;
+    }
+};
+exports.getParsedType = getParsedType;

cool-dawn-3d3b/node_modules/zod/lib/index.d.ts

@@ -0,0 +1,4 @@
+import * as z from "./external";
+export * from "./external";
+export { z };
+export default z;

cool-dawn-3d3b/node_modules/zod/lib/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.z = void 0;
+const z = __importStar(require("./external"));
+exports.z = z;
+__exportStar(require("./external"), exports);
+exports.default = z;

cool-dawn-3d3b/node_modules/zod/lib/locales/en.d.ts

@@ -0,0 +1,3 @@
+import { ZodErrorMap } from "../ZodError";
+declare const errorMap: ZodErrorMap;
+export default errorMap;

cool-dawn-3d3b/node_modules/zod/lib/locales/en.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../helpers/util");
+const ZodError_1 = require("../ZodError");
+const errorMap = (issue, _ctx) => {
+    let message;
+    switch (issue.code) {
+        case ZodError_1.ZodIssueCode.invalid_type:
+            if (issue.received === util_1.ZodParsedType.undefined) {
+                message = "Required";
+            }
+            else {
+                message = `Expected ${issue.expected}, received ${issue.received}`;
+            }
+            break;
+        case ZodError_1.ZodIssueCode.invalid_literal:
+            message = `Invalid literal value, expected ${JSON.stringify(issue.expected, util_1.util.jsonStringifyReplacer)}`;
+            break;
+        case ZodError_1.ZodIssueCode.unrecognized_keys:
+            message = `Unrecognized key(s) in object: ${util_1.util.joinValues(issue.keys, ", ")}`;
+            break;
+        case ZodError_1.ZodIssueCode.invalid_union:
+            message = `Invalid input`;
+            break;
+        case ZodError_1.ZodIssueCode.invalid_union_discriminator:
+            message = `Invalid discriminator value. Expected ${util_1.util.joinValues(issue.options)}`;
+            break;
+        case ZodError_1.ZodIssueCode.invalid_enum_value:
+            message = `Invalid enum value. Expected ${util_1.util.joinValues(issue.options)}, received '${issue.received}'`;
+            break;
+        case ZodError_1.ZodIssueCode.invalid_arguments:
+            message = `Invalid function arguments`;
+            break;
+        case ZodError_1.ZodIssueCode.invalid_return_type:
+            message = `Invalid function return type`;
+            break;
+        case ZodError_1.ZodIssueCode.invalid_date:
+            message = `Invalid date`;
+            break;
+        case ZodError_1.ZodIssueCode.invalid_string:
+            if (typeof issue.validation === "object") {
+                if ("includes" in issue.validation) {
+                    message = `Invalid input: must include "${issue.validation.includes}"`;
+                    if (typeof issue.validation.position === "number") {
+                        message = `${message} at one or more positions greater than or equal to ${issue.validation.position}`;
+                    }
+                }
+                else if ("startsWith" in issue.validation) {
+                    message = `Invalid input: must start with "${issue.validation.startsWith}"`;
+                }
+                else if ("endsWith" in issue.validation) {
+                    message = `Invalid input: must end with "${issue.validation.endsWith}"`;
+                }
+                else {
+                    util_1.util.assertNever(issue.validation);
+                }
+            }
+            else if (issue.validation !== "regex") {
+                message = `Invalid ${issue.validation}`;
+            }
+            else {
+                message = "Invalid";
+            }
+            break;
+        case ZodError_1.ZodIssueCode.too_small:
+            if (issue.type === "array")
+                message = `Array must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `more than`} ${issue.minimum} element(s)`;
+            else if (issue.type === "string")
+                message = `String must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `over`} ${issue.minimum} character(s)`;
+            else if (issue.type === "number")
+                message = `Number must be ${issue.exact
+                    ? `exactly equal to `
+                    : issue.inclusive
+                        ? `greater than or equal to `
+                        : `greater than `}${issue.minimum}`;
+            else if (issue.type === "date")
+                message = `Date must be ${issue.exact
+                    ? `exactly equal to `
+                    : issue.inclusive
+                        ? `greater than or equal to `
+                        : `greater than `}${new Date(Number(issue.minimum))}`;
+            else
+                message = "Invalid input";
+            break;
+        case ZodError_1.ZodIssueCode.too_big:
+            if (issue.type === "array")
+                message = `Array must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `less than`} ${issue.maximum} element(s)`;
+            else if (issue.type === "string")
+                message = `String must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `under`} ${issue.maximum} character(s)`;
+            else if (issue.type === "number")
+                message = `Number must be ${issue.exact
+                    ? `exactly`
+                    : issue.inclusive
+                        ? `less than or equal to`
+                        : `less than`} ${issue.maximum}`;
+            else if (issue.type === "bigint")
+                message = `BigInt must be ${issue.exact
+                    ? `exactly`
+                    : issue.inclusive
+                        ? `less than or equal to`
+                        : `less than`} ${issue.maximum}`;
+            else if (issue.type === "date")
+                message = `Date must be ${issue.exact
+                    ? `exactly`
+                    : issue.inclusive
+                        ? `smaller than or equal to`
+                        : `smaller than`} ${new Date(Number(issue.maximum))}`;
+            else
+                message = "Invalid input";
+            break;
+        case ZodError_1.ZodIssueCode.custom:
+            message = `Invalid input`;
+            break;
+        case ZodError_1.ZodIssueCode.invalid_intersection_types:
+            message = `Intersection results could not be merged`;
+            break;
+        case ZodError_1.ZodIssueCode.not_multiple_of:
+            message = `Number must be a multiple of ${issue.multipleOf}`;
+            break;
+        case ZodError_1.ZodIssueCode.not_finite:
+            message = "Number must be finite";
+            break;
+        default:
+            message = _ctx.defaultError;
+            util_1.util.assertNever(issue);
+    }
+    return { message };
+};
+exports.default = errorMap;