zod 3.25.0 → 3.25.3

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

@@ -0,0 +1,14 @@
+type ModeWriter = (doc: Doc, modes: {
+    execution: "sync" | "async";
+}) => void;
+export declare class Doc {
+    args: string[];
+    content: string[];
+    indent: number;
+    constructor(args?: string[]);
+    indented(fn: (doc: Doc) => void): void;
+    write(fn: ModeWriter): void;
+    write(line: string): void;
+    compile(): Function;
+}
+export {};

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Doc = void 0;
+class Doc {
+    constructor(args = []) {
+        this.content = [];
+        this.indent = 0;
+        if (this)
+            this.args = args;
+    }
+    indented(fn) {
+        this.indent += 1;
+        fn(this);
+        this.indent -= 1;
+    }
+    write(arg) {
+        if (typeof arg === "function") {
+            arg(this, { execution: "sync" });
+            arg(this, { execution: "async" });
+            return;
+        }
+        const content = arg;
+        const lines = content.split("\n").filter((x) => x);
+        const minIndent = Math.min(...lines.map((x) => x.length - x.trimStart().length));
+        const dedented = lines.map((x) => x.slice(minIndent)).map((x) => " ".repeat(this.indent * 2) + x);
+        for (const line of dedented) {
+            this.content.push(line);
+        }
+    }
+    compile() {
+        const F = Function;
+        const args = this?.args;
+        const content = this?.content ?? [``];
+        const lines = [...content.map((x) => `  ${x}`)];
+        // console.log(lines.join("\n"));
+        // console.dir("COMPILE", {depth: null});
+        return new F(...args, lines.join("\n"));
+    }
+}
+exports.Doc = Doc;

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

