zod-compiler 1.23.0 → 1.23.2

package/dist/core/codegen/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/codegen/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/core/codegen/index.ts"],"sourcesContent":["import type { SchemaIR } from \"../types.js\";\nimport type { CodeGenContext, CodeGenResult, CodegenMode, RecTargetGen } from \"./context.js\";\nimport { generateBuild, rebuildsOutput } from \"./build-path.js\";\nimport { declareFastTemps, emitRfDelegate, hasMutation } from \"./context.js\";\nimport type { SharedSchemaPlan } from \"./dedupe.js\";\nimport { createFastGen, generateFast } from \"./fast-path.js\";\nimport { createSlowGen, generateSlow } from \"./slow-path.js\";\n\nexport type { CodeGenResult } from \"./context.js\";\n\nexport interface GenerateValidatorOptions {\n  refCount?: number;\n  /** Codegen output mode. Defaults to \"inline\". */\n  mode?: CodegenMode;\n  /**\n   * File-level shared slow-walk plan (schema deduplication). Applied only to\n   * mutation-free schemas, so shared walks stay on the deferred cold path.\n   */\n  sharedSchemas?: SharedSchemaPlan | undefined;\n  /**\n   * Compact mode (`output: \"compact\"`). Drop the compiled slow walk for\n   * mutation-free schemas with a TOTAL fast path and delegate the cold error\n   * path to the retained Zod schema (`__zcFinZ`). The fast (hot) path is\n   * unchanged; only the bulky error-collecting walk — 64–77% of generated\n   * bytes — is replaced by a few bytes of zod delegation. See\n   * {@link CodeGenResult.rootDelegateRefIndex}.\n   */\n  compact?: boolean | undefined;\n}\n\n/**\n * Generate optimized validation code from SchemaIR.\n *\n * - `code`: preamble declarations (Sets, RegExps, etc.) — deterministic for the same IR\n * - `functionDef`: full function expression string referencing preamble vars via closure\n * - `usedHelpers`: helper names from \"virtual:zod-compiler/runtime\" referenced (lean mode only)\n *\n * Usage: `new Function(code + \"\\nreturn \" + functionDef + \";\")()`\n */\nexport function generateValidator(\n  ir: SchemaIR,\n  name: string,\n  options?: GenerateValidatorOptions,\n): CodeGenResult {\n  const fnName = `safeParse_${name}`;\n  const mode: CodegenMode = options?.mode ?? \"inline\";\n  const ctx: CodeGenContext = {\n    preamble: [],\n    counter: 0,\n    fnName,\n    regexCache: new Map(),\n    mode,\n    usedHelpers: new Set(),\n  };\n\n  // Slow-walk sharing. The plan already excludes any shape that would reach for\n  // this export's `__rf[]`, and a shared walk returns its parsed value, so a\n  // rewriting shape (a stripping object above all) delivers its result through\n  // the call. Nothing left to gate on here.\n  if (options?.sharedSchemas !== undefined) {\n    ctx.sharedSchemas = options.sharedSchemas;\n  }\n\n  // Root-level fallback: the whole schema delegates to Zod, so zod's own\n  // safeParse result IS the result. Returning it directly skips the issue\n  // copy loop (which would force zod's eager ZodError construction), the\n  // pointless [].concat(path) rewrites, and the __zcFin re-wrap. Delegation\n  // goes through the pre-mutation capture (emitRfDelegate) — here __rf[0]\n  // and the __zcMkv target are routinely the SAME object.\n  if (ir.type === \"fallback\" && ir.refIndex !== undefined) {\n    const delegate = emitRfDelegate(ctx, ir.refIndex);\n    return {\n      code: [\"/* zod-compiler */\", ...ctx.preamble].join(\"\\n\"),\n      functionDef: `function ${fnName}(input){return ${delegate}(input);}`,\n      refCount: options?.refCount ?? 0,\n      usedHelpers: ctx.usedHelpers,\n      fastFnName: null,\n      fastTotal: false,\n    };\n  }\n\n  // Recursion-target table. The root (refId 0) reuses the schema's own\n  // `safeParse_<name>` / hosted fast-check, so it needs no separate helper and\n  // its fast name is allocated lazily during the walk (recFastName). Non-root\n  // targets — recursive sub-schemas nested in a larger root, multiple distinct\n  // recursive shapes, mutual recursion — are each hosted as a standalone\n  // `__rsp_N` (slow) / `__fcr_N` (fast) validator the cycle calls by name.\n  // Common directly-self-recursive schemas have no non-root targets, so this\n  // leaves their generated output byte-identical.\n  const nonRootTargets = collectRecursionTargets(ir);\n  ctx.recTargets = new Map<number, RecTargetGen>([[0, { isRoot: true, slowName: fnName }]]);\n  for (const [refId, inner] of nonRootTargets) {\n    ctx.recTargets.set(refId, {\n      isRoot: false,\n      inner,\n      slowName: `__rsp_${ctx.counter++}`,\n      fastName: `__fcr_${ctx.counter++}`,\n    });\n  }\n  const hasNonRootTargets = nonRootTargets.size > 0;\n\n  // Fast Path: generate a boolean expression for eligible schemas.\n  //\n  // generateFast mutates ctx as it walks (extracted __fo_ helpers + regex/effect\n  // decls pushed to the preamble, a recursive __fcr_ name reserved, dedup caches\n  // populated). The walk is all-or-nothing: a later fast-ineligible node makes it\n  // return null AFTER those side effects already landed. Without a rollback the\n  // discarded fast path leaves dead __fo_ helpers in the output — and, when one\n  // referenced the recursive __fcr_ host that the `fastExpr !== null` branch below\n  // never emits, a dangling reference to an undefined identifier. Snapshot the\n  // mutable state and restore it on abort so the slow path re-declares from clean.\n  const fastPreambleLen = ctx.preamble.length;\n  const fastRegexCache = new Map(ctx.regexCache);\n  const fastEffectCache = ctx.effectFnCache && new Map(ctx.effectFnCache);\n  const fastValueCache = ctx.valueCache && new Map(ctx.valueCache);\n  const fastRecName = ctx.recFastName;\n  const fg = createFastGen(\"input\", ctx);\n  let fastExpr = generateFast(ir, fg);\n  if (fastExpr !== null && hasNonRootTargets) {\n    // Host each non-root recursion target as a boolean fast-check helper. A\n    // single fast-ineligible target (e.g. one whose recursive shape contains a\n    // fallback) disables the WHOLE fast path: the root expression already emits\n    // calls to these names, so a missing body would dangle. The shared\n    // rollback below then restores clean state for the slow-only path.\n    for (const t of ctx.recTargets.values()) {\n      if (t.isRoot) continue;\n      const targetGen = createFastGen(\"input\", ctx, false);\n      const body = generateFast(t.inner as SchemaIR, targetGen);\n      if (body === null) {\n        fastExpr = null;\n        break;\n      }\n      ctx.preamble.push(\n        `function ${t.fastName}(input){${declareFastTemps(targetGen.scope)}return ${body};}`,\n      );\n    }\n  }\n  if (fastExpr === null) {\n    ctx.preamble.length = fastPreambleLen;\n    ctx.regexCache = fastRegexCache;\n    if (fastEffectCache === undefined) delete ctx.effectFnCache;\n    else ctx.effectFnCache = fastEffectCache;\n    // Value declarations the abandoned walk emitted are truncated above, so\n    // their cache entries would name identifiers that no longer exist.\n    if (fastValueCache === undefined) delete ctx.valueCache;\n    else ctx.valueCache = fastValueCache;\n    if (fastRecName === undefined) delete ctx.recFastName;\n    else ctx.recFastName = fastRecName;\n  }\n\n  // Host the fast expression in a named boolean helper. Self-recursive\n  // schemas need it so recursive refs can call it; every other eligible\n  // schema benefits too: __zcMkv wires it into parse()/parseAsync(), whose\n  // success paths then return the input directly — no intermediate\n  // SafeParseResult allocation (the safeParse function body is far past\n  // V8's inlining budget, so escape analysis never removes it).\n  let fastFnName: string | null = null;\n  if (fastExpr !== null && fastExpr !== \"true\") {\n    fastFnName = ctx.recFastName ?? `__fc_${ctx.counter++}`;\n    ctx.preamble.push(\n      `function ${fastFnName}(input){${declareFastTemps(fg.scope)}return ${fastExpr};}`,\n    );\n    fastExpr = `${fastFnName}(input)`;\n  }\n\n  // Build Path: one pass that validates and assembles rewritten output, bailing\n  // on the first failure (see build-path). Null unless every mutation in the\n  // schema is modelled — so this emits nothing for the mutation-free schemas\n  // the compact branch takes.\n  const buildFnName = generateBuild(ir, ctx);\n\n  // `.is()` for a build-path schema is the fast expression — stripping reshapes\n  // the payload, never the verdict. A substituted `.default()` breaks that: the\n  // fast check demands a present value where the schema accepts its absence, so\n  // the predicate is partial and `.is()` falls back to safeParse().success\n  // (which runs the build pass, so it is no slower than the eager walk was).\n  const buildIsFnName = ctx.buildSubstitutesValue === true ? null : fastFnName;\n\n  const baseRefCount = options?.refCount ?? 0;\n\n  // Compact mode: a mutation-free schema with a TOTAL fast path needs no\n  // compiled slow walk — its only purpose is reproducing zod's issues on\n  // failure, and the original zod schema (retained in `output: \"compact\"`) does\n  // that exactly. Emit the fast check and, on failure, delegate to a fresh root\n  // RefEntry (the schema itself) via the pristine-bound safeParse capture, then\n  // wrap it in the lazy `__zcFinZ` failure. Drops 64–77% of generated bytes\n  // with zero hot-path cost (fc and `.is()` are unchanged) and zod-identical\n  // errors. Excluded: schemas with non-root recursion targets (mutual/nested\n  // recursion still hosts standalone slow validators) and any non-total fast\n  // path (mutation/default/catch/fallback) — those keep the compiled path.\n  if (\n    options?.compact === true &&\n    fastExpr !== null &&\n    fastExpr !== \"true\" &&\n    !hasMutation(ir) &&\n    !hasNonRootTargets\n  ) {\n    const delegate = emitRfDelegate(ctx, baseRefCount);\n    ctx.usedHelpers.add(\"__zcFinZ\");\n    return {\n      code: [\"/* zod-compiler */\", ...ctx.preamble].join(\"\\n\"),\n      functionDef: [\n        `function ${fnName}(input){`,\n        `if(${fastExpr}){return{success:true,data:input};}`,\n        `return __zcFinZ(${delegate},input);`,\n        `}`,\n      ].join(\"\\n\"),\n      refCount: baseRefCount + 1,\n      usedHelpers: ctx.usedHelpers,\n      fastFnName,\n      // Mutation-free total fast path: fc(input) ⟺ accepts(input), so `.is()`\n      // installs fc directly (compact never weakens the guard).\n      fastTotal: true,\n      rootDelegateRefIndex: baseRefCount,\n    };\n  }\n\n  // Compact + Build Path: same bargain for a schema with modelled rewrites. The\n  // build pass still has to run (it produces the payload, which zod's schema\n  // would only reproduce by parsing again), but the compiled issue walk is what\n  // compact drops, and delegating that to the retained zod schema costs a few\n  // bytes.\n  if (\n    options?.compact === true &&\n    buildFnName !== null &&\n    ctx.buildFailName !== undefined &&\n    !hasNonRootTargets\n  ) {\n    const delegate = emitRfDelegate(ctx, baseRefCount);\n    ctx.usedHelpers.add(\"__zcFinZ\");\n    const built = `__bd_${ctx.counter++}`;\n    return {\n      code: [\"/* zod-compiler */\", ...ctx.preamble].join(\"\\n\"),\n      functionDef: [\n        `function ${fnName}(input){`,\n        `var ${built}=${buildFnName}(input);`,\n        `if(${built}!==${ctx.buildFailName}){return{success:true,data:${built}};}`,\n        `return __zcFinZ(${delegate},input);`,\n        `}`,\n      ].join(\"\\n\"),\n      refCount: baseRefCount + 1,\n      usedHelpers: ctx.usedHelpers,\n      fastFnName: null,\n      fastTotal: false,\n      isFnName: buildIsFnName,\n      rootDelegateRefIndex: baseRefCount,\n    };\n  }\n\n  // Host each non-root recursion target as a safeParse-shaped slow validator,\n  // mirroring the root's eager body: collect issues, return success+data or a\n  // deferred-error result. Always emitted (the slow path always exists); the\n  // recursion call sites read `.success` / `.error.issues` / `.data`. Hoisted\n  // function declarations, so their order relative to the root is irrelevant.\n  if (hasNonRootTargets) {\n    for (const t of ctx.recTargets.values()) {\n      if (t.isRoot) continue;\n      const body = generateSlow(t.inner as SchemaIR, createSlowGen(\"_d\", \"_d\", \"[]\", \"_e\", ctx));\n      ctx.usedHelpers.add(\"__zcFin\");\n      ctx.preamble.push(\n        `function ${t.slowName}(input){var _e=[];\\nvar _d=input;\\n${body}\\n` +\n          `if(_e.length===0){return{success:true,data:_d};}\\nreturn __zcFin(_e,_d);}`,\n      );\n    }\n  }\n\n  const sg = createSlowGen(\"_d\", \"_d\", \"[]\", \"_e\", ctx);\n  // When the root schema's own shape is shared (it recurs as a sub-schema of\n  // another export, or as a duplicate root), its slow walk delegates to the\n  // shared function instead of emitting a second full copy. The fast path is\n  // still generated inline above — only the cold walk is shared.\n  const rootRef = ctx.sharedSchemas?.refFor(ir);\n  const slowCode = rootRef !== undefined ? `_d=${rootRef.name}(_d,[],_e);` : generateSlow(ir, sg);\n\n  const buildCode = (): string => [\"/* zod-compiler */\", ...ctx.preamble].join(\"\\n\");\n\n  const functionDefParts = [`function ${fnName}(input){`];\n\n  // Build Path: every mutation is modelled, so one pass can validate and\n  // assemble the output together and bail on the first failure, leaving the\n  // issue-producing walk deferred behind `.error` (see build-path).\n  // The fast check stays out of `safeParse` entirely — running it first would\n  // read every property twice — but it is still an EXACT acceptance predicate\n  // (stripping reshapes the output, never the verdict), so `.is()` installs it.\n  if (buildFnName !== null && ctx.buildFailName !== undefined) {\n    ctx.usedHelpers.add(\"__zcFinD\");\n    const built = `__bd_${ctx.counter++}`;\n    // A self-recursive walk calls this validator BY NAME (slowRecursiveRef),\n    // and that binding exists only inside the named function expression — so\n    // there the walk stays a per-call closure. Everything else hosts it in the\n    // preamble, keeping safeParse to three statements. Mirrors the same split\n    // in the mutation-free branch below.\n    const recursive = slowCode.includes(fnName);\n    let deferred: string;\n    if (recursive) {\n      deferred = `__zcFinD(function(input){var _e=[];\\nvar _d=input;\\n${slowCode}\\nreturn _e;},input)`;\n    } else {\n      const walkName = `__sw_${ctx.counter++}`;\n      ctx.preamble.push(\n        `function ${walkName}(input){var _e=[];\\nvar _d=input;\\n${slowCode}\\nreturn _e;}`,\n      );\n      deferred = `__zcFinD(${walkName},input)`;\n    }\n    return {\n      code: buildCode(),\n      functionDef: [\n        `function ${fnName}(input){`,\n        `var ${built}=${buildFnName}(input);`,\n        `if(${built}!==${ctx.buildFailName}){return{success:true,data:${built}};}`,\n        `return ${deferred};`,\n        `}`,\n      ].join(\"\\n\"),\n      refCount: options?.refCount ?? 0,\n      usedHelpers: ctx.usedHelpers,\n      // No by-reference shortcut: `data` is the freshly built object, so\n      // parse() must go through safeParse rather than returning its input.\n      fastFnName: null,\n      // `fastTotal` qualifies `fastFnName`, which is null here; the predicate\n      // travels in `isFnName` instead.\n      fastTotal: false,\n      isFnName: buildIsFnName,\n    };\n  }\n\n  if (fastExpr === \"true\") {\n    // Schema always succeeds (any/unknown) — skip slow path entirely\n    functionDefParts.push(`return{success:true,data:input};`);\n    functionDefParts.push(`}`);\n    return {\n      code: buildCode(),\n      functionDef: functionDefParts.join(\"\\n\"),\n      refCount: options?.refCount ?? 0,\n      usedHelpers: ctx.usedHelpers,\n      fastFnName: null,\n      // any/unknown always succeed; `.is()` derives `true` from the fn fallback.\n      fastTotal: false,\n    };\n  }\n\n  if (fastExpr !== null && !hasMutation(ir)) {\n    // Mutation-free schemas with a fast path: a fast-check failure can never\n    // become a slow-path success (both are generated from the same checks —\n    // unlike default/catch schemas, whose partial fast path requires value\n    // presence while the slow path SUCCEEDS by applying the fallback).\n    // The slow path's only output is therefore the issues array, observable\n    // solely through `.error` — defer the whole re-walk into the cached\n    // accessor (__zcFinD): a failed safeParse whose `.error` is never read\n    // costs the fast check alone.\n    //\n    // The walk is HOSTED as a named preamble function rather than a per-call\n    // closure, for two measured reasons: (1) a failed safeParse no longer\n    // allocates a closure environment + function object before the deferral\n    // even starts; (2) the safeParse body shrinks to two statements, putting\n    // it within V8's inlining budget — callers in hot loops get the\n    // success-path result object escape-analyzed away entirely, which the\n    // old shape (slow walk inlined into the body) made impossible.\n    ctx.usedHelpers.add(\"__zcFinD\");\n    if (slowCode.includes(fnName)) {\n      // Self-recursive slow paths call the safeParse function by NAME\n      // (slowRecursiveRef) — that binding exists only inside the named\n      // function expression under the documented evaluation contract\n      // (`new Function(code + \"return \" + functionDef)`), so the walk stays\n      // a per-call closure for recursive schemas. Recursion is the rare\n      // shape; everything else gets the hosted walk.\n      functionDefParts.push(\n        `if(${fastExpr}){return{success:true,data:input};}`,\n        `return __zcFinD(function(input){`,\n        `var _e=[];`,\n        `var _d=input;`,\n        slowCode,\n        `return _e;`,\n        `},input);`,\n        `}`,\n      );\n    } else {\n      const walkName = `__sw_${ctx.counter++}`;\n      ctx.preamble.push(\n        `function ${walkName}(input){var _e=[];\\nvar _d=input;\\n${slowCode}\\nreturn _e;}`,\n      );\n      functionDefParts.push(\n        `if(${fastExpr}){return{success:true,data:input};}`,\n        `return __zcFinD(${walkName},input);`,\n        `}`,\n      );\n    }\n    return {\n      code: buildCode(),\n      functionDef: functionDefParts.join(\"\\n\"),\n      refCount: options?.refCount ?? 0,\n      usedHelpers: ctx.usedHelpers,\n      fastFnName,\n      // Total predicate: mutation-free fast path, fc(input) ⟺ accepts(input).\n      // generateIIFE installs fc directly as the zero-allocation `.is()`.\n      fastTotal: true,\n    };\n  }\n\n  if (fastExpr !== null && !rebuildsOutput(ir)) {\n    // Partial fast path (default/catch/... present-value shortcut): the slow\n    // path must run eagerly — it can succeed where the fast check failed.\n    //\n    // Withheld when the schema rebuilds its output: there the fast check is a\n    // sound VERDICT but says nothing about the payload, and `data:input` would\n    // hand back the unstripped input. Such schemas reach here only when the\n    // build path declined them, so the eager walk produces the output instead.\n    functionDefParts.push(`if(${fastExpr}){return{success:true,data:input};}`);\n  }\n\n  // Success branch inlined at the call site instead of inside __zcFin: the\n  // eager path (mutation schemas — coerce/default/trim/transform) returns\n  // here on EVERY parse, and the inline literal keeps the hot exit free of a\n  // cross-function call; __zcFin is reached only on failure.\n  functionDefParts.push(\n    `var _e=[];`,\n    `var _d=input;`,\n    slowCode,\n    `if(_e.length===0){return{success:true,data:_d};}`,\n    `return __zcFin(_e,_d);`,\n    `}`,\n  );\n\n  const functionDef = functionDefParts.join(\"\\n\");\n\n  return {\n    code: buildCode(),\n    functionDef,\n    refCount: options?.refCount ?? 0,\n    usedHelpers: ctx.usedHelpers,\n    fastFnName,\n    // Partial fast path (default/catch) or none (including coercion): a false fc\n    // result does not imply rejection, so `.is()` derives from\n    // safeParse(input).success.\n    fastTotal: false,\n  };\n}\n\n/**\n * Find every non-root recursion target (a `recursionTarget` node, refId ≥ 1)\n * reachable from `root`, mapping refId → the inner IR to host as a standalone\n * validator. The root target (refId 0) is the schema's own function and is\n * never wrapped, so it never appears here. The same target may be wrapped at\n * several sites (a recursive schema reached from sibling positions); the first\n * inner wins — they are structurally identical extractions of one schema.\n */\nfunction collectRecursionTargets(root: SchemaIR): Map<number, SchemaIR> {\n  const out = new Map<number, SchemaIR>();\n  const seen = new Set<SchemaIR>();\n  const walk = (ir: SchemaIR): void => {\n    if (seen.has(ir)) return;\n    seen.add(ir);\n    if (ir.type === \"recursionTarget\" && !out.has(ir.refId)) {\n      out.set(ir.refId, ir.inner);\n    }\n    for (const child of childIRs(ir)) walk(child);\n  };\n  walk(root);\n  return out;\n}\n\n/** Direct child SchemaIR nodes, covering every node type (including the new wrapper). */\nfunction childIRs(ir: SchemaIR): readonly SchemaIR[] {\n  switch (ir.type) {\n    case \"object\":\n      return Object.values(ir.properties);\n    case \"array\":\n      return [ir.element];\n    case \"tuple\":\n      return ir.rest === null ? ir.items : [...ir.items, ir.rest];\n    case \"record\":\n    case \"map\":\n      return [ir.keyType, ir.valueType];\n    case \"set\":\n      return [ir.valueType];\n    case \"union\":\n    case \"discriminatedUnion\":\n      return ir.options;\n    case \"intersection\":\n      return [ir.left, ir.right];\n    case \"optional\":\n    case \"nullable\":\n    case \"readonly\":\n    case \"default\":\n    case \"catch\":\n    case \"effect\":\n    case \"recursionTarget\":\n      return [ir.inner];\n    case \"pipe\":\n      return [ir.in, ir.out];\n    default:\n      return [];\n  }\n}\n"],"mappings":"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"}

