zod 3.25.0 → 3.25.3

package/dist/commonjs/v4/core/util.d.ts

@@ -0,0 +1,186 @@
+import type * as checks from "./checks.js";
+import type { $ZodConfig } from "./core.js";
+import type * as errors from "./errors.js";
+import type * as schemas from "./schemas.js";
+export type JSONType = string | number | boolean | null | JSONType[] | {
+    [key: string]: JSONType;
+};
+export type JWTAlgorithm = "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "ES256" | "ES384" | "ES512" | "PS256" | "PS384" | "PS512";
+export type IPVersion = "v4" | "v6";
+export type MimeTypes = "application/json" | "application/xml" | "application/x-www-form-urlencoded" | "application/javascript" | "application/pdf" | "application/zip" | "application/vnd.ms-excel" | "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" | "application/msword" | "application/vnd.openxmlformats-officedocument.wordprocessingml.document" | "application/vnd.ms-powerpoint" | "application/vnd.openxmlformats-officedocument.presentationml.presentation" | "application/octet-stream" | "application/graphql" | "text/html" | "text/plain" | "text/css" | "text/javascript" | "text/csv" | "image/png" | "image/jpeg" | "image/gif" | "image/svg+xml" | "image/webp" | "audio/mpeg" | "audio/ogg" | "audio/wav" | "audio/webm" | "video/mp4" | "video/webm" | "video/ogg" | "font/woff" | "font/woff2" | "font/ttf" | "font/otf" | "multipart/form-data" | (string & {});
+export type ParsedTypes = "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" | "file" | "date" | "array" | "map" | "set" | "nan" | "null" | "promise";
+export type AssertEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2 ? true : false;
+export type AssertNotEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2 ? false : true;
+export type AssertExtends<T, U> = T extends U ? T : never;
+export type IsAny<T> = 0 extends 1 & T ? true : false;
+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> & InexactPartial<Pick<T, K>>;
+export type MakeRequired<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
+export type Exactly<T, X> = T & Record<Exclude<keyof X, keyof T>, never>;
+export type NoUndefined<T> = T extends undefined ? never : T;
+export type Whatever = {} | undefined | null;
+export type LoosePartial<T extends object> = InexactPartial<T> & {
+    [k: string]: unknown;
+};
+export type Mask<Keys extends PropertyKey> = {
+    [K in Keys]?: true;
+};
+export type Writeable<T> = {
+    -readonly [P in keyof T]: T[P];
+} & {};
+export type InexactPartial<T> = {
+    [P in keyof T]?: T[P] | undefined;
+};
+export type EmptyObject = Record<string, never>;
+export type BuiltIn = (((...args: any[]) => any) | (new (...args: any[]) => any)) | {
+    readonly [Symbol.toStringTag]: string;
+} | Date | Error | Generator | Promise<unknown> | RegExp;
+export type MakeReadonly<T> = T extends Map<infer K, infer V> ? ReadonlyMap<K, V> : T extends Set<infer V> ? ReadonlySet<V> : T extends [infer Head, ...infer Tail] ? readonly [Head, ...Tail] : T extends Array<infer V> ? ReadonlyArray<V> : T extends BuiltIn ? T : Readonly<T>;
+export type SomeObject = Record<PropertyKey, any>;
+export type Identity<T> = T;
+export type Flatten<T> = Identity<{
+    [k in keyof T]: T[k];
+}>;
+export type Mapped<T> = {
+    [k in keyof T]: T[k];
+};
+export type Prettify<T> = {
+    [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 type Extend<A extends SomeObject, B extends SomeObject> = Flatten<keyof A & keyof B extends never ? A & B : {
+    [K in keyof A as K extends keyof B ? never : K]: A[K];
+} & {
+    [K in keyof B]: B[K];
+}>;
+export type TupleItems = ReadonlyArray<schemas.$ZodType>;
+export type AnyFunc = (...args: any[]) => any;
+export type IsProp<T, K extends keyof T> = T[K] extends AnyFunc ? never : K;
+export type MaybeAsync<T> = T | Promise<T>;
+export type KeyOf<T> = keyof OmitIndexSignature<T>;
+export type OmitIndexSignature<T> = {
+    [K in keyof T as string extends K ? never : K extends string ? K : never]: T[K];
+};
+export type ExtractIndexSignature<T> = {
+    [K in keyof T as string extends K ? K : K extends string ? never : K]: T[K];
+};
+export type Keys<T extends object> = keyof OmitIndexSignature<T>;
+export type SchemaClass<T extends schemas.$ZodType> = {
+    new (def: T["_zod"]["def"]): T;
+};
+export type EnumValue = string | number;
+export type EnumLike = Readonly<Record<string, EnumValue>>;
+export type ToEnum<T extends EnumValue> = Flatten<{
+    [k in T]: k;
+}>;
+export type KeysEnum<T extends object> = ToEnum<Exclude<keyof T, symbol>>;
+export type KeysArray<T extends object> = Flatten<(keyof T & string)[]>;
+export type Literal = string | number | bigint | boolean | null | undefined;
+export type LiteralArray = Array<Literal>;
+export type Primitive = string | number | symbol | bigint | boolean | null | undefined;
+export type PrimitiveArray = Array<Primitive>;
+export type HasSize = {
+    size: number;
+};
+export type HasLength = {
+    length: number;
+};
+export type Numeric = number | bigint | Date;
+export type SafeParseResult<T> = SafeParseSuccess<T> | SafeParseError<T>;
+export type SafeParseSuccess<T> = {
+    success: true;
+    data: T;
+    error?: never;
+};
+export type SafeParseError<T> = {
+    success: false;
+    data?: never;
+    error: errors.$ZodError<T>;
+};
+export type DiscriminatorMapElement = {
+    values: Set<Primitive>;
+    maps: DiscriminatorMap[];
+};
+export type DiscriminatorMap = Map<PropertyKey, DiscriminatorMapElement>;
+export type PrimitiveSet = Set<Primitive>;
+export declare function assertEqual<A, B>(val: AssertEqual<A, B>): AssertEqual<A, B>;
+export declare function assertNotEqual<A, B>(val: AssertNotEqual<A, B>): AssertNotEqual<A, B>;
+export declare function assertIs<T>(_arg: T): void;
+export declare function assertNever(_x: never): never;
+export declare function assert<T>(_: any): asserts _ is T;
+export declare function getValidEnumValues(obj: any): any;
+export declare function joinValues<T extends Primitive[]>(array: T, separator?: string): string;
+export declare function jsonStringifyReplacer(_: string, value: any): any;
+export declare function cached<T>(getter: () => T): {
+    value: T;
+};
+export declare function nullish(input: any): boolean;
+export declare function cleanRegex(source: string): string;
+export declare function floatSafeRemainder(val: number, step: number): number;
+export declare function defineLazy<T, K extends keyof T>(object: T, key: K, getter: () => T[K]): void;
+export declare function assignProp<T extends object, K extends PropertyKey>(target: T, prop: K, value: K extends keyof T ? T[K] : any): void;
+export declare function getElementAtPath(obj: any, path: (string | number)[] | null | undefined): any;
+export declare function promiseAllObject<T extends object>(promisesObj: T): Promise<{
+    [k in keyof T]: Awaited<T[k]>;
+}>;
+export declare function randomString(length?: number): string;
+export declare function esc(str: string): string;
+export declare function isObject(data: any): data is Record<PropertyKey, unknown>;
+export declare const allowsEval: {
+    value: boolean;
+};
+export declare function isPlainObject(data: any): data is Record<PropertyKey, unknown>;
+export declare function numKeys(data: any): number;
+export declare const getParsedType: (data: any) => ParsedTypes;
+export declare const propertyKeyTypes: Set<string>;
+export declare const primitiveTypes: Set<string>;
+export declare function escapeRegex(str: string): string;
+export declare function clone<T extends schemas.$ZodType>(inst: T, def?: T["_zod"]["def"], params?: {
+    parent: boolean;
+}): T;
+export type EmptyToNever<T> = keyof T extends never ? never : T;
+export type Normalize<T> = T extends undefined ? never : T extends Record<any, any> ? Flatten<{
+    [k in keyof Omit<T, "error" | "message">]: T[k];
+} & ("error" extends keyof T ? {
+    error?: Exclude<T["error"], string>;
+} : unknown)> : never;
+export declare function normalizeParams<T>(_params: T): Normalize<T>;
+export declare function createTransparentProxy<T extends object>(getter: () => T): T;
+export declare function stringifyPrimitive(value: any): string;
+export declare function optionalKeys(shape: schemas.$ZodShape): string[];
+export type CleanKey<T extends PropertyKey> = T extends `?${infer K}` ? K : T extends `${infer K}?` ? K : T;
+export type ToCleanMap<T extends schemas.$ZodLooseShape> = {
+    [k in keyof T]: k extends `?${infer K}` ? K : k extends `${infer K}?` ? K : k;
+};
+export type FromCleanMap<T extends schemas.$ZodLooseShape> = {
+    [k in keyof T as k extends `?${infer K}` ? K : k extends `${infer K}?` ? K : k]: k;
+};
+export declare const NUMBER_FORMAT_RANGES: Record<checks.$ZodNumberFormats, [number, number]>;
+export declare const BIGINT_FORMAT_RANGES: Record<checks.$ZodBigIntFormats, [bigint, bigint]>;
+export declare function pick(schema: schemas.$ZodObject, mask: Record<string, unknown>): any;
+export declare function omit(schema: schemas.$ZodObject, mask: object): any;
+export declare function extend(schema: schemas.$ZodObject, shape: schemas.$ZodShape): any;
+export declare function merge(a: schemas.$ZodObject, b: schemas.$ZodObject): any;
+export declare function partial(Class: SchemaClass<schemas.$ZodOptional> | null, schema: schemas.$ZodObject, mask: object | undefined): any;
+export declare function required(Class: SchemaClass<schemas.$ZodNonOptional>, schema: schemas.$ZodObject, mask: object | undefined): any;
+export type Constructor<T, Def extends any[] = any[]> = new (...args: Def) => T;
+export declare function aborted(x: schemas.ParsePayload, startIndex?: number): boolean;
+export declare function prefixIssues(path: PropertyKey, issues: errors.$ZodRawIssue[]): errors.$ZodRawIssue[];
+export declare function unwrapMessage(message: string | {
+    message: string;
+} | undefined | null): string | undefined;
+export declare function finalizeIssue(iss: errors.$ZodRawIssue, ctx: schemas.ParseContextInternal | undefined, config: $ZodConfig): errors.$ZodIssue;
+export declare function getSizableOrigin(input: any): "set" | "map" | "file" | "unknown";
+export declare function getLengthableOrigin(input: any): "array" | "string" | "unknown";
+export declare function issue(_iss: string, input: any, inst: any): errors.$ZodRawIssue;
+export declare function issue(_iss: errors.$ZodRawIssue): errors.$ZodRawIssue;
+export declare function cleanEnum(obj: Record<string, EnumValue>): EnumValue[];
+export declare abstract class Class {
+    constructor(..._args: any[]);
+}

package/dist/commonjs/v4/core/util.js

@@ -0,0 +1,515 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Class = exports.BIGINT_FORMAT_RANGES = exports.NUMBER_FORMAT_RANGES = exports.primitiveTypes = exports.propertyKeyTypes = exports.getParsedType = exports.allowsEval = void 0;
+exports.assertEqual = assertEqual;
+exports.assertNotEqual = assertNotEqual;
+exports.assertIs = assertIs;
+exports.assertNever = assertNever;
+exports.assert = assert;
+exports.getValidEnumValues = getValidEnumValues;
+exports.joinValues = joinValues;
+exports.jsonStringifyReplacer = jsonStringifyReplacer;
+exports.cached = cached;
+exports.nullish = nullish;
+exports.cleanRegex = cleanRegex;
+exports.floatSafeRemainder = floatSafeRemainder;
+exports.defineLazy = defineLazy;
+exports.assignProp = assignProp;
+exports.getElementAtPath = getElementAtPath;
+exports.promiseAllObject = promiseAllObject;
+exports.randomString = randomString;
+exports.esc = esc;
+exports.isObject = isObject;
+exports.isPlainObject = isPlainObject;
+exports.numKeys = numKeys;
+exports.escapeRegex = escapeRegex;
+exports.clone = clone;
+exports.normalizeParams = normalizeParams;
+exports.createTransparentProxy = createTransparentProxy;
+exports.stringifyPrimitive = stringifyPrimitive;
+exports.optionalKeys = optionalKeys;
+exports.pick = pick;
+exports.omit = omit;
+exports.extend = extend;
+exports.merge = merge;
+exports.partial = partial;
+exports.required = required;
+exports.aborted = aborted;
+exports.prefixIssues = prefixIssues;
+exports.unwrapMessage = unwrapMessage;
+exports.finalizeIssue = finalizeIssue;
+exports.getSizableOrigin = getSizableOrigin;
+exports.getLengthableOrigin = getLengthableOrigin;
+exports.issue = issue;
+exports.cleanEnum = cleanEnum;
+// functions
+function assertEqual(val) {
+    return val;
+}
+function assertNotEqual(val) {
+    return val;
+}
+function assertIs(_arg) { }
+function assertNever(_x) {
+    throw new Error();
+}
+function assert(_) { }
+function getValidEnumValues(obj) {
+    const validKeys = Object.keys(obj).filter((k) => typeof obj[obj[k]] !== "number");
+    const filtered = {};
+    for (const k of validKeys) {
+        filtered[k] = obj[k];
+    }
+    return Object.values(filtered);
+}
+function joinValues(array, separator = "|") {
+    return array.map((val) => stringifyPrimitive(val)).join(separator);
+}
+function jsonStringifyReplacer(_, value) {
+    if (typeof value === "bigint")
+        return value.toString();
+    return value;
+}
+function cached(getter) {
+    const set = false;
+    return {
+        get value() {
+            if (!set) {
+                const value = getter();
+                Object.defineProperty(this, "value", { value });
+                return value;
+            }
+            throw new Error("cached value already set");
+        },
+    };
+}
+function nullish(input) {
+    return input === null || input === undefined;
+}
+function cleanRegex(source) {
+    const start = source.startsWith("^") ? 1 : 0;
+    const end = source.endsWith("$") ? source.length - 1 : source.length;
+    return source.slice(start, end);
+}
+function floatSafeRemainder(val, step) {
+    const valDecCount = (val.toString().split(".")[1] || "").length;
+    const stepDecCount = (step.toString().split(".")[1] || "").length;
+    const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
+    const valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
+    const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
+    return (valInt % stepInt) / 10 ** decCount;
+}
+function defineLazy(object, key, getter) {
+    const set = false;
+    Object.defineProperty(object, key, {
+        get() {
+            if (!set) {
+                const value = getter();
+                object[key] = value;
+                return value;
+            }
+            throw new Error("cached value already set");
+        },
+        set(v) {
+            Object.defineProperty(object, key, {
+                value: v,
+                // configurable: true,
+            });
+            // object[key] = v;
+        },
+        configurable: true,
+    });
+}
+function assignProp(target, prop, value) {
+    Object.defineProperty(target, prop, {
+        value,
+        writable: true,
+        enumerable: true,
+        configurable: true,
+    });
+}
+function getElementAtPath(obj, path) {
+    if (!path)
+        return obj;
+    return path.reduce((acc, key) => acc?.[key], obj);
+}
+function promiseAllObject(promisesObj) {
+    const keys = Object.keys(promisesObj);
+    const promises = keys.map((key) => promisesObj[key]);
+    return Promise.all(promises).then((results) => {
+        const resolvedObj = {};
+        for (let i = 0; i < keys.length; i++) {
+            resolvedObj[keys[i]] = results[i];
+        }
+        return resolvedObj;
+    });
+}
+function randomString(length = 10) {
+    const chars = "abcdefghijklmnopqrstuvwxyz";
+    let str = "";
+    for (let i = 0; i < length; i++) {
+        str += chars[Math.floor(Math.random() * chars.length)];
+    }
+    return str;
+}
+function esc(str) {
+    return JSON.stringify(str);
+}
+function isObject(data) {
+    return typeof data === "object" && data !== null;
+}
+exports.allowsEval = cached(() => {
+    try {
+        const F = Function;
+        new F("");
+        return true;
+    }
+    catch (_) {
+        return false;
+    }
+});
+function isPlainObject(data) {
+    return typeof data === "object" && data !== null && Object.getPrototypeOf(data) === Object.prototype;
+}
+function numKeys(data) {
+    let keyCount = 0;
+    for (const key in data) {
+        if (Object.prototype.hasOwnProperty.call(data, key)) {
+            keyCount++;
+        }
+    }
+    return keyCount;
+}
+const getParsedType = (data) => {
+    const t = typeof data;
+    switch (t) {
+        case "undefined":
+            return "undefined";
+        case "string":
+            return "string";
+        case "number":
+            return Number.isNaN(data) ? "nan" : "number";
+        case "boolean":
+            return "boolean";
+        case "function":
+            return "function";
+        case "bigint":
+            return "bigint";
+        case "symbol":
+            return "symbol";
+        case "object":
+            if (Array.isArray(data)) {
+                return "array";
+            }
+            if (data === null) {
+                return "null";
+            }
+            if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
+                return "promise";
+            }
+            if (typeof Map !== "undefined" && data instanceof Map) {
+                return "map";
+            }
+            if (typeof Set !== "undefined" && data instanceof Set) {
+                return "set";
+            }
+            if (typeof Date !== "undefined" && data instanceof Date) {
+                return "date";
+            }
+            if (typeof File !== "undefined" && data instanceof File) {
+                return "file";
+            }
+            return "object";
+        default:
+            throw new Error(`Unknown data type: ${t}`);
+    }
+};
+exports.getParsedType = getParsedType;
+exports.propertyKeyTypes = new Set(["string", "number", "symbol"]);
+exports.primitiveTypes = new Set(["string", "number", "bigint", "boolean", "symbol", "undefined"]);
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+// zod-specific utils
+function clone(inst, def, params) {
+    const cl = new inst._zod.constr(def ?? inst._zod.def);
+    if (!def || params?.parent)
+        cl._zod.parent = inst;
+    return cl;
+}
+function normalizeParams(_params) {
+    const params = _params;
+    if (!params)
+        return {};
+    if (typeof params === "string")
+        return { error: () => params };
+    if (params?.message !== undefined) {
+        if (params?.error !== undefined)
+            throw new Error("Cannot specify both `message` and `error` params");
+        params.error = params.message;
+    }
+    delete params.message;
+    if (typeof params.error === "string")
+        return { ...params, error: () => params.error };
+    return params;
+}
+function createTransparentProxy(getter) {
+    let target;
+    return new Proxy({}, {
+        get(_, prop, receiver) {
+            target ?? (target = getter());
+            return Reflect.get(target, prop, receiver);
+        },
+        set(_, prop, value, receiver) {
+            target ?? (target = getter());
+            return Reflect.set(target, prop, value, receiver);
+        },
+        has(_, prop) {
+            target ?? (target = getter());
+            return Reflect.has(target, prop);
+        },
+        deleteProperty(_, prop) {
+            target ?? (target = getter());
+            return Reflect.deleteProperty(target, prop);
+        },
+        ownKeys(_) {
+            target ?? (target = getter());
+            return Reflect.ownKeys(target);
+        },
+        getOwnPropertyDescriptor(_, prop) {
+            target ?? (target = getter());
+            return Reflect.getOwnPropertyDescriptor(target, prop);
+        },
+        defineProperty(_, prop, descriptor) {
+            target ?? (target = getter());
+            return Reflect.defineProperty(target, prop, descriptor);
+        },
+    });
+}
+function stringifyPrimitive(value) {
+    if (typeof value === "bigint")
+        return value.toString() + "n";
+    if (typeof value === "string")
+        return `"${value}"`;
+    return `${value}`;
+}
+function optionalKeys(shape) {
+    return Object.keys(shape).filter((k) => {
+        return shape[k]._zod.optin === "optional";
+    });
+}
+exports.NUMBER_FORMAT_RANGES = {
+    safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
+    int32: [-2147483648, 2147483647],
+    uint32: [0, 4294967295],
+    float32: [-3.4028234663852886e38, 3.4028234663852886e38],
+    float64: [-Number.MAX_VALUE, Number.MAX_VALUE],
+};
+exports.BIGINT_FORMAT_RANGES = {
+    int64: [/* @__PURE__*/ BigInt("-9223372036854775808"), /* @__PURE__*/ BigInt("9223372036854775807")],
+    uint64: [/* @__PURE__*/ BigInt(0), /* @__PURE__*/ BigInt("18446744073709551615")],
+};
+function pick(schema, mask) {
+    const newShape = {};
+    const currDef = schema._zod.def; //.shape;
+    for (const key in mask) {
+        if (!(key in currDef.shape)) {
+            throw new Error(`Unrecognized key: "${key}"`);
+        }
+        if (!mask[key])
+            continue;
+        // pick key
+        newShape[key] = currDef.shape[key];
+    }
+    return clone(schema, {
+        ...schema._zod.def,
+        shape: newShape,
+        checks: [],
+    });
+}
+function omit(schema, mask) {
+    const newShape = { ...schema._zod.def.shape };
+    const currDef = schema._zod.def; //.shape;
+    for (const key in mask) {
+        if (!(key in currDef.shape)) {
+            throw new Error(`Unrecognized key: "${key}"`);
+        }
+        if (!mask[key])
+            continue;
+        delete newShape[key];
+    }
+    return clone(schema, {
+        ...schema._zod.def,
+        shape: newShape,
+        checks: [],
+    });
+}
+function extend(schema, shape) {
+    const def = {
+        ...schema._zod.def,
+        get shape() {
+            const _shape = { ...schema._zod.def.shape, ...shape };
+            assignProp(this, "shape", _shape); // self-caching
+            return _shape;
+        },
+        checks: [], // delete existing checks
+    };
+    return clone(schema, def);
+}
+function merge(a, b) {
+    return clone(a, {
+        ...a._zod.def,
+        get shape() {
+            const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };
+            assignProp(this, "shape", _shape); // self-caching
+            return _shape;
+        },
+        catchall: b._zod.def.catchall,
+        checks: [], // delete existing checks
+    });
+}
+function partial(Class, schema, mask) {
+    const oldShape = schema._zod.def.shape;
+    const shape = { ...oldShape };
+    if (mask) {
+        for (const key in mask) {
+            if (!(key in oldShape)) {
+                throw new Error(`Unrecognized key: "${key}"`);
+            }
+            if (!mask[key])
+                continue;
+            shape[key] = Class
+                ? new Class({
+                    type: "optional",
+                    innerType: oldShape[key],
+                })
+                : oldShape[key];
+        }
+    }
+    else {
+        for (const key in oldShape) {
+            shape[key] = Class
+                ? new Class({
+                    type: "optional",
+                    innerType: oldShape[key],
+                })
+                : oldShape[key];
+        }
+    }
+    return clone(schema, {
+        ...schema._zod.def,
+        shape,
+        checks: [],
+    });
+}
+function required(Class, schema, mask) {
+    const oldShape = schema._zod.def.shape;
+    const shape = { ...oldShape };
+    if (mask) {
+        for (const key in mask) {
+            if (!(key in shape)) {
+                throw new Error(`Unrecognized key: "${key}"`);
+            }
+            if (!mask[key])
+                continue;
+            // overwrite with non-optional
+            shape[key] = new Class({
+                type: "nonoptional",
+                innerType: oldShape[key],
+            });
+        }
+    }
+    else {
+        for (const key in oldShape) {
+            // overwrite with non-optional
+            shape[key] = new Class({
+                type: "nonoptional",
+                innerType: oldShape[key],
+            });
+        }
+    }
+    return clone(schema, {
+        ...schema._zod.def,
+        shape,
+        // optional: [],
+        checks: [],
+    });
+}
+function aborted(x, startIndex = 0) {
+    for (let i = startIndex; i < x.issues.length; i++) {
+        if (x.issues[i].continue !== true)
+            return true;
+    }
+    return false;
+}
+function prefixIssues(path, issues) {
+    return issues.map((iss) => {
+        var _a;
+        (_a = iss).path ?? (_a.path = []);
+        iss.path.unshift(path);
+        return iss;
+    });
+}
+function unwrapMessage(message) {
+    return typeof message === "string" ? message : message?.message;
+}
+function finalizeIssue(iss, ctx, config) {
+    const full = { ...iss, path: iss.path ?? [] };
+    // for backwards compatibility
+    if (!iss.message) {
+        const message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ??
+            unwrapMessage(ctx?.error?.(iss)) ??
+            unwrapMessage(config.customError?.(iss)) ??
+            unwrapMessage(config.localeError?.(iss)) ??
+            "Invalid input";
+        full.message = message;
+    }
+    // delete (full as any).def;
+    delete full.inst;
+    delete full.continue;
+    if (!ctx?.reportInput) {
+        delete full.input;
+    }
+    return full;
+}
+function getSizableOrigin(input) {
+    if (input instanceof Set)
+        return "set";
+    if (input instanceof Map)
+        return "map";
+    if (input instanceof File)
+        return "file";
+    return "unknown";
+}
+function getLengthableOrigin(input) {
+    if (Array.isArray(input))
+        return "array";
+    if (typeof input === "string")
+        return "string";
+    return "unknown";
+}
+function issue(...args) {
+    const [iss, input, inst] = args;
+    if (typeof iss === "string") {
+        return {
+            message: iss,
+            code: "custom",
+            input,
+            inst,
+        };
+    }
+    return { ...iss };
+}
+function cleanEnum(obj) {
+    return Object.entries(obj)
+        .filter(([k, _]) => {
+        // return true if NaN, meaning it's not a number, thus a string key
+        return Number.isNaN(Number.parseInt(k, 10));
+    })
+        .map((el) => el[1]);
+}
+// instanceof
+class Class {
+    constructor(..._args) { }
+}
+exports.Class = Class;