@@ -0,0 +1,204 @@
+import type { $ZodCheck, $ZodStringFormats } from "./checks.js";
+import { $constructor } from "./core.js";
+import type { $ZodType } from "./schemas.js";
+import type * as util from "./util.js";
+export interface $ZodIssueBase {
+    readonly code?: string;
+    readonly input?: unknown;
+    readonly path: PropertyKey[];
+    readonly message: string;
+}
+export interface $ZodIssueInvalidType<Input = unknown> extends $ZodIssueBase {
+    readonly code: "invalid_type";
+    readonly expected: $ZodType["_zod"]["def"]["type"];
+    readonly input: Input;
+}
+export interface $ZodIssueTooBig<Input = unknown> extends $ZodIssueBase {
+    readonly code: "too_big";
+    readonly origin: "number" | "int" | "bigint" | "date" | "string" | "array" | "set" | "file" | (string & {});
+    readonly maximum: number | bigint;
+    readonly inclusive?: boolean;
+    readonly input: Input;
+}
+export interface $ZodIssueTooSmall<Input = unknown> extends $ZodIssueBase {
+    readonly code: "too_small";
+    readonly origin: "number" | "int" | "bigint" | "date" | "string" | "array" | "set" | "file" | (string & {});
+    readonly minimum: number | bigint;
+    readonly inclusive?: boolean;
+    readonly input: Input;
+}
+export interface $ZodIssueInvalidStringFormat extends $ZodIssueBase {
+    readonly code: "invalid_format";
+    readonly format: $ZodStringFormats | (string & {});
+    readonly pattern?: string;
+    readonly input: string;
+}
+export interface $ZodIssueNotMultipleOf<Input extends number | bigint = number | bigint> extends $ZodIssueBase {
+    readonly code: "not_multiple_of";
+    readonly divisor: number;
+    readonly input: Input;
+}
+export interface $ZodIssueUnrecognizedKeys extends $ZodIssueBase {
+    readonly code: "unrecognized_keys";
+    readonly keys: string[];
+    readonly input: Record<string, unknown>;
+}
+export interface $ZodIssueInvalidUnion extends $ZodIssueBase {
+    readonly code: "invalid_union";
+    readonly errors: $ZodIssue[][];
+    readonly input: unknown;
+}
+export interface $ZodIssueInvalidKey<Input = unknown> extends $ZodIssueBase {
+    readonly code: "invalid_key";
+    readonly origin: "map" | "record";
+    readonly issues: $ZodIssue[];
+    readonly input: Input;
+}
+export interface $ZodIssueInvalidElement<Input = unknown> extends $ZodIssueBase {
+    readonly code: "invalid_element";
+    readonly origin: "map" | "set";
+    readonly key: unknown;
+    readonly issues: $ZodIssue[];
+    readonly input: Input;
+}
+export interface $ZodIssueInvalidValue<Input = unknown> extends $ZodIssueBase {
+    readonly code: "invalid_value";
+    readonly values: util.Primitive[];
+    readonly input: Input;
+}
+export interface $ZodIssueCustom extends $ZodIssueBase {
+    readonly code?: "custom";
+    readonly params?: Record<string, any> | undefined;
+    readonly input: unknown;
+}
+export interface $ZodIssueStringCommonFormats extends $ZodIssueInvalidStringFormat {
+    format: Exclude<$ZodStringFormats, "regex" | "jwt" | "starts_with" | "ends_with" | "includes">;
+}
+export interface $ZodIssueStringInvalidRegex extends $ZodIssueInvalidStringFormat {
+    format: "regex";
+    pattern: string;
+}
+export interface $ZodIssueStringInvalidJWT extends $ZodIssueInvalidStringFormat {
+    format: "jwt";
+    algorithm?: string;
+}
+export interface $ZodIssueStringStartsWith extends $ZodIssueInvalidStringFormat {
+    format: "starts_with";
+    prefix: string;
+}
+export interface $ZodIssueStringEndsWith extends $ZodIssueInvalidStringFormat {
+    format: "ends_with";
+    suffix: string;
+}
+export interface $ZodIssueStringIncludes extends $ZodIssueInvalidStringFormat {
+    format: "includes";
+    includes: string;
+}
+export type $ZodStringFormatIssues = $ZodIssueStringCommonFormats | $ZodIssueStringInvalidRegex | $ZodIssueStringInvalidJWT | $ZodIssueStringStartsWith | $ZodIssueStringEndsWith | $ZodIssueStringIncludes;
+export type $ZodIssue = $ZodIssueInvalidType | $ZodIssueTooBig | $ZodIssueTooSmall | $ZodIssueInvalidStringFormat | $ZodIssueNotMultipleOf | $ZodIssueUnrecognizedKeys | $ZodIssueInvalidUnion | $ZodIssueInvalidKey | $ZodIssueInvalidElement | $ZodIssueInvalidValue | $ZodIssueCustom;
+export type $ZodRawIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue<T> : never;
+type RawIssue<T extends $ZodIssueBase> = util.Flatten<util.MakePartial<T, "message" | "path"> & {
+    /** The input data */
+    readonly input?: unknown;
+    /** The schema or check that originated this issue. */
+    readonly inst?: $ZodType | $ZodCheck;
+    /** @deprecated Internal use only. If `true`, Zod will continue executing validation despite this issue. */
+    readonly continue?: boolean | undefined;
+} & Record<string, any>>;
+export interface $ZodErrorMap<T extends $ZodIssueBase = $ZodIssue> {
+    (issue: $ZodRawIssue<T>): {
+        message: string;
+    } | string | undefined | null;
+}
+export interface $ZodError<T = unknown> extends Error {
+    type: T;
+    issues: $ZodIssue[];
+    _zod: {
+        output: T;
+        def: $ZodIssue[];
+    };
+    stack?: string;
+    name: string;
+}
+export declare const $ZodError: $constructor<$ZodError>;
+interface $ZodRealError<T = any> extends $ZodError<T> {
+}
+export declare const $ZodRealError: $constructor<$ZodRealError>;
+export type $ZodFlattenedError<T, U = string> = _FlattenedError<T, U>;
+type _FlattenedError<T, U = string> = {
+    formErrors: U[];
+    fieldErrors: {
+        [P in keyof T]?: U[];
+    };
+};
+/** @deprecated Use `z.treeifyError()` instead. */
+export declare function flattenError<T>(error: $ZodError<T>): _FlattenedError<T>;
+export declare function flattenError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): _FlattenedError<T, U>;
+type _ZodFormattedError<T, U = string> = T extends [any, ...any[]] ? {
+    [K in keyof T]?: $ZodFormattedError<T[K], U>;
+} : T extends any[] ? {
+    [k: number]: $ZodFormattedError<T[number], U>;
+} : T extends object ? util.Flatten<{
+    [K in keyof T]?: $ZodFormattedError<T[K], U>;
+}> : any;
+export type $ZodFormattedError<T, U = string> = {
+    _errors: U[];
+} & util.Flatten<_ZodFormattedError<T, U>>;
+export declare function formatError<T>(error: $ZodError<T>): $ZodFormattedError<T>;
+export declare function formatError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): $ZodFormattedError<T, U>;
+export type $ZodErrorTree<T, U = string> = T extends [any, ...any[]] ? {
+    errors: U[];
+    items?: {
+        [K in keyof T]?: $ZodErrorTree<T[K], U>;
+    };
+} : T extends any[] ? {
+    errors: U[];
+    items?: Array<$ZodErrorTree<T[number], U>>;
+} : T extends object ? {
+    errors: U[];
+    properties?: {
+        [K in keyof T]?: $ZodErrorTree<T[K], U>;
+    };
+} : {
+    errors: U[];
+};
+export declare function treeifyError<T>(error: $ZodError<T>): $ZodErrorTree<T>;
+export declare function treeifyError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): $ZodErrorTree<T, U>;
+/** Format a ZodError as a human-readable string in the following form.
+ *
+ * From
+ *
+ * ```ts
+ * ZodError {
+ *   issues: [
+ *     {
+ *       expected: 'string',
+ *       code: 'invalid_type',
+ *       path: [ 'username' ],
+ *       message: 'Invalid input: expected string'
+ *     },
+ *     {
+ *       expected: 'number',
+ *       code: 'invalid_type',
+ *       path: [ 'favoriteNumbers', 1 ],
+ *       message: 'Invalid input: expected number'
+ *     }
+ *   ];
+ * }
+ * ```
+ *
+ * to
+ *
+ * ```
+ * username
+ *   ✖ Expected number, received string at "username
+ * favoriteNumbers[0]
+ *   ✖ Invalid input: expected number
+ * ```
+ */
+export declare function toDotPath(path: (string | number | symbol)[]): string;
+interface BaseError {
+    issues: $ZodIssueBase[];
+}
+export declare function prettifyError(error: BaseError): string;
+export {};

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

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$ZodRealError = exports.$ZodError = void 0;
+exports.flattenError = flattenError;
+exports.formatError = formatError;
+exports.treeifyError = treeifyError;
+exports.toDotPath = toDotPath;
+exports.prettifyError = prettifyError;
+const core_js_1 = require("./core.js");
+const initializer = (inst, def) => {
+    Object.defineProperty(inst, "_zod", {
+        value: inst._zod,
+        enumerable: false,
+    });
+    Object.defineProperty(inst, "issues", {
+        value: def,
+        enumerable: true,
+    });
+    // inst.message = `Invalid input`;
+    // Object.defineProperty(inst, "message", {
+    //   get() {
+    //     return (
+    //       "\n" +
+    //       inst.issues
+    //         .map((iss) => {
+    //           return `✖ ${iss.message}${iss.path.length ? ` [${iss.path.join(".")}]` : ""}`;
+    //         })
+    //         .join("\n")
+    //     );
+    //   },
+    //   enumerable: false,
+    // });
+};
+exports.$ZodError = (0, core_js_1.$constructor)("$ZodError", initializer);
+exports.$ZodRealError = (0, core_js_1.$constructor)("$ZodError", initializer, { Parent: Error });
+function flattenError(error, mapper = (issue) => issue.message) {
+    const fieldErrors = {};
+    const formErrors = [];
+    for (const sub of error.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 };
+}
+function formatError(error, _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.errors.map((issues) => processError({ issues }));
+            }
+            else if (issue.code === "invalid_key") {
+                processError({ issues: issue.issues });
+            }
+            else if (issue.code === "invalid_element") {
+                processError({ issues: issue.issues });
+            }
+            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(error);
+    return fieldErrors;
+}
+function treeifyError(error, _mapper) {
+    const mapper = _mapper ||
+        function (issue) {
+            return issue.message;
+        };
+    const result = { errors: [] };
+    const processError = (error, path = []) => {
+        var _a, _b;
+        for (const issue of error.issues) {
+            if (issue.code === "invalid_union") {
+                issue.errors.map((issues) => processError({ issues }, issue.path));
+            }
+            else if (issue.code === "invalid_key") {
+                processError({ issues: issue.issues }, issue.path);
+            }
+            else if (issue.code === "invalid_element") {
+                processError({ issues: issue.issues }, issue.path);
+            }
+            else {
+                const fullpath = [...path, ...issue.path];
+                if (fullpath.length === 0) {
+                    result.errors.push(mapper(issue));
+                    continue;
+                }
+                let curr = result;
+                let i = 0;
+                while (i < fullpath.length) {
+                    const el = fullpath[i];
+                    const terminal = i === fullpath.length - 1;
+                    if (typeof el === "string") {
+                        curr.properties ?? (curr.properties = {});
+                        (_a = curr.properties)[el] ?? (_a[el] = { errors: [] });
+                        curr = curr.properties[el];
+                    }
+                    else {
+                        curr.items ?? (curr.items = []);
+                        (_b = curr.items)[el] ?? (_b[el] = { errors: [] });
+                        curr = curr.items[el];
+                    }
+                    if (terminal) {
+                        curr.errors.push(mapper(issue));
+                    }
+                    i++;
+                }
+            }
+        }
+    };
+    processError(error);
+    return result;
+}
+/** Format a ZodError as a human-readable string in the following form.
+ *
+ * From
+ *
+ * ```ts
+ * ZodError {
+ *   issues: [
+ *     {
+ *       expected: 'string',
+ *       code: 'invalid_type',
+ *       path: [ 'username' ],
+ *       message: 'Invalid input: expected string'
+ *     },
+ *     {
+ *       expected: 'number',
+ *       code: 'invalid_type',
+ *       path: [ 'favoriteNumbers', 1 ],
+ *       message: 'Invalid input: expected number'
+ *     }
+ *   ];
+ * }
+ * ```
+ *
+ * to
+ *
+ * ```
+ * username
+ *   ✖ Expected number, received string at "username
+ * favoriteNumbers[0]
+ *   ✖ Invalid input: expected number
+ * ```
+ */
+function toDotPath(path) {
+    const segs = [];
+    for (const seg of path) {
+        if (typeof seg === "number")
+            segs.push(`[${seg}]`);
+        else if (typeof seg === "symbol")
+            segs.push(`[${JSON.stringify(String(seg))}]`);
+        else if (/[^\w$]/.test(seg))
+            segs.push(`[${JSON.stringify(seg)}]`);
+        else {
+            if (segs.length)
+                segs.push(".");
+            segs.push(seg);
+        }
+    }
+    return segs.join("");
+}
+function prettifyError(error) {
+    const lines = [];
+    // sort by path length
+    const issues = [...error.issues].sort((a, b) => a.path.length - b.path.length);
+    // Process each issue
+    for (const issue of issues) {
+        lines.push(`✖ ${issue.message}`);
+        if (issue.path?.length)
+            lines.push(`  → at ${toDotPath(issue.path)}`);
+    }
+    // Convert Map to formatted string
+    return lines.join("\n");
+}

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