package/dist/core/codegen/issue-decls.d.ts

@@ -1,3 +1,4 @@
+//#region src/core/codegen/issue-decls.d.ts
 /**
  * Issue factory function bodies (statement form).
  *
@@ -17,13 +18,13 @@
  * absent, the __zcFin finalizer applies the configured locale default.
  */
 /** All issue factory declarations indexed by helper name. */
-export declare const ISSUE_DECLS: Readonly<Record<string, string>>;
+declare const ISSUE_DECLS: Readonly<Record<string, string>>;
 /**
  * Float-safe remainder — byte-for-byte port of zod's util.floatSafeRemainder.
  * Raw `%` mis-rejects valid multiples of decimal steps (0.3 % 0.1 !== 0);
  * zod scales both operands to integers by their decimal-place count first.
  */
-export declare const ZC_FSR_DECL = "function __zcFsr(v,s){var vd=((\"\"+v).split(\".\")[1]||\"\").length;var ss=\"\"+s;var sd=(ss.split(\".\")[1]||\"\").length;if(sd===0&&/\\d?e-\\d?/.test(ss)){var m=ss.match(/\\d?e-(\\d?)/);if(m&&m[1]){sd=parseInt(m[1],10);}}var d=vd>sd?vd:sd;var vi=parseInt(v.toFixed(d).replace(\".\",\"\"),10);var si=parseInt(s.toFixed(d).replace(\".\",\"\"),10);return (vi%si)/Math.pow(10,d);}";
+declare const ZC_FSR_DECL = "function __zcFsr(v,s){var vd=((\"\"+v).split(\".\")[1]||\"\").length;var ss=\"\"+s;var sd=(ss.split(\".\")[1]||\"\").length;if(sd===0&&/\\d?e-\\d?/.test(ss)){var m=ss.match(/\\d?e-(\\d?)/);if(m&&m[1]){sd=parseInt(m[1],10);}}var d=vd>sd?vd:sd;var vi=parseInt(v.toFixed(d).replace(\".\",\"\"),10);var si=parseInt(s.toFixed(d).replace(\".\",\"\"),10);return (vi%si)/Math.pow(10,d);}";
 /**
  * Hoisted `Object.prototype.hasOwnProperty` reference. Record fast/slow paths
  * iterate keys with `for(k in o)` (no `Object.keys` array allocation) and guard
@@ -33,9 +34,9 @@ export declare const ZC_FSR_DECL = "function __zcFsr(v,s){var vd=((\"\"+v).split
  * preserved. The hoisted reference inlines in V8; reading the prototype property
  * per call would not.
  */
