zod-compiler 1.23.0 → 1.23.2

package/dist/core/codegen/schemas/void.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"void.d.ts","sourceRoot":"","sources":["../../../../src/core/codegen/schemas/void.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAItD,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,CAAC,EAAE,OAAO,GAAG,MAAM,CAMxD;AAED,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAE/D"}
+{"version":3,"file":"void.d.ts","names":[],"sources":["../../../../src/core/codegen/schemas/void.ts"],"mappings":";;;iBAKgB,SAAS,KAAK,QAAQ,GAAG;iBAQzB,SAAS,KAAK,QAAQ,GAAG"}

package/dist/core/codegen/schemas/void.js

@@ -1,13 +1,17 @@
 import { emit } from "../emit.js";
 import { invalidType } from "../emit-issue.js";
-export function slowVoid(_ir, g) {
-    return `${emit `
+//#region src/core/codegen/schemas/void.ts
+function slowVoid(_ir, g) {
+	return `${emit`
     if(${g.input}!==undefined){
       ${invalidType(g, "void")}
     }
   `}\n`;
 }
-export function fastVoid(_ir, g) {
-    return `${g.input}===undefined`;
+function fastVoid(_ir, g) {
+	return `${g.input}===undefined`;
 }
+//#endregion
+export { fastVoid, slowVoid };
+
 //# sourceMappingURL=void.js.map

package/dist/core/codegen/schemas/void.js.map

@@ -1 +1 @@
-{"version":3,"file":"void.js","sourceRoot":"","sources":["../../../../src/core/codegen/schemas/void.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAClC,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE/C,MAAM,UAAU,QAAQ,CAAC,GAAW,EAAE,CAAU;IAC9C,OAAO,GAAG,IAAI,CAAA;SACP,CAAC,CAAC,KAAK;QACR,WAAW,CAAC,CAAC,EAAE,MAAM,CAAC;;GAE3B,IAAI,CAAC;AACR,CAAC;AAED,MAAM,UAAU,QAAQ,CAAC,GAAW,EAAE,CAAU;IAC9C,OAAO,GAAG,CAAC,CAAC,KAAK,cAAc,CAAC;AAClC,CAAC"}
+{"version":3,"file":"void.js","names":[],"sources":["../../../../src/core/codegen/schemas/void.ts"],"sourcesContent":["import type { VoidIR } from \"../../types.js\";\nimport type { FastGen, SlowGen } from \"../context.js\";\nimport { emit } from \"../emit.js\";\nimport { invalidType } from \"../emit-issue.js\";\n\nexport function slowVoid(_ir: VoidIR, g: SlowGen): string {\n  return `${emit`\n    if(${g.input}!==undefined){\n      ${invalidType(g, \"void\")}\n    }\n  `}\\n`;\n}\n\nexport function fastVoid(_ir: VoidIR, g: FastGen): string | null {\n  return `${g.input}===undefined`;\n}\n"],"mappings":";;;AAKA,SAAgB,SAAS,KAAa,GAAoB;CACxD,OAAO,GAAG,IAAI;SACP,EAAE,MAAM;QACT,YAAY,GAAG,MAAM,EAAE;;IAE3B;AACJ;AAEA,SAAgB,SAAS,KAAa,GAA2B;CAC/D,OAAO,GAAG,EAAE,MAAM;AACpB"}

package/dist/core/codegen/slow-path.d.ts

@@ -1,5 +1,8 @@
-import type { SchemaIR } from "../types.js";
-import type { CodeGenContext, SlowGen } from "./context.js";
-export declare function createSlowGen(inputExpr: string, outputExpr: string, pathExpr: string, issuesVar: string, ctx: CodeGenContext, abortedVar?: string): SlowGen;
-export declare function generateSlow(ir: SchemaIR, g: SlowGen): string;
+import { SchemaIR } from "../types.js";
+import { CodeGenContext, SlowGen } from "./context.js";
+//#region src/core/codegen/slow-path.d.ts
+declare function createSlowGen(inputExpr: string, outputExpr: string, pathExpr: string, issuesVar: string, ctx: CodeGenContext, abortedVar?: string): SlowGen;
+declare function generateSlow(ir: SchemaIR, g: SlowGen): string;
+//#endregion
+export { createSlowGen, generateSlow };
 //# sourceMappingURL=slow-path.d.ts.map

package/dist/core/codegen/slow-path.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"slow-path.d.ts","sourceRoot":"","sources":["../../../src/core/codegen/slow-path.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,KAAK,EAAE,cAAc,EAAE,OAAO,EAAiB,MAAM,cAAc,CAAC;AAgG3E,wBAAgB,aAAa,CAC3B,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,cAAc,EACnB,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAqCT;AAID,wBAAgB,YAAY,CAAC,EAAE,EAAE,QAAQ,EAAE,CAAC,EAAE,OAAO,GAAG,MAAM,CAO7D"}
+{"version":3,"file":"slow-path.d.ts","names":[],"sources":["../../../src/core/codegen/slow-path.ts"],"mappings":";;;iBAiGgB,cACd,mBACA,oBACA,kBACA,mBACA,KAAK,gBACL,sBACC;iBAyCa,aAAa,IAAI,UAAU,GAAG"}

package/dist/core/codegen/slow-path.js

@@ -1,5 +1,6 @@
 import { emitRegex, emitSet, emitTemp } from "./context.js";
 import { slowAny } from "./schemas/any.js";
+import { slowEffect } from "./schemas/effect.js";
 import { slowArray } from "./schemas/array.js";
 import { slowBigInt } from "./schemas/bigint.js";
 import { slowBoolean } from "./schemas/boolean.js";
@@ -7,7 +8,6 @@ import { slowCatch } from "./schemas/catch.js";
 import { slowDate } from "./schemas/date.js";
 import { slowDefault } from "./schemas/default.js";
 import { slowDiscriminatedUnion } from "./schemas/discriminated-union.js";
-import { slowEffect } from "./schemas/effect.js";
 import { slowEnum } from "./schemas/enum.js";
 import { slowFallback } from "./schemas/fallback.js";
 import { slowFile } from "./schemas/file.js";
@@ -35,103 +35,78 @@ import { slowUndefined } from "./schemas/undefined.js";
 import { slowUnion } from "./schemas/union.js";
 import { slowUnknown } from "./schemas/unknown.js";
 import { slowVoid } from "./schemas/void.js";
-// ─── Typed registry ─────────────────────────────────────────────────────────
-// Adding a new SchemaIR type without registering a generator here causes a
-// compile error, preventing the silent-missing-case bugs that plagued the old
-// switch-based dispatch.
+//#region src/core/codegen/slow-path.ts
 const slowRegistry = {
-    // Primitives (order follows SchemaIR union in types.ts)
-    string: slowString,
-    number: slowNumber,
-    boolean: slowBoolean,
-    bigint: slowBigInt,
-    date: slowDate,
-    symbol: slowSymbol,
-    null: slowNull,
-    undefined: slowUndefined,
-    void: slowVoid,
-    nan: slowNan,
-    never: slowNever,
-    any: slowAny,
-    unknown: slowUnknown,
-    literal: slowLiteral,
-    enum: slowEnum,
-    // Containers
-    object: slowObject,
-    array: slowArray,
-    tuple: slowTuple,
-    record: slowRecord,
-    set: slowSet,
-    map: slowMap,
-    file: slowFile,
-    // Unions & Intersections
-    union: slowUnion,
-    discriminatedUnion: slowDiscriminatedUnion,
-    intersection: slowIntersection,
-    // Modifiers
-    optional: slowOptional,
-    nullable: slowNullable,
-    readonly: slowReadonly,
-    default: slowDefault,
-    pipe: slowPipe,
-    // Effects
-    effect: slowEffect,
-    // Special
-    templateLiteral: slowTemplateLiteral,
-    catch: slowCatch,
-    fallback: slowFallback,
-    recursiveRef: slowRecursiveRef,
-    recursionTarget: slowRecursionTarget,
-    stringBool: slowStringBool,
+	string: slowString,
+	number: slowNumber,
+	boolean: slowBoolean,
+	bigint: slowBigInt,
+	date: slowDate,
+	symbol: slowSymbol,
+	null: slowNull,
+	undefined: slowUndefined,
+	void: slowVoid,
+	nan: slowNan,
+	never: slowNever,
+	any: slowAny,
+	unknown: slowUnknown,
+	literal: slowLiteral,
+	enum: slowEnum,
+	object: slowObject,
+	array: slowArray,
+	tuple: slowTuple,
+	record: slowRecord,
+	set: slowSet,
+	map: slowMap,
+	file: slowFile,
+	union: slowUnion,
+	discriminatedUnion: slowDiscriminatedUnion,
+	intersection: slowIntersection,
+	optional: slowOptional,
+	nullable: slowNullable,
+	readonly: slowReadonly,
+	default: slowDefault,
+	pipe: slowPipe,
+	effect: slowEffect,
+	templateLiteral: slowTemplateLiteral,
+	catch: slowCatch,
+	fallback: slowFallback,
+	recursiveRef: slowRecursiveRef,
+	recursionTarget: slowRecursionTarget,
+	stringBool: slowStringBool
 };
-// ─── Factory ─────────────────────────────────────────────────────────────────
-// Lives here (not in context.ts) to avoid circular imports:
-// visit() → generateSlow() → imports from context.ts
-export function createSlowGen(inputExpr, outputExpr, pathExpr, issuesVar, ctx, abortedVar) {
-    return {
-        input: inputExpr,
-        output: outputExpr,
-        path: pathExpr,
-        issues: issuesVar,
-        aborted: abortedVar,
-        ctx,
-        visit(ir, overrides) {
-            const input = overrides?.input ?? inputExpr;
-            const output = overrides?.output ?? outputExpr;
-            const path = overrides?.path ?? pathExpr;
-            const issues = overrides?.issues ?? issuesVar;
-            // `aborted` is deliberately NOT inherited (see SlowGen.aborted): a child
-            // only tracks abort when the parent explicitly forwards it, so a pipe
-            // buried inside a container never trips its ancestor union's abort flag.
-            const aborted = overrides?.aborted;
-            // Shared sub-schema: call the file-level `__zcSw_N(input, path, issues)`
-            // walk (signature defined in dedupe.ts) instead of inlining a duplicate.
-            // It returns the parsed value, so the assignment delivers whatever an
-            // inlined walk would have written to `output` — a stripping object's
-            // rebuilt result, a coerced number, a trimmed string.
-            //
-            // But the shared walk's 3-arg signature can't carry this call site's
-            // abort flag — a shared pipe option would silently drop it. When we're in
-            // an abort-tracking position (`aborted` set), inline instead of sharing so
-            // the pipe's abort reaches the union. Non-tracking sites still share.
-            const ref = aborted === undefined ? ctx.sharedSchemas?.refFor(ir) : undefined;
-            if (ref !== undefined) {
-                return `${output}=${ref.name}(${input},${path},${issues});`;
-            }
-            return generateSlow(ir, createSlowGen(input, output, path, issues, ctx, aborted));
-        },
-        temp: (prefix) => emitTemp(ctx, prefix),
-        regex: (prefix, pattern, flags) => emitRegex(ctx, prefix, pattern, flags),
-        set: (prefix, values) => emitSet(ctx, prefix, values),
-    };
+function createSlowGen(inputExpr, outputExpr, pathExpr, issuesVar, ctx, abortedVar) {
+	return {
+		input: inputExpr,
+		output: outputExpr,
+		path: pathExpr,
+		issues: issuesVar,
+		aborted: abortedVar,
+		ctx,
+		visit(ir, overrides) {
+			const input = overrides?.input ?? inputExpr;
+			const output = overrides?.output ?? outputExpr;
+			const path = overrides?.path ?? pathExpr;
+			const issues = overrides?.issues ?? issuesVar;
+			const aborted = overrides?.aborted;
+			const ref = aborted === void 0 ? ctx.sharedSchemas?.refFor(ir) : void 0;
+			if (ref !== void 0) return `${output}=${ref.name}(${input},${path},${issues});`;
+			return generateSlow(ir, createSlowGen(input, output, path, issues, ctx, aborted));
+		},
+		temp: (prefix) => emitTemp(ctx, prefix),
+		regex: (prefix, pattern, flags) => emitRegex(ctx, prefix, pattern, flags),
+		set: (prefix, values) => emitSet(ctx, prefix, values)
+	};
 }
-// ─── Dispatch ────────────────────────────────────────────────────────────────
-export function generateSlow(ir, g) {
-    // Surface the node's schema-level error message to issue emission. visit()
-    // always builds a fresh context, so typeMsg never leaks into child nodes.
-    const gen0 = ir.typeMessage !== g.typeMsg ? { ...g, typeMsg: ir.typeMessage } : g;
-    const gen = slowRegistry[ir.type];
-    // oxlint-disable-next-line typescript/no-explicit-any -- registry dispatch requires type erasure at call site
-    return gen(ir, gen0);
+function generateSlow(ir, g) {
+	const gen0 = ir.typeMessage !== g.typeMsg ? {
+		...g,
+		typeMsg: ir.typeMessage
+	} : g;
+	const gen = slowRegistry[ir.type];
+	return gen(ir, gen0);
 }
+//#endregion
+export { createSlowGen, generateSlow };
+
 //# sourceMappingURL=slow-path.js.map

package/dist/core/codegen/slow-path.js.map

@@ -1 +1 @@
-{"version":3,"file":"slow-path.js","sourceRoot":"","sources":["../../../src/core/codegen/slow-path.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"slow-path.js","names":[],"sources":["../../../src/core/codegen/slow-path.ts"],"sourcesContent":["import type { SchemaIR } from \"../types.js\";\nimport type { CodeGenContext, SlowGen, SlowGenerator } from \"./context.js\";\nimport { emitRegex, emitSet, emitTemp } from \"./context.js\";\nimport { slowAny } from \"./schemas/any.js\";\nimport { slowArray } from \"./schemas/array.js\";\nimport { slowBigInt } from \"./schemas/bigint.js\";\nimport { slowBoolean } from \"./schemas/boolean.js\";\nimport { slowCatch } from \"./schemas/catch.js\";\nimport { slowDate } from \"./schemas/date.js\";\nimport { slowDefault } from \"./schemas/default.js\";\nimport { slowDiscriminatedUnion } from \"./schemas/discriminated-union.js\";\nimport { slowEffect } from \"./schemas/effect.js\";\nimport { slowEnum } from \"./schemas/enum.js\";\nimport { slowFallback } from \"./schemas/fallback.js\";\nimport { slowFile } from \"./schemas/file.js\";\nimport { slowIntersection } from \"./schemas/intersection.js\";\nimport { slowLiteral } from \"./schemas/literal.js\";\nimport { slowMap } from \"./schemas/map.js\";\nimport { slowNan } from \"./schemas/nan.js\";\nimport { slowNever } from \"./schemas/never.js\";\nimport { slowNull } from \"./schemas/null.js\";\nimport { slowNullable } from \"./schemas/nullable.js\";\nimport { slowNumber } from \"./schemas/number.js\";\nimport { slowObject } from \"./schemas/object.js\";\nimport { slowOptional } from \"./schemas/optional.js\";\nimport { slowPipe } from \"./schemas/pipe.js\";\nimport { slowReadonly } from \"./schemas/readonly.js\";\nimport { slowRecord } from \"./schemas/record.js\";\nimport { slowRecursionTarget, slowRecursiveRef } from \"./schemas/recursive-ref.js\";\nimport { slowSet } from \"./schemas/set.js\";\nimport { slowString } from \"./schemas/string.js\";\nimport { slowStringBool } from \"./schemas/string-bool.js\";\nimport { slowSymbol } from \"./schemas/symbol.js\";\nimport { slowTemplateLiteral } from \"./schemas/template-literal.js\";\nimport { slowTuple } from \"./schemas/tuple.js\";\nimport { slowUndefined } from \"./schemas/undefined.js\";\nimport { slowUnion } from \"./schemas/union.js\";\nimport { slowUnknown } from \"./schemas/unknown.js\";\nimport { slowVoid } from \"./schemas/void.js\";\n\n// ─── Typed registry ─────────────────────────────────────────────────────────\n// Adding a new SchemaIR type without registering a generator here causes a\n// compile error, preventing the silent-missing-case bugs that plagued the old\n// switch-based dispatch.\n\nconst slowRegistry = {\n  // Primitives (order follows SchemaIR union in types.ts)\n  string: slowString,\n  number: slowNumber,\n  boolean: slowBoolean,\n  bigint: slowBigInt,\n  date: slowDate,\n  symbol: slowSymbol,\n  null: slowNull,\n  undefined: slowUndefined,\n  void: slowVoid,\n  nan: slowNan,\n  never: slowNever,\n  any: slowAny,\n  unknown: slowUnknown,\n  literal: slowLiteral,\n  enum: slowEnum,\n  // Containers\n  object: slowObject,\n  array: slowArray,\n  tuple: slowTuple,\n  record: slowRecord,\n  set: slowSet,\n  map: slowMap,\n  file: slowFile,\n  // Unions & Intersections\n  union: slowUnion,\n  discriminatedUnion: slowDiscriminatedUnion,\n  intersection: slowIntersection,\n  // Modifiers\n  optional: slowOptional,\n  nullable: slowNullable,\n  readonly: slowReadonly,\n  default: slowDefault,\n  pipe: slowPipe,\n  // Effects\n  effect: slowEffect,\n  // Special\n  templateLiteral: slowTemplateLiteral,\n  catch: slowCatch,\n  fallback: slowFallback,\n  recursiveRef: slowRecursiveRef,\n  recursionTarget: slowRecursionTarget,\n  stringBool: slowStringBool,\n} satisfies {\n  [K in SchemaIR[\"type\"]]: SlowGenerator<Extract<SchemaIR, { type: K }>>;\n};\n\n// ─── Factory ─────────────────────────────────────────────────────────────────\n// Lives here (not in context.ts) to avoid circular imports:\n// visit() → generateSlow() → imports from context.ts\n\nexport function createSlowGen(\n  inputExpr: string,\n  outputExpr: string,\n  pathExpr: string,\n  issuesVar: string,\n  ctx: CodeGenContext,\n  abortedVar?: string,\n): SlowGen {\n  return {\n    input: inputExpr,\n    output: outputExpr,\n    path: pathExpr,\n    issues: issuesVar,\n    aborted: abortedVar,\n    ctx,\n    visit(ir, overrides) {\n      const input = overrides?.input ?? inputExpr;\n      const output = overrides?.output ?? outputExpr;\n      const path = overrides?.path ?? pathExpr;\n      const issues = overrides?.issues ?? issuesVar;\n      // `aborted` is deliberately NOT inherited (see SlowGen.aborted): a child\n      // only tracks abort when the parent explicitly forwards it, so a pipe\n      // buried inside a container never trips its ancestor union's abort flag.\n      const aborted = overrides?.aborted;\n      // Shared sub-schema: call the file-level `__zcSw_N(input, path, issues)`\n      // walk (signature defined in dedupe.ts) instead of inlining a duplicate.\n      // It returns the parsed value, so the assignment delivers whatever an\n      // inlined walk would have written to `output` — a stripping object's\n      // rebuilt result, a coerced number, a trimmed string.\n      //\n      // But the shared walk's 3-arg signature can't carry this call site's\n      // abort flag — a shared pipe option would silently drop it. When we're in\n      // an abort-tracking position (`aborted` set), inline instead of sharing so\n      // the pipe's abort reaches the union. Non-tracking sites still share.\n      const ref = aborted === undefined ? ctx.sharedSchemas?.refFor(ir) : undefined;\n      if (ref !== undefined) {\n        return `${output}=${ref.name}(${input},${path},${issues});`;\n      }\n      return generateSlow(ir, createSlowGen(input, output, path, issues, ctx, aborted));\n    },\n    temp: (prefix) => emitTemp(ctx, prefix),\n    regex: (prefix, pattern, flags) => emitRegex(ctx, prefix, pattern, flags),\n    set: (prefix, values) => emitSet(ctx, prefix, values),\n  };\n}\n\n// ─── Dispatch ────────────────────────────────────────────────────────────────\n\nexport function generateSlow(ir: SchemaIR, g: SlowGen): string {\n  // Surface the node's schema-level error message to issue emission. visit()\n  // always builds a fresh context, so typeMsg never leaks into child nodes.\n  const gen0 = ir.typeMessage !== g.typeMsg ? { ...g, typeMsg: ir.typeMessage } : g;\n  const gen = slowRegistry[ir.type];\n  // oxlint-disable-next-line typescript/no-explicit-any -- registry dispatch requires type erasure at call site\n  return (gen as any)(ir, gen0);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CA,MAAM,eAAe;CAEnB,QAAQ;CACR,QAAQ;CACR,SAAS;CACT,QAAQ;CACR,MAAM;CACN,QAAQ;CACR,MAAM;CACN,WAAW;CACX,MAAM;CACN,KAAK;CACL,OAAO;CACP,KAAK;CACL,SAAS;CACT,SAAS;CACT,MAAM;CAEN,QAAQ;CACR,OAAO;CACP,OAAO;CACP,QAAQ;CACR,KAAK;CACL,KAAK;CACL,MAAM;CAEN,OAAO;CACP,oBAAoB;CACpB,cAAc;CAEd,UAAU;CACV,UAAU;CACV,UAAU;CACV,SAAS;CACT,MAAM;CAEN,QAAQ;CAER,iBAAiB;CACjB,OAAO;CACP,UAAU;CACV,cAAc;CACd,iBAAiB;CACjB,YAAY;AACd;AAQA,SAAgB,cACd,WACA,YACA,UACA,WACA,KACA,YACS;CACT,OAAO;EACL,OAAO;EACP,QAAQ;EACR,MAAM;EACN,QAAQ;EACR,SAAS;EACT;EACA,MAAM,IAAI,WAAW;GACnB,MAAM,QAAQ,WAAW,SAAS;GAClC,MAAM,SAAS,WAAW,UAAU;GACpC,MAAM,OAAO,WAAW,QAAQ;GAChC,MAAM,SAAS,WAAW,UAAU;GAIpC,MAAM,UAAU,WAAW;GAW3B,MAAM,MAAM,YAAY,KAAA,IAAY,IAAI,eAAe,OAAO,EAAE,IAAI,KAAA;GACpE,IAAI,QAAQ,KAAA,GACV,OAAO,GAAG,OAAO,GAAG,IAAI,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,OAAO;GAE1D,OAAO,aAAa,IAAI,cAAc,OAAO,QAAQ,MAAM,QAAQ,KAAK,OAAO,CAAC;EAClF;EACA,OAAO,WAAW,SAAS,KAAK,MAAM;EACtC,QAAQ,QAAQ,SAAS,UAAU,UAAU,KAAK,QAAQ,SAAS,KAAK;EACxE,MAAM,QAAQ,WAAW,QAAQ,KAAK,QAAQ,MAAM;CACtD;AACF;AAIA,SAAgB,aAAa,IAAc,GAAoB;CAG7D,MAAM,OAAO,GAAG,gBAAgB,EAAE,UAAU;EAAE,GAAG;EAAG,SAAS,GAAG;CAAY,IAAI;CAChF,MAAM,MAAM,aAAa,GAAG;CAE5B,OAAQ,IAAY,IAAI,IAAI;AAC9B"}

package/dist/core/codegen/well-known-regex.d.ts

@@ -1,3 +1,4 @@
+//#region src/core/codegen/well-known-regex.d.ts
 /**
  * Well-known regex sources hosted in the virtual module "virtual:zod-compiler/runtime".
  *
@@ -9,7 +10,7 @@
  * exposes additional well-known formats and we want bundle-wide dedup.
  */
 /** Zod v4's email regex source (string.ts uses this directly when format === "email"). */
-export declare const EMAIL_REGEX_SOURCE: string;
+declare const EMAIL_REGEX_SOURCE: string;
 /**
  * Behavior-equivalent rewrite of EMAIL_REGEX_SOURCE that runs ~1.45x faster on V8.
  *
@@ -22,27 +23,27 @@ export declare const EMAIL_REGEX_SOURCE: string;
  * Equivalence is enforced by tests/core/codegen/email-fast-regex.test.ts
  * (exhaustive short-string sweep + structured cases + random fuzz).
  */
-export declare const EMAIL_FAST_REGEX_SOURCE: string;
+declare const EMAIL_FAST_REGEX_SOURCE: string;
 /** Fallback UUID regex used when the extractor doesn't provide a pattern (e.g. in unit tests). */
-export declare const UUID_REGEX_SOURCE = "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$";
-export interface WellKnownRegex {
-    /** Stable virtual-module export name. Always starts with "__zcRe". */
-    name: string;
-    /** Pattern source string (verbatim match against `g.regex()` 2nd argument). */
-    source: string;
-    /**
-     * Behavior-equivalent faster pattern used for the actual `.test()` regex.
-     * Issue reporting (`pattern:` field) always uses `source` so generated
-     * issues stay byte-identical to zod's.
-     */
-    testSource?: string;
+declare const UUID_REGEX_SOURCE = "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$";
+interface WellKnownRegex {
+  /** Stable virtual-module export name. Always starts with "__zcRe". */
+  name: string;
+  /** Pattern source string (verbatim match against `g.regex()` 2nd argument). */
+  source: string;
+  /**
+   * Behavior-equivalent faster pattern used for the actual `.test()` regex.
+   * Issue reporting (`pattern:` field) always uses `source` so generated
+   * issues stay byte-identical to zod's.
+   */
+  testSource?: string;
 }
-export declare const WELL_KNOWN_REGEXES: readonly WellKnownRegex[];
+declare const WELL_KNOWN_REGEXES: readonly WellKnownRegex[];
 /**
  * Look up a well-known regex by its pattern source string.
  * Returns the virtual-module export name or null if the pattern is user-defined.
  */
-export declare function lookupWellKnownRegex(source: string): string | null;
+declare function lookupWellKnownRegex(source: string): string | null;
 /**
  * Look up the hand-written behavior-equivalent test pattern for a regex source.
  * Returns null when no rewrite is registered in {@link WELL_KNOWN_REGEXES}.
@@ -51,7 +52,7 @@ export declare function lookupWellKnownRegex(source: string): string | null;
  * layers automatic repeat unrolling on top and also covers user-supplied
  * patterns that are in no table.
  */
-export declare function lookupFastRegexSource(source: string): string | null;
+declare function lookupFastRegexSource(source: string): string | null;
 /**
  * The pattern a generated `.test()` should actually run for `source`, or null
  * when `source` is already the best form.
@@ -67,12 +68,14 @@ export declare function lookupFastRegexSource(source: string): string | null;
  * need its flags carried into the reported pattern too) and must keep
  * reporting the ORIGINAL source in issues — see `emitRegexSourceString`.
  */
-export declare function fastTestSource(source: string): string | null;
+declare function fastTestSource(source: string): string | null;
 /**
  * Virtual-module export name for the ORIGINAL `/source/` pattern string of a
  * rewritten well-known regex (e.g. "__zcReEmailSrc"). Issue sites reference it
  * so the original pattern stays a single bundle-wide string even though the
  * runtime regex object is built from testSource.
  */
-export declare function wellKnownRegexSourceName(source: string): string | null;
+declare function wellKnownRegexSourceName(source: string): string | null;
+//#endregion
+export { EMAIL_FAST_REGEX_SOURCE, EMAIL_REGEX_SOURCE, UUID_REGEX_SOURCE, WELL_KNOWN_REGEXES, WellKnownRegex, fastTestSource, lookupFastRegexSource, lookupWellKnownRegex, wellKnownRegexSourceName };
 //# sourceMappingURL=well-known-regex.d.ts.map

package/dist/core/codegen/well-known-regex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"well-known-regex.d.ts","sourceRoot":"","sources":["../../../src/core/codegen/well-known-regex.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,0FAA0F;AAC1F,eAAO,MAAM,kBAAkB,QAA+G,CAAC;AAE/I;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,uBAAuB,QAAqH,CAAC;AAE1J,kGAAkG;AAClG,eAAO,MAAM,iBAAiB,2KAC4I,CAAC;AAE3K,MAAM,WAAW,cAAc;IAC7B,sEAAsE;IACtE,IAAI,EAAE,MAAM,CAAC;IACb,+EAA+E;IAC/E,MAAM,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,eAAO,MAAM,kBAAkB,EAAE,SAAS,cAAc,EA6BvD,CAAC;AAaF;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAElE;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAEnE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAG5D;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAItE"}
+{"version":3,"file":"well-known-regex.d.ts","names":[],"sources":["../../../src/core/codegen/well-known-regex.ts"],"mappings":";;;;;;;;;;;;cAca;;;;;;;;;;;;;cAcA;;cAGA;UAGI;;EAEf;;EAEA;;;;;;EAMA;;cAGW,6BAA6B;;;;;iBA8C1B,qBAAqB;;;;;;;;;iBAYrB,sBAAsB;;;;;;;;;;;;;;;;iBAmBtB,eAAe;;;;;;;iBAWf,yBAAyB"}

package/dist/core/codegen/well-known-regex.js

@@ -1,111 +1,142 @@
-/**
- * Well-known regex sources hosted in the virtual module "virtual:zod-compiler/runtime".
- *
- * In lean mode (unplugin), `g.regex()` consults this registry and emits a reference
- * like `__zcReEmail` instead of declaring `var __re_email_*=new RegExp(...)`.
- * The bundler then deduplicates the regex literal across all transformed files.
- *
- * Pattern sources are matched verbatim (string equality). Add new entries as Zod
- * exposes additional well-known formats and we want bundle-wide dedup.
- */
 import { unrollRepeats } from "./regex-unroll.js";
+//#region src/core/codegen/well-known-regex.ts
+/**
+* Well-known regex sources hosted in the virtual module "virtual:zod-compiler/runtime".
+*
+* In lean mode (unplugin), `g.regex()` consults this registry and emits a reference
+* like `__zcReEmail` instead of declaring `var __re_email_*=new RegExp(...)`.
+* The bundler then deduplicates the regex literal across all transformed files.
+*
+* Pattern sources are matched verbatim (string equality). Add new entries as Zod
+* exposes additional well-known formats and we want bundle-wide dedup.
+*/
 /** Zod v4's email regex source (string.ts uses this directly when format === "email"). */
-export const EMAIL_REGEX_SOURCE = String.raw `^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$`;
+const EMAIL_REGEX_SOURCE = String.raw`^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$`;
 /**
- * Behavior-equivalent rewrite of EMAIL_REGEX_SOURCE that runs ~1.45x faster on V8.
- *
- * Zod's pattern fronts two lookaheads; `(?!.*\.\.)` re-scans the entire string
- * before matching starts. The rewrite encodes the same constraints structurally:
- * the local part is dot-separated runs of `[A-Za-z0-9_'+-]` (no leading dot, no
- * empty run ⇒ no `..`) ending in `[A-Za-z0-9_+-]`, and the domain grammar already
- * makes `..` impossible (every label starts with an alphanumeric).
- *
- * Equivalence is enforced by tests/core/codegen/email-fast-regex.test.ts
- * (exhaustive short-string sweep + structured cases + random fuzz).
- */
-export const EMAIL_FAST_REGEX_SOURCE = String.raw `^(?:[A-Za-z0-9_'+\-]+\.)*[A-Za-z0-9_'+\-]*[A-Za-z0-9_+-]@(?:[A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$`;
+* Behavior-equivalent rewrite of EMAIL_REGEX_SOURCE that runs ~1.45x faster on V8.
+*
+* Zod's pattern fronts two lookaheads; `(?!.*\.\.)` re-scans the entire string
+* before matching starts. The rewrite encodes the same constraints structurally:
+* the local part is dot-separated runs of `[A-Za-z0-9_'+-]` (no leading dot, no
+* empty run ⇒ no `..`) ending in `[A-Za-z0-9_+-]`, and the domain grammar already
+* makes `..` impossible (every label starts with an alphanumeric).
+*
+* Equivalence is enforced by tests/core/codegen/email-fast-regex.test.ts
+* (exhaustive short-string sweep + structured cases + random fuzz).
+*/
+const EMAIL_FAST_REGEX_SOURCE = String.raw`^(?:[A-Za-z0-9_'+\-]+\.)*[A-Za-z0-9_'+\-]*[A-Za-z0-9_+-]@(?:[A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$`;
 /** Fallback UUID regex used when the extractor doesn't provide a pattern (e.g. in unit tests). */
-export const UUID_REGEX_SOURCE = "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$";
-export const WELL_KNOWN_REGEXES = [
-    { name: "__zcReEmail", source: EMAIL_REGEX_SOURCE, testSource: EMAIL_FAST_REGEX_SOURCE },
-    { name: "__zcReUuid", source: UUID_REGEX_SOURCE },
-    { name: "__zcReCuid", source: "^[cC][^\\s-]{8,}$" },
-    { name: "__zcReCuid2", source: "^[0-9a-z]+$" },
-    { name: "__zcReUlid", source: "^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$" },
-    { name: "__zcReNanoid", source: "^[a-zA-Z0-9_-]{21}$" },
-    { name: "__zcReXid", source: "^[0-9a-vA-V]{20}$" },
-    { name: "__zcReKsuid", source: "^[A-Za-z0-9]{27}$" },
-    {
-        name: "__zcReIpv4",
-        source: "^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$",
-    },
-    {
-        name: "__zcReIpv6",
-        source: "^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$",
-    },
-    {
-        name: "__zcReBase64",
-        source: "^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$",
-    },
-    { name: "__zcReBase64Url", source: "^[A-Za-z0-9_-]*$" },
-    { name: "__zcReE164", source: "^\\+[1-9]\\d{6,14}$" },
-    {
-        name: "__zcReGuid",
-        source: "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$",
-    },
+const UUID_REGEX_SOURCE = "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$";
+const WELL_KNOWN_REGEXES = [
+	{
+		name: "__zcReEmail",
+		source: EMAIL_REGEX_SOURCE,
+		testSource: EMAIL_FAST_REGEX_SOURCE
+	},
+	{
+		name: "__zcReUuid",
+		source: UUID_REGEX_SOURCE
+	},
+	{
+		name: "__zcReCuid",
+		source: "^[cC][^\\s-]{8,}$"
+	},
+	{
+		name: "__zcReCuid2",
+		source: "^[0-9a-z]+$"
+	},
+	{
+		name: "__zcReUlid",
+		source: "^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$"
+	},
+	{
+		name: "__zcReNanoid",
+		source: "^[a-zA-Z0-9_-]{21}$"
+	},
+	{
+		name: "__zcReXid",
+		source: "^[0-9a-vA-V]{20}$"
+	},
+	{
+		name: "__zcReKsuid",
+		source: "^[A-Za-z0-9]{27}$"
+	},
+	{
+		name: "__zcReIpv4",
+		source: "^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$"
+	},
+	{
+		name: "__zcReIpv6",
+		source: "^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$"
+	},
+	{
+		name: "__zcReBase64",
+		source: "^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$"
+	},
+	{
+		name: "__zcReBase64Url",
+		source: "^[A-Za-z0-9_-]*$"
+	},
+	{
+		name: "__zcReE164",
+		source: "^\\+[1-9]\\d{6,14}$"
+	},
+	{
+		name: "__zcReGuid",
+		source: "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$"
+	}
 ];
 const SOURCE_TO_NAME = new Map(WELL_KNOWN_REGEXES.map((r) => [r.source, r.name]));
-const SOURCE_TO_TEST_SOURCE = new Map(WELL_KNOWN_REGEXES.filter((r) => r.testSource !== undefined).map((r) => [
-    r.source,
-    r.testSource,
-]));
+const SOURCE_TO_TEST_SOURCE = new Map(WELL_KNOWN_REGEXES.filter((r) => r.testSource !== void 0).map((r) => [r.source, r.testSource]));
 /**
- * Look up a well-known regex by its pattern source string.
- * Returns the virtual-module export name or null if the pattern is user-defined.
- */
-export function lookupWellKnownRegex(source) {
-    return SOURCE_TO_NAME.get(source) ?? null;
+* Look up a well-known regex by its pattern source string.
+* Returns the virtual-module export name or null if the pattern is user-defined.
+*/
+function lookupWellKnownRegex(source) {
+	return SOURCE_TO_NAME.get(source) ?? null;
 }
 /**
- * Look up the hand-written behavior-equivalent test pattern for a regex source.
- * Returns null when no rewrite is registered in {@link WELL_KNOWN_REGEXES}.
- *
- * This is the TABLE lookup only. Codegen calls {@link fastTestSource}, which
- * layers automatic repeat unrolling on top and also covers user-supplied
- * patterns that are in no table.
- */
-export function lookupFastRegexSource(source) {
-    return SOURCE_TO_TEST_SOURCE.get(source) ?? null;
+* Look up the hand-written behavior-equivalent test pattern for a regex source.
+* Returns null when no rewrite is registered in {@link WELL_KNOWN_REGEXES}.
+*
+* This is the TABLE lookup only. Codegen calls {@link fastTestSource}, which
+* layers automatic repeat unrolling on top and also covers user-supplied
+* patterns that are in no table.
+*/
+function lookupFastRegexSource(source) {
+	return SOURCE_TO_TEST_SOURCE.get(source) ?? null;
 }
 /**
- * The pattern a generated `.test()` should actually run for `source`, or null
- * when `source` is already the best form.
- *
- * Two behavior-preserving rewrites compose here: the hand-written table entry
- * above (currently just email), then {@link unrollRepeats}, which turns bounded
- * repeats of single-character atoms into explicit repetition — worth 1.3-3.4x
- * on the string formats everyday schemas use (uuid, guid, ulid, nanoid, xid,
- * ksuid, base64, e164, iso.date). Unrolling runs on the table rewrite when
- * there is one, so the two stack.
- *
- * Callers must apply this only to flag-less regexes (the flagged form would
- * need its flags carried into the reported pattern too) and must keep
- * reporting the ORIGINAL source in issues — see `emitRegexSourceString`.
- */
-export function fastTestSource(source) {
-    const tableRewrite = SOURCE_TO_TEST_SOURCE.get(source) ?? null;
-    return unrollRepeats(tableRewrite ?? source) ?? tableRewrite;
+* The pattern a generated `.test()` should actually run for `source`, or null
+* when `source` is already the best form.
+*
+* Two behavior-preserving rewrites compose here: the hand-written table entry
+* above (currently just email), then {@link unrollRepeats}, which turns bounded
+* repeats of single-character atoms into explicit repetition — worth 1.3-3.4x
+* on the string formats everyday schemas use (uuid, guid, ulid, nanoid, xid,
+* ksuid, base64, e164, iso.date). Unrolling runs on the table rewrite when
+* there is one, so the two stack.
+*
+* Callers must apply this only to flag-less regexes (the flagged form would
+* need its flags carried into the reported pattern too) and must keep
+* reporting the ORIGINAL source in issues — see `emitRegexSourceString`.
+*/
+function fastTestSource(source) {
+	const tableRewrite = SOURCE_TO_TEST_SOURCE.get(source) ?? null;
+	return unrollRepeats(tableRewrite ?? source) ?? tableRewrite;
 }
 /**
- * Virtual-module export name for the ORIGINAL `/source/` pattern string of a
- * rewritten well-known regex (e.g. "__zcReEmailSrc"). Issue sites reference it
- * so the original pattern stays a single bundle-wide string even though the
- * runtime regex object is built from testSource.
- */
-export function wellKnownRegexSourceName(source) {
-    const name = SOURCE_TO_NAME.get(source);
-    if (name === undefined)
-        return null;
-    return fastTestSource(source) !== null ? `${name}Src` : null;
+* Virtual-module export name for the ORIGINAL `/source/` pattern string of a
+* rewritten well-known regex (e.g. "__zcReEmailSrc"). Issue sites reference it
+* so the original pattern stays a single bundle-wide string even though the
+* runtime regex object is built from testSource.
+*/
+function wellKnownRegexSourceName(source) {
+	const name = SOURCE_TO_NAME.get(source);
+	if (name === void 0) return null;
+	return fastTestSource(source) !== null ? `${name}Src` : null;
 }
+//#endregion
+export { EMAIL_FAST_REGEX_SOURCE, EMAIL_REGEX_SOURCE, UUID_REGEX_SOURCE, WELL_KNOWN_REGEXES, fastTestSource, lookupFastRegexSource, lookupWellKnownRegex, wellKnownRegexSourceName };
+
 //# sourceMappingURL=well-known-regex.js.map