@@ -0,0 +1,35 @@
+import * as schemas from "./schemas.js";
+import { $ZodTuple } from "./schemas.js";
+import type * as util from "./util.js";
+export interface $ZodFunctionDef {
+    type: "function";
+    input: $ZodFunctionArgs | null;
+    output: schemas.$ZodType | null;
+}
+export type $ZodFunctionArgs = schemas.$ZodType<unknown[], unknown[]>;
+export type $InferInnerFunctionType<Args extends $ZodFunctionArgs, Returns extends schemas.$ZodType> = (...args: Args["_zod"]["output"]) => Returns["_zod"]["input"];
+export type $InferInnerFunctionTypeAsync<Args extends $ZodFunctionArgs, Returns extends schemas.$ZodType> = (...args: Args["_zod"]["output"]) => util.MaybeAsync<Returns["_zod"]["input"]>;
+export type $InferOuterFunctionType<Args extends $ZodFunctionArgs, Returns extends schemas.$ZodType> = (...args: Args["_zod"]["input"]) => Returns["_zod"]["output"];
+export type $InferOuterFunctionTypeAsync<Args extends $ZodFunctionArgs, Returns extends schemas.$ZodType> = (...args: Args["_zod"]["input"]) => util.MaybeAsync<Returns["_zod"]["output"]>;
+export declare class $ZodFunction<Args extends $ZodFunctionArgs = $ZodFunctionArgs, Returns extends schemas.$ZodType = schemas.$ZodType> {
+    _def: $ZodFunctionDef;
+    _input: $InferInnerFunctionType<Args, Returns>;
+    _output: $InferOuterFunctionType<Args, Returns>;
+    constructor(def: $ZodFunctionDef);
+    implement<F extends $InferInnerFunctionType<Args, Returns>>(func: F): F extends this["_output"] ? F : this["_output"];
+    implementAsync<F extends $InferInnerFunctionTypeAsync<Args, Returns>>(func: F): F extends $InferOuterFunctionTypeAsync<Args, Returns> ? F : $InferOuterFunctionTypeAsync<Args, Returns>;
+    input<const Items extends util.TupleItems, const Rest extends schemas.$ZodType | null = null>(args: Items, rest?: Rest): $ZodFunction<schemas.$ZodTuple<Items, Rest>, Returns>;
+    input<NewArgs extends $ZodFunctionArgs>(args: NewArgs): $ZodFunction<NewArgs, Returns>;
+    output<NewReturns extends schemas.$ZodType>(output: NewReturns): $ZodFunction<Args, NewReturns>;
+}
+export interface $ZodFunctionParams<I extends $ZodFunctionArgs, O extends schemas.$ZodType> {
+    input?: I;
+    output?: O;
+}
+declare function _function(): $ZodFunction;
+declare function _function<const In extends Array<schemas.$ZodType> = Array<schemas.$ZodType>, Out extends schemas.$ZodType = schemas.$ZodType>(params?: {
+    input?: In;
+    output?: Out;
+}): $ZodFunction<$ZodTuple<In, null>, Out>;
+declare function _function<In extends $ZodFunctionArgs = $ZodFunctionArgs, Out extends schemas.$ZodType = schemas.$ZodType>(params?: $ZodFunctionParams<In, Out>): $ZodFunction<In, Out>;
+export { _function as function };

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