-export declare const ZC_HOP_DECL = "const __zcHop=Object.prototype.hasOwnProperty;";
+declare const ZC_HOP_DECL = "const __zcHop=Object.prototype.hasOwnProperty;";
 /** `c==="invalid_type"||c==="invalid_value"||…` over the code held in `codeExpr`. */
-export declare function abortingCodeTest(codeExpr: string): string;
+declare function abortingCodeTest(codeExpr: string): string;
 /**
  * Port of zod's `util.aborted(payload, startIndex)`: has anything since
  * `startIndex` produced a NON-continuable issue?
@@ -50,7 +51,7 @@ export declare function abortingCodeTest(codeExpr: string): string;
  * bypasses the abort gate — so generated code leaves those ungated and only
  * wraps the refine/superRefine effects.
  */
-export declare const ZC_AB_DECL: string;
+declare const ZC_AB_DECL: string;
 /**
  * Port of zod's `util.finalizeIssue` for issues NESTED inside an
  * `invalid_key` / `invalid_element` wrapper. Those never reach the top-level
@@ -62,7 +63,7 @@ export declare const ZC_AB_DECL: string;
  * `input` is cleared by assignment rather than `delete`, matching the top-level
  * finalizer and the union's per-option loop.
  */
-export declare const ZC_FZ_DECL: string;
+declare const ZC_FZ_DECL: string;
 /**
  * Port of zod's `util.prefixIssues(key, issues)` for a map entry whose key is a
  * property-key type: each issue's RELATIVE path is spliced onto the map's own
@@ -71,9 +72,9 @@ export declare const ZC_FZ_DECL: string;
  * `b.concat(k,x.path)` flattens `x.path` one level, giving exactly
  * `[...base, key, ...relative]`.
  */