@@ -0,0 +1,107 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$ZodFunction = void 0;
+exports.function = _function;
+const api_js_1 = require("./api.js");
+const parse_js_1 = require("./parse.js");
+const schemas = __importStar(require("./schemas.js"));
+const schemas_js_1 = require("./schemas.js");
+class $ZodFunction {
+    constructor(def) {
+        this._def = def;
+    }
+    implement(func) {
+        if (typeof func !== "function") {
+            throw new Error("implement() must be called with a function");
+        }
+        const impl = ((...args) => {
+            const parsedArgs = this._def.input ? (0, parse_js_1.parse)(this._def.input, args, undefined, { callee: impl }) : args;
+            if (!Array.isArray(parsedArgs)) {
+                throw new Error("Invalid arguments schema: not an array or tuple schema.");
+            }
+            const output = func(...parsedArgs);
+            return this._def.output ? (0, parse_js_1.parse)(this._def.output, output, undefined, { callee: impl }) : output;
+        });
+        return impl;
+    }
+    implementAsync(func) {
+        if (typeof func !== "function") {
+            throw new Error("implement() must be called with a function");
+        }
+        const impl = (async (...args) => {
+            const parsedArgs = this._def.input ? await (0, parse_js_1.parseAsync)(this._def.input, args, undefined, { callee: impl }) : args;
+            if (!Array.isArray(parsedArgs)) {
+                throw new Error("Invalid arguments schema: not an array or tuple schema.");
+            }
+            const output = await func(...parsedArgs);
+            return this._def.output ? (0, parse_js_1.parseAsync)(this._def.output, output, undefined, { callee: impl }) : output;
+        });
+        return impl;
+    }
+    input(...args) {
+        if (Array.isArray(args[0])) {
+            return new $ZodFunction({
+                type: "function",
+                input: new schemas_js_1.$ZodTuple({
+                    type: "tuple",
+                    items: args[0],
+                    rest: args[1],
+                }),
+                output: this._def.output,
+            });
+        }
+        return new $ZodFunction({
+            type: "function",
+            input: args[0],
+            output: this._def.output,
+        });
+    }
+    output(output) {
+        return new $ZodFunction({
+            type: "function",
+            input: this._def.input,
+            output,
+        });
+    }
+}
+exports.$ZodFunction = $ZodFunction;
+function _function(params) {
+    return new $ZodFunction({
+        type: "function",
+        input: Array.isArray(params?.input) ? (0, api_js_1._tuple)(schemas.$ZodTuple, params?.input) : (params?.input ?? null),
+        output: params?.output ?? null,
+    });
+}

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