-export declare const ZC_PFX_DECL = "function __zcPfx(d,s,b,k){for(var i=0;i<s.length;i++){var x=s[i];x.path=b.concat(k,x.path);d.push(x);}}";
+declare const ZC_PFX_DECL = "function __zcPfx(d,s,b,k){for(var i=0;i<s.length;i++){var x=s[i];x.path=b.concat(k,x.path);d.push(x);}}";
 /** Does `keyExpr` hold one of zod's `util.propertyKeyTypes` (string|number|symbol)? */
-export declare function propertyKeyTest(keyExpr: string): string;
+declare function propertyKeyTest(keyExpr: string): string;
 /**
  * superRefine fast-check: run the payload callback on a throwaway payload and
  * report whether it both added nothing AND left the value alone. zod's own
@@ -89,7 +90,7 @@ export declare function propertyKeyTest(keyExpr: string): string;
  * (see ZC_SR_DECL). Callbacks that only validate — effectively all of them —
  * still take the fast exit.
  */
-export declare const ZC_SR_OK_DECL: string;
+declare const ZC_SR_OK_DECL: string;
 /**
  * Module-local (never imported by generated code) — __zcSr/__zcSrOk call it.
  * Lean mode declares it in the runtime module beside them; inline mode pushes it
@@ -102,7 +103,7 @@ export declare const ZC_SR_OK_DECL: string;
  * the returned thenable is the only evidence, so the test lives here. Sync
  * callbacks return undefined, so the guard short-circuits on the first operand.
  */
-export declare const ZC_SR_RUN_DECL: string;
+declare const ZC_SR_RUN_DECL: string;
 /**
  * superRefine slow-path merge: run the callback, then move its issues onto the
  * validator's list the way zod's finalizeIssue does — the node's path prefixed
@@ -118,7 +119,9 @@ export declare const ZC_SR_RUN_DECL: string;
  * failing only through superRefine would be surfaced directly instead of inside
  * `invalid_union`.
  */
-export declare const ZC_SR_DECL: string;
+declare const ZC_SR_DECL: string;
 /** Non-issue runtime helper declarations hosted in the virtual module. */
-export declare const RUNTIME_HELPER_DECLS: Readonly<Record<string, string>>;
+declare const RUNTIME_HELPER_DECLS: Readonly<Record<string, string>>;
+//#endregion
+export { ISSUE_DECLS, RUNTIME_HELPER_DECLS, ZC_AB_DECL, ZC_FSR_DECL, ZC_FZ_DECL, ZC_HOP_DECL, ZC_PFX_DECL, ZC_SR_DECL, ZC_SR_OK_DECL, ZC_SR_RUN_DECL, abortingCodeTest, propertyKeyTest };
 //# sourceMappingURL=issue-decls.d.ts.map

package/dist/core/codegen/issue-decls.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"issue-decls.d.ts","sourceRoot":"","sources":["../../../src/core/codegen/issue-decls.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AA0BH,6DAA6D;AAC7D,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CASxD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,WAAW,gYACmV,CAAC;AAE5W;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,mDAAmD,CAAC;AAwB5E,qFAAqF;AACrF,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,UAAU,QAAsH,CAAC;AAE9I;;;;;;;;;;GAUG;AACH,eAAO,MAAM,UAAU,QAGU,CAAC;AAElC;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,4GACmF,CAAC;AAE5G,uFAAuF;AACvF,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,aAAa,QAEmB,CAAC;AAE9C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,cAAc,QAEiD,CAAC;AAE7E;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,UAAU,QAKkD,CAAC;AAE1E,0EAA0E;AAC1E,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAQjE,CAAC"}
+{"version":3,"file":"issue-decls.d.ts","names":[],"sources":["../../../src/core/codegen/issue-decls.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;cA4Ca,aAAa,SAAS;;;;;;cAgBtB;;;;;;;;;;cAYA;;iBAyBG,iBAAiB;;;;;;;;;;;;;;;cAkBpB;;;;;;;;;;;;cAaA;;;;;;;;;cAaA;;iBAIG,gBAAgB;;;;;;;;;;;;;;;;cAmBnB;;;;;;;;;;;;;cAgBA;;;;;;;;;;;;;;;;cAmBA;;cAQA,sBAAsB,SAAS"}

package/dist/core/codegen/issue-decls.js

@@ -1,182 +1,151 @@
-/**
- * Issue factory function bodies (statement form).
- *
- * These functions produce the same `{code, ...}` shapes that lean-mode
- * generated code would otherwise inline at every check site.
- * Hosted in "virtual:zod-compiler/runtime" and called as `__zcTS(...)` etc.
- *
- * Argument convention (positional, kept short to minimize call-site bytes):
- *   __zcTS(minimum, origin, inclusive, input, path, msg?)  — too_small
- *   __zcTB(maximum, origin, inclusive, input, path, msg?)  — too_big
- *   __zcIT(expected, input, path, msg?)                    — invalid_type
- *   __zcIF(format, input, path, extra?, msg?)              — invalid_format (extra merged into result)
- *   __zcIV(values, input, path, msg?)                      — invalid_value
- *   __zcUK(keys, input, path, msg?)                        — unrecognized_keys
- *
- * The trailing msg argument carries a static custom error message; when
- * absent, the __zcFin finalizer applies the configured locale default.
- */
-const ZC_TS_DECL = 'function __zcTS(m,o,i,inp,p,msg){var r={code:"too_small",minimum:m,origin:o,inclusive:i,input:inp,path:p};if(msg!==undefined)r.message=msg;return r;}';
-const ZC_TS_EXACT_DECL = 'function __zcTSx(m,o,inp,p,msg){var r={code:"too_small",minimum:m,origin:o,inclusive:true,exact:true,input:inp,path:p};if(msg!==undefined)r.message=msg;return r;}';
-const ZC_TB_DECL = 'function __zcTB(m,o,i,inp,p,msg){var r={code:"too_big",maximum:m,origin:o,inclusive:i,input:inp,path:p};if(msg!==undefined)r.message=msg;return r;}';
-const ZC_TB_EXACT_DECL = 'function __zcTBx(m,o,inp,p,msg){var r={code:"too_big",maximum:m,origin:o,inclusive:true,exact:true,input:inp,path:p};if(msg!==undefined)r.message=msg;return r;}';
-const ZC_IT_DECL = 'function __zcIT(e,inp,p,msg){var r={code:"invalid_type",expected:e,input:inp,path:p};if(msg!==undefined)r.message=msg;return r;}';
-const ZC_IF_DECL = 'function __zcIF(f,inp,p,extra,msg){var r={code:"invalid_format",format:f,input:inp,path:p};if(extra)Object.assign(r,extra);if(msg!==undefined)r.message=msg;return r;}';
-const ZC_IV_DECL = 'function __zcIV(values,inp,p,msg){var r={code:"invalid_value",values:values,input:inp,path:p};if(msg!==undefined)r.message=msg;return r;}';
-const ZC_UK_DECL = 'function __zcUK(k,inp,p,msg){var r={code:"unrecognized_keys",keys:k,input:inp,path:p};if(msg!==undefined)r.message=msg;return r;}';
 /** All issue factory declarations indexed by helper name. */
-export const ISSUE_DECLS = {
-    __zcTS: ZC_TS_DECL,
-    __zcTSx: ZC_TS_EXACT_DECL,
-    __zcTB: ZC_TB_DECL,
-    __zcTBx: ZC_TB_EXACT_DECL,
-    __zcIT: ZC_IT_DECL,
-    __zcIF: ZC_IF_DECL,
-    __zcIV: ZC_IV_DECL,
-    __zcUK: ZC_UK_DECL,
+const ISSUE_DECLS = {
+	__zcTS: "function __zcTS(m,o,i,inp,p,msg){var r={code:\"too_small\",minimum:m,origin:o,inclusive:i,input:inp,path:p};if(msg!==undefined)r.message=msg;return r;}",
+	__zcTSx: "function __zcTSx(m,o,inp,p,msg){var r={code:\"too_small\",minimum:m,origin:o,inclusive:true,exact:true,input:inp,path:p};if(msg!==undefined)r.message=msg;return r;}",
+	__zcTB: "function __zcTB(m,o,i,inp,p,msg){var r={code:\"too_big\",maximum:m,origin:o,inclusive:i,input:inp,path:p};if(msg!==undefined)r.message=msg;return r;}",
+	__zcTBx: "function __zcTBx(m,o,inp,p,msg){var r={code:\"too_big\",maximum:m,origin:o,inclusive:true,exact:true,input:inp,path:p};if(msg!==undefined)r.message=msg;return r;}",
+	__zcIT: "function __zcIT(e,inp,p,msg){var r={code:\"invalid_type\",expected:e,input:inp,path:p};if(msg!==undefined)r.message=msg;return r;}",
+	__zcIF: "function __zcIF(f,inp,p,extra,msg){var r={code:\"invalid_format\",format:f,input:inp,path:p};if(extra)Object.assign(r,extra);if(msg!==undefined)r.message=msg;return r;}",
+	__zcIV: "function __zcIV(values,inp,p,msg){var r={code:\"invalid_value\",values:values,input:inp,path:p};if(msg!==undefined)r.message=msg;return r;}",
+	__zcUK: "function __zcUK(k,inp,p,msg){var r={code:\"unrecognized_keys\",keys:k,input:inp,path:p};if(msg!==undefined)r.message=msg;return r;}"
 };
 /**
- * Float-safe remainder — byte-for-byte port of zod's util.floatSafeRemainder.
- * Raw `%` mis-rejects valid multiples of decimal steps (0.3 % 0.1 !== 0);
- * zod scales both operands to integers by their decimal-place count first.
- */
-export const ZC_FSR_DECL = 'function __zcFsr(v,s){var vd=((""+v).split(".")[1]||"").length;var ss=""+s;var sd=(ss.split(".")[1]||"").length;if(sd===0&&/\\d?e-\\d?/.test(ss)){var m=ss.match(/\\d?e-(\\d?)/);if(m&&m[1]){sd=parseInt(m[1],10);}}var d=vd>sd?vd:sd;var vi=parseInt(v.toFixed(d).replace(".",""),10);var si=parseInt(s.toFixed(d).replace(".",""),10);return (vi%si)/Math.pow(10,d);}';
+* Float-safe remainder — byte-for-byte port of zod's util.floatSafeRemainder.
+* Raw `%` mis-rejects valid multiples of decimal steps (0.3 % 0.1 !== 0);
+* zod scales both operands to integers by their decimal-place count first.
+*/
+const ZC_FSR_DECL = "function __zcFsr(v,s){var vd=((\"\"+v).split(\".\")[1]||\"\").length;var ss=\"\"+s;var sd=(ss.split(\".\")[1]||\"\").length;if(sd===0&&/\\d?e-\\d?/.test(ss)){var m=ss.match(/\\d?e-(\\d?)/);if(m&&m[1]){sd=parseInt(m[1],10);}}var d=vd>sd?vd:sd;var vi=parseInt(v.toFixed(d).replace(\".\",\"\"),10);var si=parseInt(s.toFixed(d).replace(\".\",\"\"),10);return (vi%si)/Math.pow(10,d);}";
 /**
- * Hoisted `Object.prototype.hasOwnProperty` reference. Record fast/slow paths
- * iterate keys with `for(k in o)` (no `Object.keys` array allocation) and guard
- * each key with `__zcHop.call(o,k)` to skip inherited enumerable properties —
- * yielding the exact own-enumerable string-key set `Object.keys` would, so
- * fast/slow stay in agreement and parity with zod's own-key record semantics is
- * preserved. The hoisted reference inlines in V8; reading the prototype property
- * per call would not.
- */
-export const ZC_HOP_DECL = "const __zcHop=Object.prototype.hasOwnProperty;";
+* Hoisted `Object.prototype.hasOwnProperty` reference. Record fast/slow paths
+* iterate keys with `for(k in o)` (no `Object.keys` array allocation) and guard
+* each key with `__zcHop.call(o,k)` to skip inherited enumerable properties —
+* yielding the exact own-enumerable string-key set `Object.keys` would, so
+* fast/slow stay in agreement and parity with zod's own-key record semantics is
+* preserved. The hoisted reference inlines in V8; reading the prototype property
+* per call would not.
+*/
+const ZC_HOP_DECL = "const __zcHop=Object.prototype.hasOwnProperty;";
 /**
- * Issue codes zod raises from a schema's `_zod.parse` rather than from a check,
- * and which therefore carry `continue !== true` — what `util.aborted` looks for.
- *
- * Everything a CHECK produces (`too_small`, `too_big`, `invalid_format`,
- * `not_multiple_of`, a refine's `custom`) is continuable, because `$ZodCheck`
- * sets `continue: !def.abort` and an `abort: true` check costs the schema its
- * compiled path anyway — so classifying by code alone is exact for generated
- * issues.
- *
- * Read by {@link ZC_AB_DECL} and by the union's option-pruning loop, which
- * applies the same rule inline over a per-option issue array.
- */
+* Issue codes zod raises from a schema's `_zod.parse` rather than from a check,
+* and which therefore carry `continue !== true` — what `util.aborted` looks for.
+*
+* Everything a CHECK produces (`too_small`, `too_big`, `invalid_format`,
+* `not_multiple_of`, a refine's `custom`) is continuable, because `$ZodCheck`
+* sets `continue: !def.abort` and an `abort: true` check costs the schema its
+* compiled path anyway — so classifying by code alone is exact for generated
+* issues.
+*
+* Read by {@link ZC_AB_DECL} and by the union's option-pruning loop, which
+* applies the same rule inline over a per-option issue array.
+*/
 const ABORTING_ISSUE_CODES = [
-    "invalid_type",
-    "invalid_value",
-    "invalid_union",
-    "unrecognized_keys",
-    "invalid_key",
-    "invalid_element",
+	"invalid_type",
+	"invalid_value",
+	"invalid_union",
+	"unrecognized_keys",
+	"invalid_key",
+	"invalid_element"
 ];
 /** `c==="invalid_type"||c==="invalid_value"||…` over the code held in `codeExpr`. */
-export function abortingCodeTest(codeExpr) {
-    return ABORTING_ISSUE_CODES.map((code) => `${codeExpr}===${JSON.stringify(code)}`).join("||");
+function abortingCodeTest(codeExpr) {
+	return ABORTING_ISSUE_CODES.map((code) => `${codeExpr}===${JSON.stringify(code)}`).join("||");
 }
 /**
- * Port of zod's `util.aborted(payload, startIndex)`: has anything since
- * `startIndex` produced a NON-continuable issue?
- *
- * zod gates a schema's check chain on this (`runChecks`: `else if (isAborted)
- * continue`), which is what makes a container's `.refine()` still run after a
- * property or element failed its own `min`/`max`/format check, and stop running
- * once one failed to parse at all. The `startIndex` is the issue count when the
- * node was entered, mirroring the fresh payload zod hands each sub-schema.
- *
- * Size/length checks are exempt in zod — they declare a `when` predicate, which
- * bypasses the abort gate — so generated code leaves those ungated and only
- * wraps the refine/superRefine effects.
- */
-export const ZC_AB_DECL = `function __zcAb(e,i){for(;i<e.length;i++){var c=e[i].code;if(${abortingCodeTest("c")})return true;}return false;}`;
+* Port of zod's `util.aborted(payload, startIndex)`: has anything since
+* `startIndex` produced a NON-continuable issue?
+*
+* zod gates a schema's check chain on this (`runChecks`: `else if (isAborted)
+* continue`), which is what makes a container's `.refine()` still run after a
+* property or element failed its own `min`/`max`/format check, and stop running
+* once one failed to parse at all. The `startIndex` is the issue count when the
+* node was entered, mirroring the fresh payload zod hands each sub-schema.
+*
+* Size/length checks are exempt in zod — they declare a `when` predicate, which
+* bypasses the abort gate — so generated code leaves those ungated and only
+* wraps the refine/superRefine effects.
+*/
+const ZC_AB_DECL = `function __zcAb(e,i){for(;i<e.length;i++){var c=e[i].code;if(${abortingCodeTest("c")})return true;}return false;}`;
 /**
- * Port of zod's `util.finalizeIssue` for issues NESTED inside an
- * `invalid_key` / `invalid_element` wrapper. Those never reach the top-level
- * finalization loop (which walks only the outer array), so zod finalizes them
- * where it builds the wrapper: locale message applied when none was baked in,
- * `input` cleared. Their `path` stays RELATIVE to the key or value schema — zod
- * ran it on a fresh payload — so nothing rewrites it.
- *
- * `input` is cleared by assignment rather than `delete`, matching the top-level
- * finalizer and the union's per-option loop.
- */
-export const ZC_FZ_DECL = "function __zcFz(e){for(var i=0;i<e.length;i++){var s=e[i];" +
-    'if(s.message===undefined&&typeof __zcMsg==="function")s.message=__zcMsg(s);' +
-    "s.input=undefined;}return e;}";
+* Port of zod's `util.finalizeIssue` for issues NESTED inside an
+* `invalid_key` / `invalid_element` wrapper. Those never reach the top-level
+* finalization loop (which walks only the outer array), so zod finalizes them
+* where it builds the wrapper: locale message applied when none was baked in,
+* `input` cleared. Their `path` stays RELATIVE to the key or value schema — zod
+* ran it on a fresh payload — so nothing rewrites it.
+*
+* `input` is cleared by assignment rather than `delete`, matching the top-level
+* finalizer and the union's per-option loop.
+*/
+const ZC_FZ_DECL = "function __zcFz(e){for(var i=0;i<e.length;i++){var s=e[i];if(s.message===undefined&&typeof __zcMsg===\"function\")s.message=__zcMsg(s);s.input=undefined;}return e;}";
 /**
- * Port of zod's `util.prefixIssues(key, issues)` for a map entry whose key is a
- * property-key type: each issue's RELATIVE path is spliced onto the map's own
- * path plus the key, and the issue moves into the parent's array.
- *
- * `b.concat(k,x.path)` flattens `x.path` one level, giving exactly
- * `[...base, key, ...relative]`.
- */
-export const ZC_PFX_DECL = "function __zcPfx(d,s,b,k){for(var i=0;i<s.length;i++){var x=s[i];x.path=b.concat(k,x.path);d.push(x);}}";
+* Port of zod's `util.prefixIssues(key, issues)` for a map entry whose key is a
+* property-key type: each issue's RELATIVE path is spliced onto the map's own
+* path plus the key, and the issue moves into the parent's array.
+*
+* `b.concat(k,x.path)` flattens `x.path` one level, giving exactly
+* `[...base, key, ...relative]`.
+*/
+const ZC_PFX_DECL = "function __zcPfx(d,s,b,k){for(var i=0;i<s.length;i++){var x=s[i];x.path=b.concat(k,x.path);d.push(x);}}";
 /** Does `keyExpr` hold one of zod's `util.propertyKeyTypes` (string|number|symbol)? */
-export function propertyKeyTest(keyExpr) {
-    return `typeof ${keyExpr}==="string"||typeof ${keyExpr}==="number"||typeof ${keyExpr}==="symbol"`;
+function propertyKeyTest(keyExpr) {
+	return `typeof ${keyExpr}==="string"||typeof ${keyExpr}==="number"||typeof ${keyExpr}==="symbol"`;
 }
 /**
- * superRefine fast-check: run the payload callback on a throwaway payload and
- * report whether it both added nothing AND left the value alone. zod's own
- * wrapper (the referenced function) installs `addIssue` and normalizes what the
- * user adds, so the verdict is zod's; the issues themselves are re-collected by
- * the slow walk.
- *
- * The `p.value===v` half is what lets a superRefine node keep a fast path at
- * all. `value` is writable public API ($RefinementCtx extends ParsePayload), so
- * a callback may rewrite it, and the fast path's caller returns the ORIGINAL
- * input on success — which would then be stale. Reporting false when the value
- * moved routes those parses into the slow walk, which propagates the new value
- * (see ZC_SR_DECL). Callbacks that only validate — effectively all of them —
- * still take the fast exit.
- */
-export const ZC_SR_OK_DECL = "function __zcSrOk(f,v){var p={value:v,issues:[]};__zcSrRun(f,p);" +
-    "return p.issues.length===0&&p.value===v;}";
+* superRefine fast-check: run the payload callback on a throwaway payload and
+* report whether it both added nothing AND left the value alone. zod's own
+* wrapper (the referenced function) installs `addIssue` and normalizes what the
+* user adds, so the verdict is zod's; the issues themselves are re-collected by
+* the slow walk.
+*
+* The `p.value===v` half is what lets a superRefine node keep a fast path at
+* all. `value` is writable public API ($RefinementCtx extends ParsePayload), so
+* a callback may rewrite it, and the fast path's caller returns the ORIGINAL
+* input on success — which would then be stale. Reporting false when the value
+* moved routes those parses into the slow walk, which propagates the new value
+* (see ZC_SR_DECL). Callbacks that only validate — effectively all of them —
+* still take the fast exit.
+*/
+const ZC_SR_OK_DECL = "function __zcSrOk(f,v){var p={value:v,issues:[]};__zcSrRun(f,p);return p.issues.length===0&&p.value===v;}";
 /**
- * Module-local (never imported by generated code) — __zcSr/__zcSrOk call it.
- * Lean mode declares it in the runtime module beside them; inline mode pushes it
- * into the preamble alongside whichever of the two is used.
- *
- * Invoke the referenced wrapper, reproducing zod's synchronous-parse contract:
- * a callback that returns a promise makes zod raise $ZodAsyncError rather than
- * silently accepting. Because the ref points at zod's superRefine WRAPPER, not
- * the user's function, an async callback cannot be detected while extracting —
- * the returned thenable is the only evidence, so the test lives here. Sync
- * callbacks return undefined, so the guard short-circuits on the first operand.
- */
-export const ZC_SR_RUN_DECL = "function __zcSrRun(f,p){var r=f(p);" +
-    'if(r&&typeof r.then==="function"){throw new __zcCore.$ZodAsyncError();}}';
+* Module-local (never imported by generated code) — __zcSr/__zcSrOk call it.
+* Lean mode declares it in the runtime module beside them; inline mode pushes it
+* into the preamble alongside whichever of the two is used.
+*
+* Invoke the referenced wrapper, reproducing zod's synchronous-parse contract:
+* a callback that returns a promise makes zod raise $ZodAsyncError rather than
+* silently accepting. Because the ref points at zod's superRefine WRAPPER, not
+* the user's function, an async callback cannot be detected while extracting —
+* the returned thenable is the only evidence, so the test lives here. Sync
+* callbacks return undefined, so the guard short-circuits on the first operand.
+*/
+const ZC_SR_RUN_DECL = "function __zcSrRun(f,p){var r=f(p);if(r&&typeof r.then===\"function\"){throw new __zcCore.$ZodAsyncError();}}";
 /**
- * superRefine slow-path merge: run the callback, then move its issues onto the
- * validator's list the way zod's finalizeIssue does — the node's path prefixed
- * onto any path the user supplied, and the internal `inst`/`continue` fields
- * dropped (they are zod bookkeeping, deleted before the issue is user-visible).
- *
- * Returns the payload, so the caller can write `.value` back (the callback may
- * have rewritten it) and read `.aborted`. Aborted is set when any issue aborts
- * in zod's sense (`continue !== true`, which covers `fatal: true` and the string
- * shorthand, whose issue carries no `continue` at all) — or when the callback
- * set it directly, also public payload API. A union option uses it to mark
- * itself aborted, matching how zod prunes option errors; without it an option
- * failing only through superRefine would be surfaced directly instead of inside
- * `invalid_union`.
- */
-export const ZC_SR_DECL = "function __zcSr(f,v,p,e){var q={value:v,issues:[]};__zcSrRun(f,q);" +
-    "for(var i=0;i<q.issues.length;i++){var s=q.issues[i],t={};" +
-    'for(var k in s){if(k!=="inst"&&k!=="continue")t[k]=s[k];}' +
-    "if(s.continue!==true)q.aborted=true;" +
-    "t.path=s.path&&s.path.length?p.concat(s.path):p;e.push(t);}return q;}";
+* superRefine slow-path merge: run the callback, then move its issues onto the
+* validator's list the way zod's finalizeIssue does — the node's path prefixed
+* onto any path the user supplied, and the internal `inst`/`continue` fields
+* dropped (they are zod bookkeeping, deleted before the issue is user-visible).
+*
+* Returns the payload, so the caller can write `.value` back (the callback may
+* have rewritten it) and read `.aborted`. Aborted is set when any issue aborts
+* in zod's sense (`continue !== true`, which covers `fatal: true` and the string
+* shorthand, whose issue carries no `continue` at all) — or when the callback
+* set it directly, also public payload API. A union option uses it to mark
+* itself aborted, matching how zod prunes option errors; without it an option
+* failing only through superRefine would be surfaced directly instead of inside
+* `invalid_union`.
+*/
+const ZC_SR_DECL = "function __zcSr(f,v,p,e){var q={value:v,issues:[]};__zcSrRun(f,q);for(var i=0;i<q.issues.length;i++){var s=q.issues[i],t={};for(var k in s){if(k!==\"inst\"&&k!==\"continue\")t[k]=s[k];}if(s.continue!==true)q.aborted=true;t.path=s.path&&s.path.length?p.concat(s.path):p;e.push(t);}return q;}";
 /** Non-issue runtime helper declarations hosted in the virtual module. */
-export const RUNTIME_HELPER_DECLS = {
-    __zcAb: ZC_AB_DECL,
-    __zcFsr: ZC_FSR_DECL,
-    __zcFz: ZC_FZ_DECL,
-    __zcHop: ZC_HOP_DECL,
-    __zcPfx: ZC_PFX_DECL,
-    __zcSr: ZC_SR_DECL,
-    __zcSrOk: ZC_SR_OK_DECL,
+const RUNTIME_HELPER_DECLS = {
+	__zcAb: ZC_AB_DECL,
+	__zcFsr: ZC_FSR_DECL,
+	__zcFz: ZC_FZ_DECL,
+	__zcHop: ZC_HOP_DECL,
+	__zcPfx: ZC_PFX_DECL,
+	__zcSr: ZC_SR_DECL,
+	__zcSrOk: ZC_SR_OK_DECL
 };
+//#endregion
+export { ISSUE_DECLS, RUNTIME_HELPER_DECLS, ZC_AB_DECL, ZC_FSR_DECL, ZC_FZ_DECL, ZC_HOP_DECL, ZC_PFX_DECL, ZC_SR_DECL, ZC_SR_OK_DECL, ZC_SR_RUN_DECL, abortingCodeTest, propertyKeyTest };
+
 //# sourceMappingURL=issue-decls.js.map

package/dist/core/codegen/issue-decls.js.map

@@ -1 +1 @@
-{"version":3,"file":"issue-decls.js","sourceRoot":"","sources":["../../../src/core/codegen/issue-decls.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,MAAM,UAAU,GACd,uJAAuJ,CAAC;AAE1J,MAAM,gBAAgB,GACpB,oKAAoK,CAAC;AAEvK,MAAM,UAAU,GACd,qJAAqJ,CAAC;AAExJ,MAAM,gBAAgB,GACpB,kKAAkK,CAAC;AAErK,MAAM,UAAU,GACd,kIAAkI,CAAC;AAErI,MAAM,UAAU,GACd,wKAAwK,CAAC;AAE3K,MAAM,UAAU,GACd,2IAA2I,CAAC;AAE9I,MAAM,UAAU,GACd,mIAAmI,CAAC;AAEtI,6DAA6D;AAC7D,MAAM,CAAC,MAAM,WAAW,GAAqC;IAC3D,MAAM,EAAE,UAAU;IAClB,OAAO,EAAE,gBAAgB;IACzB,MAAM,EAAE,UAAU;IAClB,OAAO,EAAE,gBAAgB;IACzB,MAAM,EAAE,UAAU;IAClB,MAAM,EAAE,UAAU;IAClB,MAAM,EAAE,UAAU;IAClB,MAAM,EAAE,UAAU;CACnB,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,MAAM,WAAW,GACtB,yWAAyW,CAAC;AAE5W;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,gDAAgD,CAAC;AAE5E;;;;;;;;;;;;GAYG;AACH,MAAM,oBAAoB,GAAsB;IAC9C,cAAc;IACd,eAAe;IACf,eAAe;IACf,mBAAmB;IACnB,aAAa;IACb,iBAAiB;CAClB,CAAC;AAEF,qFAAqF;AACrF,MAAM,UAAU,gBAAgB,CAAC,QAAgB;IAC/C,OAAO,oBAAoB,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,GAAG,QAAQ,MAAM,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAChG,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,gEAAgE,gBAAgB,CAAC,GAAG,CAAC,8BAA8B,CAAC;AAE9I;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,UAAU,GACrB,4DAA4D;IAC5D,6EAA6E;IAC7E,+BAA+B,CAAC;AAElC;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,WAAW,GACtB,yGAAyG,CAAC;AAE5G,uFAAuF;AACvF,MAAM,UAAU,eAAe,CAAC,OAAe;IAC7C,OAAO,UAAU,OAAO,uBAAuB,OAAO,uBAAuB,OAAO,aAAa,CAAC;AACpG,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,aAAa,GACxB,kEAAkE;IAClE,2CAA2C,CAAC;AAE9C;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,cAAc,GACzB,qCAAqC;IACrC,0EAA0E,CAAC;AAE7E;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,UAAU,GACrB,oEAAoE;IACpE,4DAA4D;IAC5D,2DAA2D;IAC3D,sCAAsC;IACtC,uEAAuE,CAAC;AAE1E,0EAA0E;AAC1E,MAAM,CAAC,MAAM,oBAAoB,GAAqC;IACpE,MAAM,EAAE,UAAU;IAClB,OAAO,EAAE,WAAW;IACpB,MAAM,EAAE,UAAU;IAClB,OAAO,EAAE,WAAW;IACpB,OAAO,EAAE,WAAW;IACpB,MAAM,EAAE,UAAU;IAClB,QAAQ,EAAE,aAAa;CACxB,CAAC"}
+{"version":3,"file":"issue-decls.js","names":[],"sources":["../../../src/core/codegen/issue-decls.ts"],"sourcesContent":["/**\n * Issue factory function bodies (statement form).\n *\n * These functions produce the same `{code, ...}` shapes that lean-mode\n * generated code would otherwise inline at every check site.\n * Hosted in \"virtual:zod-compiler/runtime\" and called as `__zcTS(...)` etc.\n *\n * Argument convention (positional, kept short to minimize call-site bytes):\n *   __zcTS(minimum, origin, inclusive, input, path, msg?)  — too_small\n *   __zcTB(maximum, origin, inclusive, input, path, msg?)  — too_big\n *   __zcIT(expected, input, path, msg?)                    — invalid_type\n *   __zcIF(format, input, path, extra?, msg?)              — invalid_format (extra merged into result)\n *   __zcIV(values, input, path, msg?)                      — invalid_value\n *   __zcUK(keys, input, path, msg?)                        — unrecognized_keys\n *\n * The trailing msg argument carries a static custom error message; when\n * absent, the __zcFin finalizer applies the configured locale default.\n */\n\nconst ZC_TS_DECL =\n  'function __zcTS(m,o,i,inp,p,msg){var r={code:\"too_small\",minimum:m,origin:o,inclusive:i,input:inp,path:p};if(msg!==undefined)r.message=msg;return r;}';\n\nconst ZC_TS_EXACT_DECL =\n  'function __zcTSx(m,o,inp,p,msg){var r={code:\"too_small\",minimum:m,origin:o,inclusive:true,exact:true,input:inp,path:p};if(msg!==undefined)r.message=msg;return r;}';\n\nconst ZC_TB_DECL =\n  'function __zcTB(m,o,i,inp,p,msg){var r={code:\"too_big\",maximum:m,origin:o,inclusive:i,input:inp,path:p};if(msg!==undefined)r.message=msg;return r;}';\n\nconst ZC_TB_EXACT_DECL =\n  'function __zcTBx(m,o,inp,p,msg){var r={code:\"too_big\",maximum:m,origin:o,inclusive:true,exact:true,input:inp,path:p};if(msg!==undefined)r.message=msg;return r;}';\n\nconst ZC_IT_DECL =\n  'function __zcIT(e,inp,p,msg){var r={code:\"invalid_type\",expected:e,input:inp,path:p};if(msg!==undefined)r.message=msg;return r;}';\n\nconst ZC_IF_DECL =\n  'function __zcIF(f,inp,p,extra,msg){var r={code:\"invalid_format\",format:f,input:inp,path:p};if(extra)Object.assign(r,extra);if(msg!==undefined)r.message=msg;return r;}';\n\nconst ZC_IV_DECL =\n  'function __zcIV(values,inp,p,msg){var r={code:\"invalid_value\",values:values,input:inp,path:p};if(msg!==undefined)r.message=msg;return r;}';\n\nconst ZC_UK_DECL =\n  'function __zcUK(k,inp,p,msg){var r={code:\"unrecognized_keys\",keys:k,input:inp,path:p};if(msg!==undefined)r.message=msg;return r;}';\n\n/** All issue factory declarations indexed by helper name. */\nexport const ISSUE_DECLS: Readonly<Record<string, string>> = {\n  __zcTS: ZC_TS_DECL,\n  __zcTSx: ZC_TS_EXACT_DECL,\n  __zcTB: ZC_TB_DECL,\n  __zcTBx: ZC_TB_EXACT_DECL,\n  __zcIT: ZC_IT_DECL,\n  __zcIF: ZC_IF_DECL,\n  __zcIV: ZC_IV_DECL,\n  __zcUK: ZC_UK_DECL,\n};\n\n/**\n * Float-safe remainder — byte-for-byte port of zod's util.floatSafeRemainder.\n * Raw `%` mis-rejects valid multiples of decimal steps (0.3 % 0.1 !== 0);\n * zod scales both operands to integers by their decimal-place count first.\n */\nexport const ZC_FSR_DECL =\n  'function __zcFsr(v,s){var vd=((\"\"+v).split(\".\")[1]||\"\").length;var ss=\"\"+s;var sd=(ss.split(\".\")[1]||\"\").length;if(sd===0&&/\\\\d?e-\\\\d?/.test(ss)){var m=ss.match(/\\\\d?e-(\\\\d?)/);if(m&&m[1]){sd=parseInt(m[1],10);}}var d=vd>sd?vd:sd;var vi=parseInt(v.toFixed(d).replace(\".\",\"\"),10);var si=parseInt(s.toFixed(d).replace(\".\",\"\"),10);return (vi%si)/Math.pow(10,d);}';\n\n/**\n * Hoisted `Object.prototype.hasOwnProperty` reference. Record fast/slow paths\n * iterate keys with `for(k in o)` (no `Object.keys` array allocation) and guard\n * each key with `__zcHop.call(o,k)` to skip inherited enumerable properties —\n * yielding the exact own-enumerable string-key set `Object.keys` would, so\n * fast/slow stay in agreement and parity with zod's own-key record semantics is\n * preserved. The hoisted reference inlines in V8; reading the prototype property\n * per call would not.\n */\nexport const ZC_HOP_DECL = \"const __zcHop=Object.prototype.hasOwnProperty;\";\n\n/**\n * Issue codes zod raises from a schema's `_zod.parse` rather than from a check,\n * and which therefore carry `continue !== true` — what `util.aborted` looks for.\n *\n * Everything a CHECK produces (`too_small`, `too_big`, `invalid_format`,\n * `not_multiple_of`, a refine's `custom`) is continuable, because `$ZodCheck`\n * sets `continue: !def.abort` and an `abort: true` check costs the schema its\n * compiled path anyway — so classifying by code alone is exact for generated\n * issues.\n *\n * Read by {@link ZC_AB_DECL} and by the union's option-pruning loop, which\n * applies the same rule inline over a per-option issue array.\n */\nconst ABORTING_ISSUE_CODES: readonly string[] = [\n  \"invalid_type\",\n  \"invalid_value\",\n  \"invalid_union\",\n  \"unrecognized_keys\",\n  \"invalid_key\",\n  \"invalid_element\",\n];\n\n/** `c===\"invalid_type\"||c===\"invalid_value\"||…` over the code held in `codeExpr`. */\nexport function abortingCodeTest(codeExpr: string): string {\n  return ABORTING_ISSUE_CODES.map((code) => `${codeExpr}===${JSON.stringify(code)}`).join(\"||\");\n}\n\n/**\n * Port of zod's `util.aborted(payload, startIndex)`: has anything since\n * `startIndex` produced a NON-continuable issue?\n *\n * zod gates a schema's check chain on this (`runChecks`: `else if (isAborted)\n * continue`), which is what makes a container's `.refine()` still run after a\n * property or element failed its own `min`/`max`/format check, and stop running\n * once one failed to parse at all. The `startIndex` is the issue count when the\n * node was entered, mirroring the fresh payload zod hands each sub-schema.\n *\n * Size/length checks are exempt in zod — they declare a `when` predicate, which\n * bypasses the abort gate — so generated code leaves those ungated and only\n * wraps the refine/superRefine effects.\n */\nexport const ZC_AB_DECL = `function __zcAb(e,i){for(;i<e.length;i++){var c=e[i].code;if(${abortingCodeTest(\"c\")})return true;}return false;}`;\n\n/**\n * Port of zod's `util.finalizeIssue` for issues NESTED inside an\n * `invalid_key` / `invalid_element` wrapper. Those never reach the top-level\n * finalization loop (which walks only the outer array), so zod finalizes them\n * where it builds the wrapper: locale message applied when none was baked in,\n * `input` cleared. Their `path` stays RELATIVE to the key or value schema — zod\n * ran it on a fresh payload — so nothing rewrites it.\n *\n * `input` is cleared by assignment rather than `delete`, matching the top-level\n * finalizer and the union's per-option loop.\n */\nexport const ZC_FZ_DECL =\n  \"function __zcFz(e){for(var i=0;i<e.length;i++){var s=e[i];\" +\n  'if(s.message===undefined&&typeof __zcMsg===\"function\")s.message=__zcMsg(s);' +\n  \"s.input=undefined;}return e;}\";\n\n/**\n * Port of zod's `util.prefixIssues(key, issues)` for a map entry whose key is a\n * property-key type: each issue's RELATIVE path is spliced onto the map's own\n * path plus the key, and the issue moves into the parent's array.\n *\n * `b.concat(k,x.path)` flattens `x.path` one level, giving exactly\n * `[...base, key, ...relative]`.\n */\nexport const ZC_PFX_DECL =\n  \"function __zcPfx(d,s,b,k){for(var i=0;i<s.length;i++){var x=s[i];x.path=b.concat(k,x.path);d.push(x);}}\";\n\n/** Does `keyExpr` hold one of zod's `util.propertyKeyTypes` (string|number|symbol)? */\nexport function propertyKeyTest(keyExpr: string): string {\n  return `typeof ${keyExpr}===\"string\"||typeof ${keyExpr}===\"number\"||typeof ${keyExpr}===\"symbol\"`;\n}\n\n/**\n * superRefine fast-check: run the payload callback on a throwaway payload and\n * report whether it both added nothing AND left the value alone. zod's own\n * wrapper (the referenced function) installs `addIssue` and normalizes what the\n * user adds, so the verdict is zod's; the issues themselves are re-collected by\n * the slow walk.\n *\n * The `p.value===v` half is what lets a superRefine node keep a fast path at\n * all. `value` is writable public API ($RefinementCtx extends ParsePayload), so\n * a callback may rewrite it, and the fast path's caller returns the ORIGINAL\n * input on success — which would then be stale. Reporting false when the value\n * moved routes those parses into the slow walk, which propagates the new value\n * (see ZC_SR_DECL). Callbacks that only validate — effectively all of them —\n * still take the fast exit.\n */\nexport const ZC_SR_OK_DECL =\n  \"function __zcSrOk(f,v){var p={value:v,issues:[]};__zcSrRun(f,p);\" +\n  \"return p.issues.length===0&&p.value===v;}\";\n\n/**\n * Module-local (never imported by generated code) — __zcSr/__zcSrOk call it.\n * Lean mode declares it in the runtime module beside them; inline mode pushes it\n * into the preamble alongside whichever of the two is used.\n *\n * Invoke the referenced wrapper, reproducing zod's synchronous-parse contract:\n * a callback that returns a promise makes zod raise $ZodAsyncError rather than\n * silently accepting. Because the ref points at zod's superRefine WRAPPER, not\n * the user's function, an async callback cannot be detected while extracting —\n * the returned thenable is the only evidence, so the test lives here. Sync\n * callbacks return undefined, so the guard short-circuits on the first operand.\n */\nexport const ZC_SR_RUN_DECL =\n  \"function __zcSrRun(f,p){var r=f(p);\" +\n  'if(r&&typeof r.then===\"function\"){throw new __zcCore.$ZodAsyncError();}}';\n\n/**\n * superRefine slow-path merge: run the callback, then move its issues onto the\n * validator's list the way zod's finalizeIssue does — the node's path prefixed\n * onto any path the user supplied, and the internal `inst`/`continue` fields\n * dropped (they are zod bookkeeping, deleted before the issue is user-visible).\n *\n * Returns the payload, so the caller can write `.value` back (the callback may\n * have rewritten it) and read `.aborted`. Aborted is set when any issue aborts\n * in zod's sense (`continue !== true`, which covers `fatal: true` and the string\n * shorthand, whose issue carries no `continue` at all) — or when the callback\n * set it directly, also public payload API. A union option uses it to mark\n * itself aborted, matching how zod prunes option errors; without it an option\n * failing only through superRefine would be surfaced directly instead of inside\n * `invalid_union`.\n */\nexport const ZC_SR_DECL =\n  \"function __zcSr(f,v,p,e){var q={value:v,issues:[]};__zcSrRun(f,q);\" +\n  \"for(var i=0;i<q.issues.length;i++){var s=q.issues[i],t={};\" +\n  'for(var k in s){if(k!==\"inst\"&&k!==\"continue\")t[k]=s[k];}' +\n  \"if(s.continue!==true)q.aborted=true;\" +\n  \"t.path=s.path&&s.path.length?p.concat(s.path):p;e.push(t);}return q;}\";\n\n/** Non-issue runtime helper declarations hosted in the virtual module. */\nexport const RUNTIME_HELPER_DECLS: Readonly<Record<string, string>> = {\n  __zcAb: ZC_AB_DECL,\n  __zcFsr: ZC_FSR_DECL,\n  __zcFz: ZC_FZ_DECL,\n  __zcHop: ZC_HOP_DECL,\n  __zcPfx: ZC_PFX_DECL,\n  __zcSr: ZC_SR_DECL,\n  __zcSrOk: ZC_SR_OK_DECL,\n};\n"],"mappings":";AA4CA,MAAa,cAAgD;CAC3D,QAAQ;CACR,SAAS;CACT,QAAQ;CACR,SAAS;CACT,QAAQ;CACR,QAAQ;CACR,QAAQ;CACR,QAAQ;AACV;;;;;;AAOA,MAAa,cACX;;;;;;;;;;AAWF,MAAa,cAAc;;;;;;;;;;;;;;AAe3B,MAAM,uBAA0C;CAC9C;CACA;CACA;CACA;CACA;CACA;AACF;;AAGA,SAAgB,iBAAiB,UAA0B;CACzD,OAAO,qBAAqB,KAAK,SAAS,GAAG,SAAS,KAAK,KAAK,UAAU,IAAI,GAAG,CAAC,CAAC,KAAK,IAAI;AAC9F;;;;;;;;;;;;;;;AAgBA,MAAa,aAAa,gEAAgE,iBAAiB,GAAG,EAAE;;;;;;;;;;;;AAahH,MAAa,aACX;;;;;;;;;AAYF,MAAa,cACX;;AAGF,SAAgB,gBAAgB,SAAyB;CACvD,OAAO,UAAU,QAAQ,sBAAsB,QAAQ,sBAAsB,QAAQ;AACvF;;;;;;;;;;;;;;;;AAiBA,MAAa,gBACX;;;;;;;;;;;;;AAeF,MAAa,iBACX;;;;;;;;;;;;;;;;AAkBF,MAAa,aACX;;AAOF,MAAa,uBAAyD;CACpE,QAAQ;CACR,SAAS;CACT,QAAQ;CACR,SAAS;CACT,SAAS;CACT,QAAQ;CACR,UAAU;AACZ"}

package/dist/core/codegen/regex-unroll.d.ts

@@ -1,3 +1,4 @@
+//#region src/core/codegen/regex-unroll.d.ts
 /**
  * Bounded-repeat unrolling for `.test()` regexes.
  *
@@ -32,5 +33,7 @@
  * Returns `null` when nothing changed or the pattern could not be scanned
  * exactly (in which case the caller keeps the original source).
  */
-export declare function unrollRepeats(source: string): string | null;
+declare function unrollRepeats(source: string): string | null;
+//#endregion
+export { unrollRepeats };
 //# sourceMappingURL=regex-unroll.d.ts.map

package/dist/core/codegen/regex-unroll.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"regex-unroll.d.ts","sourceRoot":"","sources":["../../../src/core/codegen/regex-unroll.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AA4BH;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CA4D3D"}
+{"version":3,"file":"regex-unroll.d.ts","names":[],"sources":["../../../src/core/codegen/regex-unroll.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6DgB,cAAc"}