@@ -0,0 +1,15 @@
+export * from "./core.js";
+export * from "./parse.js";
+export * from "./errors.js";
+export * from "./schemas.js";
+export * from "./checks.js";
+export * from "./versions.js";
+export * as util from "./util.js";
+export * as regexes from "./regexes.js";
+export * as locales from "../locales/index.js";
+export * from "./registries.js";
+export * from "./doc.js";
+export * from "./function.js";
+export * from "./api.js";
+export * from "./to-json-schema.js";
+export * as JSONSchema from "./json-schema.js";

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

@@ -0,0 +1,54 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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 __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);
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSONSchema = exports.locales = exports.regexes = exports.util = void 0;
+__exportStar(require("./core.js"), exports);
+__exportStar(require("./parse.js"), exports);
+__exportStar(require("./errors.js"), exports);
+__exportStar(require("./schemas.js"), exports);
+__exportStar(require("./checks.js"), exports);
+__exportStar(require("./versions.js"), exports);
+exports.util = __importStar(require("./util.js"));
+exports.regexes = __importStar(require("./regexes.js"));
+exports.locales = __importStar(require("../locales/index.js"));
+__exportStar(require("./registries.js"), exports);
+__exportStar(require("./doc.js"), exports);
+__exportStar(require("./function.js"), exports);
+__exportStar(require("./api.js"), exports);
+__exportStar(require("./to-json-schema.js"), exports);
+exports.JSONSchema = __importStar(require("./json-schema.js"));