zod-compiler 2.0.6 → 2.0.7

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

@@ -1 +1 @@
-{"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 *   __zcTSt(minimum, origin, input, path, msg?)            — too_small, tuple key order\n *   __zcTBt(maximum, origin, input, path, msg?)            — too_big, tuple key order\n *   __zcTB(maximum, origin, inclusive, input, path, msg?)  — too_big\n *   __zcIT(expected, input, path, msg?)                    — invalid_type\n *   __zcITc(expected, input, path, msg?)                   — invalid_type, `code` first\n *   __zcIF(origin, format, input, path, extra?, msg?)      — invalid_format (extra merged into result)\n *   __zcIV(values, input, path, extra?, msg?)              — invalid_value (extra merged into result)\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 * KEY ORDER IS PART OF THE CONTRACT. `ZodError.message` is\n * `JSON.stringify(issues, …, 2)`, so the order these factories insert keys in is\n * printed verbatim in the message every consumer logs, snapshots or serializes.\n * Each literal below therefore reproduces the order of the corresponding\n * `payload.issues.push({…})` in zod, which is irregular by type — `too_small`\n * from a check leads with `origin` while the same code from a tuple's length\n * branch leads with `code` — and every factory writes `message` LAST, because\n * zod's `finalizeIssue` assigns it after the fact (`full.message = …`) even for\n * a custom message baked into the check's error map.\n */\n\nconst ZC_TS_DECL =\n  'function __zcTS(m,o,i,inp,p,msg){var r={origin:o,code:\"too_small\",minimum:m,inclusive:i,input:inp,path:p};if(msg!==undefined)r.message=msg;return r;}';\n\n/**\n * too_small in the TUPLE under-length key order. $ZodTuple pushes\n * `{ code, minimum, inclusive: true, input, inst, origin }`, so its `origin`\n * trails `inclusive` where every check-created size issue leads with it. Its\n * over-length sibling is __zcTBt.\n */\nconst ZC_TS_TUPLE_DECL =\n  'function __zcTSt(m,o,inp,p,msg){var r={code:\"too_small\",minimum:m,inclusive:true,origin:o,input:inp,path:p,continue:false};if(msg!==undefined)r.message=msg;return r;}';\n\nconst ZC_TS_EXACT_DECL =\n  'function __zcTSx(m,o,inp,p,msg){var r={origin:o,code:\"too_small\",minimum:m,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={origin:o,code:\"too_big\",maximum:m,inclusive:i,input:inp,path:p};if(msg!==undefined)r.message=msg;return r;}';\n\n/**\n * too_big in the TUPLE over-length key order. $ZodTuple spreads\n * `{ code, maximum, inclusive }` and appends `origin` after `input`/`inst`, so\n * its `origin` trails `inclusive` where every check-created size issue leads\n * with it. Its under-length sibling is __zcTSt.\n */\nconst ZC_TB_TUPLE_DECL =\n  'function __zcTBt(m,o,inp,p,msg){var r={code:\"too_big\",maximum:m,inclusive:true,origin:o,input:inp,path:p,continue:false};if(msg!==undefined)r.message=msg;return r;}';\n\nconst ZC_TB_EXACT_DECL =\n  'function __zcTBx(m,o,inp,p,msg){var r={origin:o,code:\"too_big\",maximum:m,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={expected:e,code:\"invalid_type\",input:inp,path:p};if(msg!==undefined)r.message=msg;return r;}';\n\n/**\n * invalid_type with `code` ahead of `expected`. Every schema in zod spells this\n * issue `{ expected, code }` — except `$ZodDiscriminatedUnion`, whose\n * non-object guard writes `{ code, expected }`. One literal, one key order, and\n * it shows up in `ZodError.message`.\n */\nconst ZC_IT_CODE_FIRST_DECL =\n  'function __zcITc(e,inp,p,msg){var r={code:\"invalid_type\",expected:e,input:inp,path:p};if(msg!==undefined)r.message=msg;return r;}';\n\n/**\n * `o` is the leading `origin`, present only for the formats whose issue carries\n * one: `$ZodCheckStringFormat`'s default pattern check and the regex /\n * includes / starts_with / ends_with checks all lead with `origin: \"string\"`,\n * while `z.url()`'s own pushes and every `$ZodCustomStringFormat` omit it\n * entirely. `extra` holds the per-format tail (`pattern`, `includes`, `prefix`,\n * `suffix`, `note`) and is merged BEFORE input/path so it lands where zod\n * writes it.\n */\nconst ZC_IF_DECL =\n  'function __zcIF(o,f,inp,p,extra,msg){var r=o===undefined?{code:\"invalid_format\",format:f}:{origin:o,code:\"invalid_format\",format:f};if(extra)Object.assign(r,extra);r.input=inp;r.path=p;if(msg!==undefined)r.message=msg;return r;}';\n\n/**\n * `extra` carries the per-producer fields: enum and literal push `values` only,\n * while z.stringbool()'s codec transform also pushes `expected: \"stringbool\"`.\n * Merged the same way __zcIF merges its own.\n */\nconst ZC_IV_DECL =\n  'function __zcIV(values,inp,p,extra,msg){var r={code:\"invalid_value\"};if(extra)Object.assign(r,extra);r.values=values;r.input=inp;r.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  __zcTSt: ZC_TS_TUPLE_DECL,\n  __zcTSx: ZC_TS_EXACT_DECL,\n  __zcTB: ZC_TB_DECL,\n  __zcTBt: ZC_TB_TUPLE_DECL,\n  __zcTBx: ZC_TB_EXACT_DECL,\n  __zcIT: ZC_IT_DECL,\n  __zcITc: ZC_IT_CODE_FIRST_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 *\n * zod 4.5 REPLACED the decimal-scaling implementation this once mirrored with a\n * ratio-and-tolerance one, and the two disagree in both directions: the old form\n * accepted `1e-7` as a multiple of 3 (its `toFixed` scaling collapsed the value\n * to 0) and rejected `1e21` (where `toFixed` yields exponential notation and\n * `parseInt` then reads 1). The tolerance is 4x epsilon because `val` and `step`\n * each round to a double before the division rounds again, so a true decimal\n * multiple's quotient can sit up to 1.5 scaled epsilons from the integer.\n */\nexport const ZC_FSR_DECL =\n  \"function __zcFsr(v,s){var r=v/s;var q=Math.round(r);\" +\n  \"var t=4*Number.EPSILON*Math.max(Math.abs(r),1);\" +\n  \"return Math.abs(r-q)<t?0:r-q;}\";\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 * Port of zod's `util.isPlainObject` — the guard `$ZodRecord` applies to its\n * input, and a STRICTLY narrower test than the `util.isObject` (`typeof\n * \"object\"`, not null, not an array) that `$ZodObject` uses.\n *\n * The distinction is load-bearing and was a validation hole while records shared\n * the object guard: `z.record(z.string(), z.string())` accepted a `Date`, a\n * `Map`, a `RegExp`, an `Error`, a `File` and any class instance — every one of\n * which zod rejects with `invalid_type`/`expected: \"record\"`, and none of which\n * has own enumerable string keys for the value schema to catch. Compiled output\n * therefore said \"valid\" to inputs zod refuses, which is the one direction a\n * validator must never diverge in.\n *\n * The algorithm is zod's, step for step, because the answer is observable and\n * the edge cases are deliberate:\n *   - `constructor === undefined` (a null-prototype object) is PLAIN;\n *   - a non-function own `constructor` (`{ constructor: 1 }`) is PLAIN;\n *   - otherwise the constructor's `prototype` must be an object carrying its OWN\n *     `isPrototypeOf` — which `Object.prototype` does and `Date.prototype`,\n *     `Map.prototype` and every user class prototype do not. Testing that rather\n *     than `Object.getPrototypeOf(o) === Object.prototype` is what lets a plain\n *     object from another realm (a vm context, an iframe) still count as plain.\n *\n * `c===Object` is a short-cut, not a fourth rule: it is exactly the case where\n * zod's remaining steps are foregone — `Object.prototype` is an object and has\n * its own `isPrototypeOf` — so the answer is `true` either way. It is also the\n * case every ordinary record takes (an object literal, `JSON.parse` output, a\n * `Map`-free DTO), and taking it saves the `prototype` load and the\n * `hasOwnProperty` call: measured 9.6 → 5.7 ns on a monomorphic record and\n * 15.7 → 9.2 ns across 16 shapes, i.e. 22% of a five-key record's whole parse.\n * A plain object from another realm has a different `Object` and simply takes\n * the long road to the same verdict, as before.\n *\n * Self-contained (`Object.prototype.hasOwnProperty` spelled out rather than\n * reusing `__zcHop`) so inline mode can emit this decl alone: `emitRuntimeHelper`\n * pushes only the decl it is asked for, and a helper that closed over another\n * name would dangle wherever that one was not also emitted.\n */\nexport const ZC_PLAIN_DECL =\n  'function __zcPlain(o){if(typeof o!==\"object\"||o===null||Array.isArray(o))return false;' +\n  'var c=o.constructor;if(c===Object||c===undefined||typeof c!==\"function\")return true;' +\n  'var p=c.prototype;if(typeof p!==\"object\"||p===null||Array.isArray(p))return false;' +\n  'return Object.prototype.hasOwnProperty.call(p,\"isPrototypeOf\");}';\n\n/**\n * `z.email()`'s default validator, `regexes.email`, as a single linear scan.\n *\n * Zod's pattern is\n * `^(?!\\.)(?!.*\\.\\.)([A-Za-z0-9_'+\\-\\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\\-]*\\.)+[A-Za-z]{2,}$`,\n * and even its lookahead-free rewrite (EMAIL_FAST_REGEX_SOURCE) backtracks at\n * every dot it fails to find: `(?:[X]+\\.)*` re-tries the run one character\n * shorter each time, and the domain's `(?:label\\.)+` does the same over the\n * TLD. Written as a scanner the language is:\n *\n *   local  — `[A-Za-z0-9_'+.-]+`, no leading `.`, no `..`, and the character\n *            before `@` is neither `.` nor `'` (that last is the `[A-Za-z0-9_+-]`\n *            the pattern demands there);\n *   domain — one or more labels `[A-Za-z0-9][A-Za-z0-9-]*` each ending in `.`,\n *            then a TLD of two or more letters running to the end.\n *\n * A trailing `\\n` is not accepted: the pattern has no `m` flag, so its `$`\n * matches only at the end of input, and the scan reads to `length`.\n *\n * Measured against the fast regex on V8: 32 → 16 ns for `alice@example.com`,\n * 48 → 40 for `bob_smith-99@mail-server.io`, 39 → 20 for a non-address, and a\n * tie from ~35 characters up (the regex's per-character work is cheaper than a\n * `charCodeAt` loop's; its fixed dispatch cost is what the scanner avoids). A\n * lookbehind rewrite runs about as fast but needs ES2018 regex support, which\n * the CLI's React Native / Hermes and older-Safari consumers cannot assume.\n *\n * Equivalence to zod's regex — every string, both verdicts — is pinned by\n * tests/core/codegen/email-scanner.test.ts. Reached only behind a `typeof`\n * string guard, like the `.test()` it replaces; issue sites keep reporting\n * zod's own pattern string (see `emitRegexSourceString`).\n */\nexport const ZC_EMAIL_DECL =\n  \"function __zcEmail(s){var n=s.length,i=0,c,p=46;\" +\n  // Local part. `p` starts as `.` so a leading dot trips the `..` rule.\n  \"for(;;){if(i===n)return false;c=s.charCodeAt(i);if(c===64)break;\" +\n  \"if(c===46){if(p===46)return false;}\" +\n  \"else if(!((c>=97&&c<=122)||(c>=65&&c<=90)||(c>=48&&c<=57)||c===95||c===39||c===43||c===45))return false;\" +\n  \"p=c;i++;}\" +\n  \"if(p===46||p===39)return false;\" +\n  // Domain. `l` is the current label's start, `t` whether it is letters-only.\n  \"var l=++i,d=0,t=true;\" +\n  \"for(;i<n;i++){c=s.charCodeAt(i);\" +\n  \"if((c>=97&&c<=122)||(c>=65&&c<=90))continue;\" +\n  \"if(c===46){if(i===l)return false;d++;l=i+1;t=true;continue;}\" +\n  \"if((c>=48&&c<=57)||c===45){if(c===45&&i===l)return false;t=false;continue;}\" +\n  \"return false;}\" +\n  \"return d>0&&t&&n-l>=2;}\";\n\n/**\n * Ports of `util.getLengthableOrigin` / `util.getSizableOrigin` — the `origin` a\n * length/size check puts on its issue, computed from the RUNTIME INPUT rather\n * than from the schema.\n *\n * They only matter because those checks declare a `when` predicate\n * (`!nullish(value) && value.length/size !== undefined`), which bypasses zod's\n * abort gate: `z.string().min(2)` handed `[]` reports the `invalid_type` AND a\n * `too_small` whose origin is `\"array\"`, because the empty array satisfies the\n * `when`. Inside the matching type branch the origin is statically known and\n * these are not used; they exist for the type-MISMATCH branch, where the input\n * can be anything with a `.length` or a `.size`.\n *\n * `File` is probed through `typeof` first: zod tests `input instanceof File`\n * unguarded, which throws where the global is absent — an environment zod does\n * not run in, and not one worth reproducing a crash for.\n */\nexport const ZC_LENGTH_ORIGIN_DECL =\n  'function __zcLo(v){return Array.isArray(v)?\"array\":typeof v===\"string\"?\"string\":\"unknown\";}';\n\n/**\n * Drop an own `__proto__` from a container the parse hands back BY REFERENCE.\n *\n * zod never lets the key into an output: `$ZodObject`'s shape loop strips a\n * declared one, `handleCatchall` skips an undeclared one, and `$ZodRecord` skips\n * it while copying — all so the assignment into their fresh `{}` cannot replace\n * the result's prototype. A compiled loose/catchall object or record IS its\n * input, so the key has to be removed here instead; leaving it made\n * `Object.assign({}, parsed)` a prototype-pollution sink, since [[Set]] runs the\n * inherited setter the spread that built the value did not.\n *\n * Copies rather than editing in place: the divergence note promises the caller\n * its own container back, not one with a key silently deleted from it. The\n * common object has no such key and is returned untouched, so the cost is one\n * `hasOwnProperty` call.\n */\nexport const ZC_PROTO_SCRUB_DECL =\n  'function __zcPs(o){if(!Object.prototype.hasOwnProperty.call(o,\"__proto__\"))return o;' +\n  'var c={...o};delete c[\"__proto__\"];return c;}';\n\n/**\n * Code points in a string — zod's `util.codePointLength`, verbatim. A surrogate\n * pair counts once and a lone surrogate as itself. The regex probe is the fast\n * exit for a string with no astral characters, and the hand-rolled loop avoids\n * the allocating string iterator. Only reached from a length check whose\n * UTF-16 count leaves the verdict in doubt (see stringLengthTests).\n */\nexport const ZC_CPL_DECL =\n  \"function __zcCpl(s){var n=s.length;if(!/[\\\\uD800-\\\\uDBFF]/.test(s))return n;var c=n;for(var i=0;i<n-1;i++){if((s.charCodeAt(i)&0xfc00)===0xd800&&(s.charCodeAt(i+1)&0xfc00)===0xdc00){c--;i++;}}return c;}\";\n\nexport const ZC_SIZE_ORIGIN_DECL =\n  'function __zcSo(v){return v instanceof Set?\"set\":v instanceof Map?\"map\":' +\n  '(typeof File!==\"undefined\"&&v instanceof File)?\"file\":\"unknown\";}';\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 * `unrecognized_keys` is the one parse-level issue zod pushes WITH\n * `continue: true`: it describes the shape of the input rather than the\n * validity of the parsed value, so the parse still fails but the object's own\n * refines run first and a union does not count the option as aborted.\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  \"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 s=e[i];if(s.continue===false)return true;var c=s.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 `delete`d rather than assigned `undefined`, matching zod's own\n * `delete full.input` and the top-level finalizer: the key's PRESENCE is\n * observable (`\"input\" in issue`, `Object.keys`, spread, a strict deep-equal\n * against a zod issue), so assigning left a nested issue one key wider than\n * zod's. Only reached while an error is being built — never on a successful\n * parse — so the dictionary-mode transition it costs is confined to the path\n * that then constructs a ZodError anyway.\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  \"delete s.input;delete s.continue;}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/**\n * `[...p, k]`: a path with one segment appended, as a fresh array.\n *\n * `extendPath` splices a segment into a path that is still an array literal,\n * but a shared walk receives its path as a parameter, opaque at build time, so\n * there the segment is appended at run time. A nested shared walk's call site\n * evaluates that append up front — on a valid parse too, once per property and\n * per array element, whenever the schema runs its walk eagerly because it has\n * no build path (a `z.url()`, a `.catch()`, a `superRefine()`).\n *\n * `Array.prototype.concat`, which this replaces, is a C++ builtin in V8: ~70 ns\n * a call against ~7 ns for the copy below. On the eager walk of a 14-property\n * product schema calling six shared sub-walks, a valid parse went from 713 to\n * 299 ns and an `.error` read from 2.05 to 1.44 µs. The preallocated copy also\n * beat `slice()` + `push` (391 ns), a `push` loop (338 ns) and spread (361 ns).\n */\nexport const ZC_PATH_APPEND_DECL =\n  \"function __zcPa(p,k){var n=p.length,r=new Array(n+1);for(var i=0;i<n;i++)r[i]=p[i];r[n]=k;return r;}\";\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 * z.custom()/z.instanceof() fast verdict. Zod treats truthy predicate returns\n * as success and raises $ZodAsyncError when a synchronous parse encounters a\n * thenable, including a non-async function that happens to return a Promise.\n */\nexport const ZC_CUSTOM_OK_DECL =\n  \"function __zcCu(f,v){var r=f(v);\" +\n  'if(r&&typeof r.then===\"function\"){throw new __zcCore.$ZodAsyncError();}return !!r;}';\n\n/**\n * Raise zod's synchronous-parse error. A user callback that hands back a\n * Promise — a `.refine()` predicate, a `.transform()`, a `z.preprocess()` —\n * makes zod's sync `safeParse` throw `$ZodAsyncError` rather than treat the\n * Promise as a value (a truthy one, for a predicate, which would ACCEPT the\n * input). The callback's source cannot tell: only an `async` function is\n * detectable at extraction time (those are delegated), and a plain function\n * that returns a Promise looks like any other. So the test is on the returned\n * value, at every call site that consumes one, with zod's own\n * `instanceof Promise` — a non-Promise thenable is a plain value to zod too.\n *\n * Hosted rather than inlined so the throw stays out of the hot path's inlining\n * budget: call sites test `x instanceof Promise` themselves and branch here\n * only in the exotic case. The compiled `parseAsync`/`safeParseAsync` wrappers\n * catch this and re-run through zod's async pipeline (see MK_VALIDATOR_DECL),\n * so an async-capable caller still gets zod's answer.\n *\n * `.catch()`, `.default()` and `.overwrite()` callbacks are deliberately NOT\n * guarded: zod substitutes whatever they return, Promise included.\n */\nexport const ZC_ASYNC_DECL = \"function __zcAsy(){throw new __zcCore.$ZodAsyncError();}\";\n\n/**\n * Run a retained zod schema for a delegated sub-schema and return its RAW\n * payload — `_zod.run` on a fresh `{value, issues: []}`, the exact call zod's\n * own `safeParse` makes — rather than the finalized `SafeParseResult`.\n *\n * The raw payload is the only place zod's abort state survives.\n * `finalizeIssue` deletes `continue` from every issue and `safeParse` builds\n * its ZodError from the finalized copies, so a delegate that went through\n * `safeParse` could not tell a `z.custom()` failure (`continue: false` — zod\n * defaults `z.custom()` to `abort: true`) from a `.refine()` one\n * (`continue: true`). A plain union prunes its options on that flag\n * (`util.aborted`): with it lost, an option failing through a delegated\n * aborting check was surfaced as the sole non-aborted option instead of inside\n * `invalid_union`. Reading the payload keeps the flag until __zcRf copies it\n * onto the finalized issue, where the union's pruning loop reads it and the\n * top-level finalizer then deletes it, as zod's does.\n *\n * `_zod.run` is also immune to the aliasing hazard `__rfp_N` guards against:\n * `__zcMkv` installs the compiled methods as own `parse`/`safeParse` slots and\n * never touches `_zod`, so a retained entry that IS the compiled schema still\n * runs zod's implementation here. A Promise result is zod's `$ZodAsyncError`,\n * as in `_safeParse`.\n */\nexport const ZC_RUN_DELEGATE_DECL =\n  \"function __zcRd(z,v,c){var r=z.run({value:v,issues:[]},c);\" +\n  \"if(r instanceof Promise)throw new __zcCore.$ZodAsyncError();return r;}\";\n\n/**\n * Finalize a delegate's raw issues onto the validator's list. Each goes\n * through zod's own `util.finalizeIssue` — the check's and schema's error\n * maps, the per-call ctx, `customError`, the locale, then \"Invalid input\", with\n * `inst` and `input` stripped — which is the very function `safeParse` maps\n * every issue through, so the messages are zod's byte for byte. The node's\n * path is prefixed onto the issue's relative one as zod's `prefixIssues`\n * would, and the abort marker is re-applied: an issue whose raw `continue` was\n * not `true` aborted in zod's sense (`util.aborted`), which the union pruning\n * loop reads as `continue:false` before the top-level finalizer deletes the\n * key again (see ZC_RUN_DELEGATE_DECL).\n */\nexport const ZC_DELEGATE_ISSUES_DECL =\n  \"function __zcRf(s,c,e,p){var g=__zcCore.config();for(var i=0;i<s.length;i++){\" +\n  \"var q=s[i],f=__zcCore.util.finalizeIssue(q,c,g);f.path=p.concat(f.path);\" +\n  \"if(q.continue!==true)f.continue=false;e.push(f);}}\";\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, the internal `inst`/`continue` fields\n * dropped (they are zod bookkeeping, deleted before the issue is user-visible),\n * and the owning schema's static message `m` applied to an issue that carries\n * none of its own, since zod stamps the owner onto every issue a check raises.\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 at whose root the\n * superRefine sits reads the flag to mark itself aborted, matching how zod\n * prunes option errors. The aborting issue ALSO keeps a `continue:false`\n * marker of its own, because zod's `util.aborted` reads the flag off the\n * issues and those travel up through containers where the payload flag does\n * not: a fatal superRefine on an object's property aborts the union option\n * holding the object. The top-level finalizer deletes the marker, as zod's\n * `finalizeIssue` does, so no user-visible issue carries it.\n */\nexport const ZC_SR_DECL =\n  \"function __zcSr(f,v,p,e,m){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;t.continue=false;}\" +\n  \"t.path=s.path&&s.path.length?p.concat(s.path):p;\" +\n  \"if(t.message===undefined&&m!==undefined)t.message=m;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  __zcLo: ZC_LENGTH_ORIGIN_DECL,\n  __zcSo: ZC_SIZE_ORIGIN_DECL,\n  __zcCpl: ZC_CPL_DECL,\n  __zcEmail: ZC_EMAIL_DECL,\n  __zcPs: ZC_PROTO_SCRUB_DECL,\n  __zcPlain: ZC_PLAIN_DECL,\n  __zcPfx: ZC_PFX_DECL,\n  __zcPa: ZC_PATH_APPEND_DECL,\n  __zcCu: ZC_CUSTOM_OK_DECL,\n  __zcSr: ZC_SR_DECL,\n  __zcSrOk: ZC_SR_OK_DECL,\n  __zcAsy: ZC_ASYNC_DECL,\n  __zcRd: ZC_RUN_DELEGATE_DECL,\n  __zcRf: ZC_DELEGATE_ISSUES_DECL,\n};\n"],"mappings":";AAkGA,MAAa,cAAgD;CAC3D,QAAQ;CACR,SAAS;CACT,SAAS;CACT,QAAQ;CACR,SAAS;CACT,SAAS;CACT,QAAQ;CACR,SAAS;CACT,QAAQ;CACR,QAAQ;CACR,QAAQ;AACV;;;;;;;;;;;;;AAcA,MAAa,cACX;;;;;;;;;;AAaF,MAAa,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwC3B,MAAa,gBACX;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCF,MAAa,gBACX;;;;;;;;;;;;;;;;;;AAiCF,MAAa,wBACX;;;;;;;;;;;;;;;;;AAkBF,MAAa,sBACX;;;;;;;;AAUF,MAAa,cACX;AAEF,MAAa,sBACX;;;;;;;;;;;;;;;;;;;AAqBF,MAAM,uBAA0C;CAC9C;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,0GAA0G,iBAAiB,GAAG,EAAE;;;;;;;;;;;;;;;;;AAkB1J,MAAa,aACX;;;;;;;;;AAYF,MAAa,cACX;;;;;;;;;;;;;;;;;AAkBF,MAAa,sBACX;;AAGF,SAAgB,gBAAgB,SAAyB;CACvD,OAAO,UAAU,QAAQ,sBAAsB,QAAQ,sBAAsB,QAAQ;AACvF;;;;;;;;;;;;;;;;AAiBA,MAAa,gBACX;;;;;;;;;;;;;AAeF,MAAa,iBACX;;;;;;AAQF,MAAa,oBACX;;;;;;;;;;;;;;;;;;;;;AAuBF,MAAa,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;AAyB7B,MAAa,uBACX;;;;;;;;;;;;;AAeF,MAAa,0BACX;;;;;;;;;;;;;;;;;;;;;;AAyBF,MAAa,aACX;;AAQF,MAAa,uBAAyD;CACpE,QAAQ;CACR,SAAS;CACT,QAAQ;CACR,SAAS;CACT,QAAQ;CACR,QAAQ;CACR,SAAS;CACT,WAAW;CACX,QAAQ;CACR,WAAW;CACX,SAAS;CACT,QAAQ;CACR,QAAQ;CACR,QAAQ;CACR,UAAU;CACV,SAAS;CACT,QAAQ;CACR,QAAQ;AACV"}
+{"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 *   __zcTSt(minimum, origin, input, path, msg?)            — too_small, tuple key order\n *   __zcTBt(maximum, origin, input, path, msg?)            — too_big, tuple key order\n *   __zcTB(maximum, origin, inclusive, input, path, msg?)  — too_big\n *   __zcIT(expected, input, path, msg?)                    — invalid_type\n *   __zcITc(expected, input, path, msg?)                   — invalid_type, `code` first\n *   __zcIF(origin, format, input, path, extra?, msg?)      — invalid_format (extra merged into result)\n *   __zcIV(values, input, path, extra?, msg?)              — invalid_value (extra merged into result)\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 * KEY ORDER IS PART OF THE CONTRACT. `ZodError.message` is\n * `JSON.stringify(issues, …, 2)`, so the order these factories insert keys in is\n * printed verbatim in the message every consumer logs, snapshots or serializes.\n * Each literal below therefore reproduces the order of the corresponding\n * `payload.issues.push({…})` in zod, which is irregular by type — `too_small`\n * from a check leads with `origin` while the same code from a tuple's length\n * branch leads with `code` — and every factory writes `message` LAST, because\n * zod's `finalizeIssue` assigns it after the fact (`full.message = …`) even for\n * a custom message baked into the check's error map.\n */\n\nconst ZC_TS_DECL =\n  'function __zcTS(m,o,i,inp,p,msg){var r={origin:o,code:\"too_small\",minimum:m,inclusive:i,input:inp,path:p};if(msg!==undefined)r.message=msg;return r;}';\n\n/**\n * too_small in the TUPLE under-length key order. $ZodTuple pushes\n * `{ code, minimum, inclusive: true, input, inst, origin }`, so its `origin`\n * trails `inclusive` where every check-created size issue leads with it. Its\n * over-length sibling is __zcTBt.\n */\nconst ZC_TS_TUPLE_DECL =\n  'function __zcTSt(m,o,inp,p,msg){var r={code:\"too_small\",minimum:m,inclusive:true,origin:o,input:inp,path:p,continue:false};if(msg!==undefined)r.message=msg;return r;}';\n\nconst ZC_TS_EXACT_DECL =\n  'function __zcTSx(m,o,inp,p,msg){var r={origin:o,code:\"too_small\",minimum:m,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={origin:o,code:\"too_big\",maximum:m,inclusive:i,input:inp,path:p};if(msg!==undefined)r.message=msg;return r;}';\n\n/**\n * too_big in the TUPLE over-length key order. $ZodTuple spreads\n * `{ code, maximum, inclusive }` and appends `origin` after `input`/`inst`, so\n * its `origin` trails `inclusive` where every check-created size issue leads\n * with it. Its under-length sibling is __zcTSt.\n */\nconst ZC_TB_TUPLE_DECL =\n  'function __zcTBt(m,o,inp,p,msg){var r={code:\"too_big\",maximum:m,inclusive:true,origin:o,input:inp,path:p,continue:false};if(msg!==undefined)r.message=msg;return r;}';\n\nconst ZC_TB_EXACT_DECL =\n  'function __zcTBx(m,o,inp,p,msg){var r={origin:o,code:\"too_big\",maximum:m,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={expected:e,code:\"invalid_type\",input:inp,path:p};if(msg!==undefined)r.message=msg;return r;}';\n\n/**\n * invalid_type with `code` ahead of `expected`. Every schema in zod spells this\n * issue `{ expected, code }` — except `$ZodDiscriminatedUnion`, whose\n * non-object guard writes `{ code, expected }`. One literal, one key order, and\n * it shows up in `ZodError.message`.\n */\nconst ZC_IT_CODE_FIRST_DECL =\n  'function __zcITc(e,inp,p,msg){var r={code:\"invalid_type\",expected:e,input:inp,path:p};if(msg!==undefined)r.message=msg;return r;}';\n\n/**\n * `o` is the leading `origin`, present only for the formats whose issue carries\n * one: `$ZodCheckStringFormat`'s default pattern check and the regex /\n * includes / starts_with / ends_with checks all lead with `origin: \"string\"`,\n * while `z.url()`'s own pushes and every `$ZodCustomStringFormat` omit it\n * entirely. `extra` holds the per-format tail (`pattern`, `includes`, `prefix`,\n * `suffix`, `note`) and is merged BEFORE input/path so it lands where zod\n * writes it.\n */\nconst ZC_IF_DECL =\n  'function __zcIF(o,f,inp,p,extra,msg){var r=o===undefined?{code:\"invalid_format\",format:f}:{origin:o,code:\"invalid_format\",format:f};if(extra)Object.assign(r,extra);r.input=inp;r.path=p;if(msg!==undefined)r.message=msg;return r;}';\n\n/**\n * `extra` carries the per-producer fields: enum and literal push `values` only,\n * while z.stringbool()'s codec transform also pushes `expected: \"stringbool\"`.\n * Merged the same way __zcIF merges its own.\n */\nconst ZC_IV_DECL =\n  'function __zcIV(values,inp,p,extra,msg){var r={code:\"invalid_value\"};if(extra)Object.assign(r,extra);r.values=values;r.input=inp;r.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  __zcTSt: ZC_TS_TUPLE_DECL,\n  __zcTSx: ZC_TS_EXACT_DECL,\n  __zcTB: ZC_TB_DECL,\n  __zcTBt: ZC_TB_TUPLE_DECL,\n  __zcTBx: ZC_TB_EXACT_DECL,\n  __zcIT: ZC_IT_DECL,\n  __zcITc: ZC_IT_CODE_FIRST_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 *\n * zod 4.5 REPLACED the decimal-scaling implementation this once mirrored with a\n * ratio-and-tolerance one, and the two disagree in both directions: the old form\n * accepted `1e-7` as a multiple of 3 (its `toFixed` scaling collapsed the value\n * to 0) and rejected `1e21` (where `toFixed` yields exponential notation and\n * `parseInt` then reads 1). The tolerance is 4x epsilon because `val` and `step`\n * each round to a double before the division rounds again, so a true decimal\n * multiple's quotient can sit up to 1.5 scaled epsilons from the integer.\n */\nexport const ZC_FSR_DECL =\n  \"function __zcFsr(v,s){var r=v/s;var q=Math.round(r);\" +\n  \"var t=4*Number.EPSILON*Math.max(Math.abs(r),1);\" +\n  \"return Math.abs(r-q)<t?0:r-q;}\";\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 * Port of zod's `util.isPlainObject` — the guard `$ZodRecord` applies to its\n * input, and a STRICTLY narrower test than the `util.isObject` (`typeof\n * \"object\"`, not null, not an array) that `$ZodObject` uses.\n *\n * The distinction is load-bearing and was a validation hole while records shared\n * the object guard: `z.record(z.string(), z.string())` accepted a `Date`, a\n * `Map`, a `RegExp`, an `Error`, a `File` and any class instance — every one of\n * which zod rejects with `invalid_type`/`expected: \"record\"`, and none of which\n * has own enumerable string keys for the value schema to catch. Compiled output\n * therefore said \"valid\" to inputs zod refuses, which is the one direction a\n * validator must never diverge in.\n *\n * The algorithm is zod's, step for step, because the answer is observable and\n * the edge cases are deliberate:\n *   - `constructor === undefined` (a null-prototype object) is PLAIN;\n *   - a non-function own `constructor` (`{ constructor: 1 }`) is PLAIN;\n *   - otherwise the constructor's `prototype` must be an object carrying its OWN\n *     `isPrototypeOf` — which `Object.prototype` does and `Date.prototype`,\n *     `Map.prototype` and every user class prototype do not. Testing that rather\n *     than `Object.getPrototypeOf(o) === Object.prototype` is what lets a plain\n *     object from another realm (a vm context, an iframe) still count as plain.\n *\n * `c===Object` is a short-cut, not a fourth rule: it is exactly the case where\n * zod's remaining steps are foregone — `Object.prototype` is an object and has\n * its own `isPrototypeOf` — so the answer is `true` either way. It is also the\n * case every ordinary record takes (an object literal, `JSON.parse` output, a\n * `Map`-free DTO), and taking it saves the `prototype` load and the\n * `hasOwnProperty` call: measured 9.6 → 5.7 ns on a monomorphic record and\n * 15.7 → 9.2 ns across 16 shapes, i.e. 22% of a five-key record's whole parse.\n * A plain object from another realm has a different `Object` and simply takes\n * the long road to the same verdict, as before.\n *\n * Self-contained (`Object.prototype.hasOwnProperty` spelled out rather than\n * reusing `__zcHop`) so inline mode can emit this decl alone: `emitRuntimeHelper`\n * pushes only the decl it is asked for, and a helper that closed over another\n * name would dangle wherever that one was not also emitted.\n */\nexport const ZC_PLAIN_DECL =\n  'function __zcPlain(o){if(typeof o!==\"object\"||o===null||Array.isArray(o))return false;' +\n  'var c=o.constructor;if(c===Object||c===undefined||typeof c!==\"function\")return true;' +\n  'var p=c.prototype;if(typeof p!==\"object\"||p===null||Array.isArray(p))return false;' +\n  'return Object.prototype.hasOwnProperty.call(p,\"isPrototypeOf\");}';\n\n/**\n * `z.email()`'s default validator, `regexes.email`, as a single linear scan.\n *\n * Zod's pattern is\n * `^(?!\\.)(?!.*\\.\\.)([A-Za-z0-9_'+\\-\\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\\-]*\\.)+[A-Za-z]{2,}$`,\n * and even its lookahead-free rewrite (EMAIL_FAST_REGEX_SOURCE) backtracks at\n * every dot it fails to find: `(?:[X]+\\.)*` re-tries the run one character\n * shorter each time, and the domain's `(?:label\\.)+` does the same over the\n * TLD. Written as a scanner the language is:\n *\n *   local  — `[A-Za-z0-9_'+.-]+`, no leading `.`, no `..`, and the character\n *            before `@` is neither `.` nor `'` (that last is the `[A-Za-z0-9_+-]`\n *            the pattern demands there);\n *   domain — one or more labels `[A-Za-z0-9][A-Za-z0-9-]*` each ending in `.`,\n *            then a TLD of two or more letters running to the end.\n *\n * A trailing `\\n` is not accepted: the pattern has no `m` flag, so its `$`\n * matches only at the end of input, and the scan reads to `length`.\n *\n * Measured against the fast regex on V8: 32 → 16 ns for `alice@example.com`,\n * 48 → 40 for `bob_smith-99@mail-server.io`, 39 → 20 for a non-address, and a\n * tie from ~35 characters up (the regex's per-character work is cheaper than a\n * `charCodeAt` loop's; its fixed dispatch cost is what the scanner avoids). A\n * lookbehind rewrite runs about as fast but needs ES2018 regex support, which\n * the CLI's React Native / Hermes and older-Safari consumers cannot assume.\n *\n * Equivalence to zod's regex — every string, both verdicts — is pinned by\n * tests/core/codegen/email-scanner.test.ts. Reached only behind a `typeof`\n * string guard, like the `.test()` it replaces; issue sites keep reporting\n * zod's own pattern string (see `emitRegexSourceString`).\n */\nexport const ZC_EMAIL_DECL =\n  \"function __zcEmail(s){var n=s.length,i=0,c,p=46;\" +\n  // Local part. `p` starts as `.` so a leading dot trips the `..` rule.\n  \"for(;;){if(i===n)return false;c=s.charCodeAt(i);if(c===64)break;\" +\n  \"if(c===46){if(p===46)return false;}\" +\n  \"else if(!((c>=97&&c<=122)||(c>=65&&c<=90)||(c>=48&&c<=57)||c===95||c===39||c===43||c===45))return false;\" +\n  \"p=c;i++;}\" +\n  \"if(p===46||p===39)return false;\" +\n  // Domain. `l` is the current label's start, `t` whether it is letters-only.\n  \"var l=++i,d=0,t=true;\" +\n  \"for(;i<n;i++){c=s.charCodeAt(i);\" +\n  \"if((c>=97&&c<=122)||(c>=65&&c<=90))continue;\" +\n  \"if(c===46){if(i===l)return false;d++;l=i+1;t=true;continue;}\" +\n  \"if((c>=48&&c<=57)||c===45){if(c===45&&i===l)return false;t=false;continue;}\" +\n  \"return false;}\" +\n  \"return d>0&&t&&n-l>=2;}\";\n\n/**\n * Does `s` parse as a URL? The verdict `new URL(s)` gives by not throwing,\n * without building the URL object: `URL.canParse` runs the same parser at half\n * the cost (~80 ns against ~160 ns on V8, trim included). Used only where\n * nothing reads the parsed URL — no hostname or protocol test, no `normalize`.\n * A host without `canParse` (Node before 18.17, older browsers, React Native's\n * polyfill) falls back to the constructor, and one without `URL` at all answers\n * false, as the try/catch zod wraps around that constructor does.\n */\nexport const ZC_URL_DECL =\n  'function __zcUrl(s){if(typeof URL===\"function\"&&typeof URL.canParse===\"function\")return URL.canParse(s);' +\n  \"try{new URL(s);return true;}catch(_){return false;}}\";\n\n/**\n * Ports of `util.getLengthableOrigin` / `util.getSizableOrigin` — the `origin` a\n * length/size check puts on its issue, computed from the RUNTIME INPUT rather\n * than from the schema.\n *\n * They only matter because those checks declare a `when` predicate\n * (`!nullish(value) && value.length/size !== undefined`), which bypasses zod's\n * abort gate: `z.string().min(2)` handed `[]` reports the `invalid_type` AND a\n * `too_small` whose origin is `\"array\"`, because the empty array satisfies the\n * `when`. Inside the matching type branch the origin is statically known and\n * these are not used; they exist for the type-MISMATCH branch, where the input\n * can be anything with a `.length` or a `.size`.\n *\n * `File` is probed through `typeof` first: zod tests `input instanceof File`\n * unguarded, which throws where the global is absent — an environment zod does\n * not run in, and not one worth reproducing a crash for.\n */\nexport const ZC_LENGTH_ORIGIN_DECL =\n  'function __zcLo(v){return Array.isArray(v)?\"array\":typeof v===\"string\"?\"string\":\"unknown\";}';\n\n/**\n * Drop an own `__proto__` from a container the parse hands back BY REFERENCE.\n *\n * zod never lets the key into an output: `$ZodObject`'s shape loop strips a\n * declared one, `handleCatchall` skips an undeclared one, and `$ZodRecord` skips\n * it while copying — all so the assignment into their fresh `{}` cannot replace\n * the result's prototype. A compiled loose/catchall object or record IS its\n * input, so the key has to be removed here instead; leaving it made\n * `Object.assign({}, parsed)` a prototype-pollution sink, since [[Set]] runs the\n * inherited setter the spread that built the value did not.\n *\n * Copies rather than editing in place: the divergence note promises the caller\n * its own container back, not one with a key silently deleted from it. The\n * common object has no such key and is returned untouched, so the cost is one\n * `hasOwnProperty` call.\n */\nexport const ZC_PROTO_SCRUB_DECL =\n  'function __zcPs(o){if(!Object.prototype.hasOwnProperty.call(o,\"__proto__\"))return o;' +\n  'var c={...o};delete c[\"__proto__\"];return c;}';\n\n/**\n * Code points in a string — zod's `util.codePointLength`, verbatim. A surrogate\n * pair counts once and a lone surrogate as itself. The regex probe is the fast\n * exit for a string with no astral characters, and the hand-rolled loop avoids\n * the allocating string iterator. Only reached from a length check whose\n * UTF-16 count leaves the verdict in doubt (see stringLengthTests).\n */\nexport const ZC_CPL_DECL =\n  \"function __zcCpl(s){var n=s.length;if(!/[\\\\uD800-\\\\uDBFF]/.test(s))return n;var c=n;for(var i=0;i<n-1;i++){if((s.charCodeAt(i)&0xfc00)===0xd800&&(s.charCodeAt(i+1)&0xfc00)===0xdc00){c--;i++;}}return c;}\";\n\nexport const ZC_SIZE_ORIGIN_DECL =\n  'function __zcSo(v){return v instanceof Set?\"set\":v instanceof Map?\"map\":' +\n  '(typeof File!==\"undefined\"&&v instanceof File)?\"file\":\"unknown\";}';\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 * `unrecognized_keys` is the one parse-level issue zod pushes WITH\n * `continue: true`: it describes the shape of the input rather than the\n * validity of the parsed value, so the parse still fails but the object's own\n * refines run first and a union does not count the option as aborted.\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  \"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 s=e[i];if(s.continue===false)return true;var c=s.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 `delete`d rather than assigned `undefined`, matching zod's own\n * `delete full.input` and the top-level finalizer: the key's PRESENCE is\n * observable (`\"input\" in issue`, `Object.keys`, spread, a strict deep-equal\n * against a zod issue), so assigning left a nested issue one key wider than\n * zod's. Only reached while an error is being built — never on a successful\n * parse — so the dictionary-mode transition it costs is confined to the path\n * that then constructs a ZodError anyway.\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  \"delete s.input;delete s.continue;}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/**\n * `[...p, k]`: a path with one segment appended, as a fresh array.\n *\n * `extendPath` splices a segment into a path that is still an array literal,\n * but a shared walk receives its path as a parameter, opaque at build time, so\n * there the segment is appended at run time. A nested shared walk's call site\n * evaluates that append up front — on a valid parse too, once per property and\n * per array element, whenever the schema runs its walk eagerly because it has\n * no build path (a `z.url()`, a `.catch()`, a `superRefine()`).\n *\n * `Array.prototype.concat`, which this replaces, is a C++ builtin in V8: ~70 ns\n * a call against ~7 ns for the copy below. On the eager walk of a 14-property\n * product schema calling six shared sub-walks, a valid parse went from 713 to\n * 299 ns and an `.error` read from 2.05 to 1.44 µs. The preallocated copy also\n * beat `slice()` + `push` (391 ns), a `push` loop (338 ns) and spread (361 ns).\n */\nexport const ZC_PATH_APPEND_DECL =\n  \"function __zcPa(p,k){var n=p.length,r=new Array(n+1);for(var i=0;i<n;i++)r[i]=p[i];r[n]=k;return r;}\";\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 * z.custom()/z.instanceof() fast verdict. Zod treats truthy predicate returns\n * as success and raises $ZodAsyncError when a synchronous parse encounters a\n * thenable, including a non-async function that happens to return a Promise.\n */\nexport const ZC_CUSTOM_OK_DECL =\n  \"function __zcCu(f,v){var r=f(v);\" +\n  'if(r&&typeof r.then===\"function\"){throw new __zcCore.$ZodAsyncError();}return !!r;}';\n\n/**\n * Raise zod's synchronous-parse error. A user callback that hands back a\n * Promise — a `.refine()` predicate, a `.transform()`, a `z.preprocess()` —\n * makes zod's sync `safeParse` throw `$ZodAsyncError` rather than treat the\n * Promise as a value (a truthy one, for a predicate, which would ACCEPT the\n * input). The callback's source cannot tell: only an `async` function is\n * detectable at extraction time (those are delegated), and a plain function\n * that returns a Promise looks like any other. So the test is on the returned\n * value, at every call site that consumes one, with zod's own\n * `instanceof Promise` — a non-Promise thenable is a plain value to zod too.\n *\n * Hosted rather than inlined so the throw stays out of the hot path's inlining\n * budget: call sites test `x instanceof Promise` themselves and branch here\n * only in the exotic case. The compiled `parseAsync`/`safeParseAsync` wrappers\n * catch this and re-run through zod's async pipeline (see MK_VALIDATOR_DECL),\n * so an async-capable caller still gets zod's answer.\n *\n * `.catch()`, `.default()` and `.overwrite()` callbacks are deliberately NOT\n * guarded: zod substitutes whatever they return, Promise included.\n */\nexport const ZC_ASYNC_DECL = \"function __zcAsy(){throw new __zcCore.$ZodAsyncError();}\";\n\n/**\n * Run a retained zod schema for a delegated sub-schema and return its RAW\n * payload — `_zod.run` on a fresh `{value, issues: []}`, the exact call zod's\n * own `safeParse` makes — rather than the finalized `SafeParseResult`.\n *\n * The raw payload is the only place zod's abort state survives.\n * `finalizeIssue` deletes `continue` from every issue and `safeParse` builds\n * its ZodError from the finalized copies, so a delegate that went through\n * `safeParse` could not tell a `z.custom()` failure (`continue: false` — zod\n * defaults `z.custom()` to `abort: true`) from a `.refine()` one\n * (`continue: true`). A plain union prunes its options on that flag\n * (`util.aborted`): with it lost, an option failing through a delegated\n * aborting check was surfaced as the sole non-aborted option instead of inside\n * `invalid_union`. Reading the payload keeps the flag until __zcRf copies it\n * onto the finalized issue, where the union's pruning loop reads it and the\n * top-level finalizer then deletes it, as zod's does.\n *\n * `_zod.run` is also immune to the aliasing hazard `__rfp_N` guards against:\n * `__zcMkv` installs the compiled methods as own `parse`/`safeParse` slots and\n * never touches `_zod`, so a retained entry that IS the compiled schema still\n * runs zod's implementation here. A Promise result is zod's `$ZodAsyncError`,\n * as in `_safeParse`.\n */\nexport const ZC_RUN_DELEGATE_DECL =\n  \"function __zcRd(z,v,c){var r=z.run({value:v,issues:[]},c);\" +\n  \"if(r instanceof Promise)throw new __zcCore.$ZodAsyncError();return r;}\";\n\n/**\n * Finalize a delegate's raw issues onto the validator's list. Each goes\n * through zod's own `util.finalizeIssue` — the check's and schema's error\n * maps, the per-call ctx, `customError`, the locale, then \"Invalid input\", with\n * `inst` and `input` stripped — which is the very function `safeParse` maps\n * every issue through, so the messages are zod's byte for byte. The node's\n * path is prefixed onto the issue's relative one as zod's `prefixIssues`\n * would, and the abort marker is re-applied: an issue whose raw `continue` was\n * not `true` aborted in zod's sense (`util.aborted`), which the union pruning\n * loop reads as `continue:false` before the top-level finalizer deletes the\n * key again (see ZC_RUN_DELEGATE_DECL).\n */\nexport const ZC_DELEGATE_ISSUES_DECL =\n  \"function __zcRf(s,c,e,p){var g=__zcCore.config();for(var i=0;i<s.length;i++){\" +\n  \"var q=s[i],f=__zcCore.util.finalizeIssue(q,c,g);f.path=p.concat(f.path);\" +\n  \"if(q.continue!==true)f.continue=false;e.push(f);}}\";\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, the internal `inst`/`continue` fields\n * dropped (they are zod bookkeeping, deleted before the issue is user-visible),\n * and the owning schema's static message `m` applied to an issue that carries\n * none of its own, since zod stamps the owner onto every issue a check raises.\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 at whose root the\n * superRefine sits reads the flag to mark itself aborted, matching how zod\n * prunes option errors. The aborting issue ALSO keeps a `continue:false`\n * marker of its own, because zod's `util.aborted` reads the flag off the\n * issues and those travel up through containers where the payload flag does\n * not: a fatal superRefine on an object's property aborts the union option\n * holding the object. The top-level finalizer deletes the marker, as zod's\n * `finalizeIssue` does, so no user-visible issue carries it.\n */\nexport const ZC_SR_DECL =\n  \"function __zcSr(f,v,p,e,m){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;t.continue=false;}\" +\n  \"t.path=s.path&&s.path.length?p.concat(s.path):p;\" +\n  \"if(t.message===undefined&&m!==undefined)t.message=m;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  __zcLo: ZC_LENGTH_ORIGIN_DECL,\n  __zcSo: ZC_SIZE_ORIGIN_DECL,\n  __zcCpl: ZC_CPL_DECL,\n  __zcEmail: ZC_EMAIL_DECL,\n  __zcUrl: ZC_URL_DECL,\n  __zcPs: ZC_PROTO_SCRUB_DECL,\n  __zcPlain: ZC_PLAIN_DECL,\n  __zcPfx: ZC_PFX_DECL,\n  __zcPa: ZC_PATH_APPEND_DECL,\n  __zcCu: ZC_CUSTOM_OK_DECL,\n  __zcSr: ZC_SR_DECL,\n  __zcSrOk: ZC_SR_OK_DECL,\n  __zcAsy: ZC_ASYNC_DECL,\n  __zcRd: ZC_RUN_DELEGATE_DECL,\n  __zcRf: ZC_DELEGATE_ISSUES_DECL,\n};\n"],"mappings":";AAkGA,MAAa,cAAgD;CAC3D,QAAQ;CACR,SAAS;CACT,SAAS;CACT,QAAQ;CACR,SAAS;CACT,SAAS;CACT,QAAQ;CACR,SAAS;CACT,QAAQ;CACR,QAAQ;CACR,QAAQ;AACV;;;;;;;;;;;;;AAcA,MAAa,cACX;;;;;;;;;;AAaF,MAAa,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwC3B,MAAa,gBACX;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCF,MAAa,gBACX;;;;;;;;;;AAyBF,MAAa,cACX;;;;;;;;;;;;;;;;;;AAoBF,MAAa,wBACX;;;;;;;;;;;;;;;;;AAkBF,MAAa,sBACX;;;;;;;;AAUF,MAAa,cACX;AAEF,MAAa,sBACX;;;;;;;;;;;;;;;;;;;AAqBF,MAAM,uBAA0C;CAC9C;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,0GAA0G,iBAAiB,GAAG,EAAE;;;;;;;;;;;;;;;;;AAkB1J,MAAa,aACX;;;;;;;;;AAYF,MAAa,cACX;;;;;;;;;;;;;;;;;AAkBF,MAAa,sBACX;;AAGF,SAAgB,gBAAgB,SAAyB;CACvD,OAAO,UAAU,QAAQ,sBAAsB,QAAQ,sBAAsB,QAAQ;AACvF;;;;;;;;;;;;;;;;AAiBA,MAAa,gBACX;;;;;;;;;;;;;AAeF,MAAa,iBACX;;;;;;AAQF,MAAa,oBACX;;;;;;;;;;;;;;;;;;;;;AAuBF,MAAa,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;AAyB7B,MAAa,uBACX;;;;;;;;;;;;;AAeF,MAAa,0BACX;;;;;;;;;;;;;;;;;;;;;;AAyBF,MAAa,aACX;;AAQF,MAAa,uBAAyD;CACpE,QAAQ;CACR,SAAS;CACT,QAAQ;CACR,SAAS;CACT,QAAQ;CACR,QAAQ;CACR,SAAS;CACT,WAAW;CACX,SAAS;CACT,QAAQ;CACR,WAAW;CACX,SAAS;CACT,QAAQ;CACR,QAAQ;CACR,QAAQ;CACR,UAAU;CACV,SAAS;CACT,QAAQ;CACR,QAAQ;AACV"}

package/dist/core/codegen/schemas/string.d.ts

@@ -1,6 +1,19 @@
-import { CheckIR, StringIR } from "../../types.js";
+import { CheckIR, CheckStringFormat, StringIR } from "../../types.js";
 import { CodeGenContext, FastGen, SlowGen } from "../context.js";
 //#region src/core/codegen/schemas/string.d.ts
+/**
+ * Is this a `z.url()` check — one that trims the value and writes back a
+ * rewrite of it? A patterned "url" is a custom format that borrowed the name
+ * (see buildString), validating through its own regex like any other format.
+ */
+declare function isUrlRewrite(check: StringIR["checks"][number]): boolean;
+/**
+ * The url check on the build path: {@link slowUrlCheck}'s verdict and
+ * write-back as statements over `value`, which leave the rewritten value in it
+ * and `return fail` at the first failure rather than push an issue — the
+ * deferred walk reports those.
+ */
+declare function buildUrlCheck(check: CheckStringFormat, value: string, fail: string, temp: (prefix: string) => string, ctx: CodeGenContext): string;
 declare function slowString(ir: StringIR, g: SlowGen): string;
 /**
  * Boolean expression testing ONE compiled string check against `x`, or null when
@@ -15,5 +28,5 @@ declare function slowString(ir: StringIR, g: SlowGen): string;
 declare function fastStringCheck(check: CheckIR, x: string, ctx: CodeGenContext): string | null;
 declare function fastString(ir: StringIR, g: FastGen): string | null;
 //#endregion
-export { fastString, fastStringCheck, slowString };
+export { buildUrlCheck, fastString, fastStringCheck, isUrlRewrite, slowString };
 //# sourceMappingURL=string.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"string.d.ts","names":[],"sources":["../../../../src/core/codegen/schemas/string.ts"],"mappings":";;;iBA0GgB,WAAW,IAAI,UAAU,GAAG;;;;;;;;;;;iBAmK5B,gBAAgB,OAAO,SAAS,WAAW,KAAK;iBAuDhD,WAAW,IAAI,UAAU,GAAG"}
+{"version":3,"file":"string.d.ts","names":[],"sources":["../../../../src/core/codegen/schemas/string.ts"],"mappings":";;;;;;;;iBAuCgB,aAAa,OAAO;;;;;;;iBA6GpB,cACd,OAAO,mBACP,eACA,cACA,OAAO,2BACP,KAAK;iBAyBS,WAAW,IAAI,UAAU,GAAG;;;;;;;;;;;iBAmK5B,gBAAgB,OAAO,SAAS,WAAW,KAAK;iBAuDhD,WAAW,IAAI,UAAU,GAAG"}

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

@@ -1,4 +1,4 @@
-import { ZC_EMAIL_DECL } from "../issue-decls.js";
+import { ZC_EMAIL_DECL, ZC_URL_DECL } from "../issue-decls.js";
 import { EMAIL_REGEX_SOURCE, fastTestSource, isDefaultEmailPattern } from "../well-known-regex.js";
 import { checkPriority, emitEffectFn, emitRegex, emitRegexSourceString, emitRuntimeHelper, escapeString } from "../context.js";
 import { emit } from "../emit.js";
@@ -17,10 +17,36 @@ function lastIndexReset(regexVar, flags) {
 */
 const HTTP_PROTOCOL_SOURCE = "^https?$";
 /**
+* Is this a `z.url()` check — one that trims the value and writes back a
+* rewrite of it? A patterned "url" is a custom format that borrowed the name
+* (see buildString), validating through its own regex like any other format.
+*/
+function isUrlRewrite(check) {
+	return check.kind === "string_format" && check.format === "url" && !check.pattern;
+}
+/**
+* Does the url check read the PARSED url — a hostname or protocol test, or
+* `normalize`'s href? Only then is the URL object needed; a check that only asks
+* whether the input parses goes through `__zcUrl` (see ZC_URL_DECL) instead.
+*/
+function urlReadsParsed(check) {
+	return Boolean(check.hostname) || Boolean(check.protocol) || check.normalize === true;
+}
+/** $ZodURL's write-back without `normalize`: the trimmed input, tabs and newlines deleted. */
+function urlStripped(trimmedVar, ctx) {
+	return `${trimmedVar}.replace(${emitRegex(ctx, "tnl", "[\\t\\n\\r]", "g")},"")`;
+}
+/** `url.protocol` without its trailing colon, the form $ZodURL tests. */
+function urlProtocol(urlVar) {
+	return `(${urlVar}.protocol.endsWith(":")?${urlVar}.protocol.slice(0,-1):${urlVar}.protocol)`;
+}
+/**
 * Generate the url check, mirroring $ZodURL semantics:
 * trim → (for an http(s)-protocol check without normalize) require `://` →
 * new URL(trimmed) → optional hostname/protocol regex tests → write back
 * url.href (normalize) or the trimmed input with its tabs and newlines deleted.
+* A check that reads nothing off the parsed URL only asks `__zcUrl` whether the
+* input parses, which skips constructing it.
 *
 * The `://` guard is `parseURLObject`'s: without it the URL parser accepts
 * `http:example.com`, and its rejection is a distinct issue (`note: "Invalid
@@ -36,41 +62,48 @@ const HTTP_PROTOCOL_SOURCE = "^https?$";
 */
 function slowUrlCheck(check, g) {
 	const trimmedVar = g.temp("ut");
-	const urlVar = g.temp("u");
-	let inner = "";
-	if (check.hostname) {
-		const re = g.regex("host", check.hostname, check.hostnameFlags);
-		inner += emit`
-      ${lastIndexReset(re, check.hostnameFlags)}
-      if(!${re}.test(${urlVar}.hostname)){
-        ${invalidFormat(g, "url", {
-			extra: `note:"Invalid hostname",pattern:${escapeString(check.hostname)}`,
-			message: check.message
-		})}
+	let parse;
+	if (!urlReadsParsed(check)) parse = emit`
+      if(!${emitRuntimeHelper(g.ctx, "__zcUrl", ZC_URL_DECL)}(${trimmedVar})){
+        ${invalidFormat(g, "url", { message: check.message })}
+      }else{
+        ${g.output}=${urlStripped(trimmedVar, g.ctx)};
       }`;
-	}
-	if (check.protocol) {
-		const re = g.regex("proto", check.protocol, check.protocolFlags);
-		const protoExpr = `(${urlVar}.protocol.endsWith(":")?${urlVar}.protocol.slice(0,-1):${urlVar}.protocol)`;
-		inner += emit`
-      ${lastIndexReset(re, check.protocolFlags)}
-      if(!${re}.test(${protoExpr})){
-        ${invalidFormat(g, "url", {
-			extra: `note:"Invalid protocol",pattern:${escapeString(check.protocol)}`,
-			message: check.message
-		})}
+	else {
+		const urlVar = g.temp("u");
+		let inner = "";
+		if (check.hostname) {
+			const re = g.regex("host", check.hostname, check.hostnameFlags);
+			inner += emit`
+        ${lastIndexReset(re, check.hostnameFlags)}
+        if(!${re}.test(${urlVar}.hostname)){
+          ${invalidFormat(g, "url", {
+				extra: `note:"Invalid hostname",pattern:${escapeString(check.hostname)}`,
+				message: check.message
+			})}
+        }`;
+		}
+		if (check.protocol) {
+			const re = g.regex("proto", check.protocol, check.protocolFlags);
+			inner += emit`
+        ${lastIndexReset(re, check.protocolFlags)}
+        if(!${re}.test(${urlProtocol(urlVar)})){
+          ${invalidFormat(g, "url", {
+				extra: `note:"Invalid protocol",pattern:${escapeString(check.protocol)}`,
+				message: check.message
+			})}
+        }`;
+		}
+		inner += `${g.output}=${check.normalize ? `${urlVar}.href` : urlStripped(trimmedVar, g.ctx)};`;
+		parse = emit`
+      var ${urlVar}=null;
+      try{${urlVar}=new URL(${trimmedVar});}catch(_){}
+      if(${urlVar}===null){
+        ${invalidFormat(g, "url", { message: check.message })}
+      }else{
+        ${inner}
       }`;
 	}
-	const stripped = check.normalize ? `${urlVar}.href` : `${trimmedVar}.replace(${g.regex("tnl", "[\\t\\n\\r]", "g")},"")`;
-	inner += `${g.output}=${stripped};`;
-	let parse = emit`
-    var ${urlVar}=null;
-    try{${urlVar}=new URL(${trimmedVar});}catch(_){}
-    if(${urlVar}===null){
-      ${invalidFormat(g, "url", { message: check.message })}
-    }else{
-      ${inner}
-    }`;
 	if (!check.normalize && check.protocol === HTTP_PROTOCOL_SOURCE) parse = emit`
       if(!${g.regex("httpUrl", "^https?:\\/\\/", "i")}.test(${trimmedVar})){
         ${invalidFormat(g, "url", {
@@ -84,6 +117,35 @@ function slowUrlCheck(check, g) {
     var ${trimmedVar}=${g.input}.trim();
     ${parse}`;
 }
+/**
+* The url check on the build path: {@link slowUrlCheck}'s verdict and
+* write-back as statements over `value`, which leave the rewritten value in it
+* and `return fail` at the first failure rather than push an issue — the
+* deferred walk reports those.
+*/
+function buildUrlCheck(check, value, fail, temp, ctx) {
+	const trimmedVar = temp("but");
+	let code = `${trimmedVar}=${value}.trim();`;
+	if (!check.normalize && check.protocol === HTTP_PROTOCOL_SOURCE) {
+		const re = emitRegex(ctx, "httpUrl", "^https?:\\/\\/", "i");
+		code += `if(!${re}.test(${trimmedVar}))return ${fail};`;
+	}
+	if (!urlReadsParsed(check)) {
+		const parses = `${emitRuntimeHelper(ctx, "__zcUrl", ZC_URL_DECL)}(${trimmedVar})`;
+		return `${code}if(!${parses})return ${fail};${value}=${urlStripped(trimmedVar, ctx)};`;
+	}
+	const urlVar = temp("bur");
+	code += `try{${urlVar}=new URL(${trimmedVar});}catch(_){return ${fail};}`;
+	if (check.hostname) {
+		const re = emitRegex(ctx, "host", check.hostname, check.hostnameFlags);
+		code += `${lastIndexReset(re, check.hostnameFlags)}if(!${re}.test(${urlVar}.hostname))return ${fail};`;
+	}
+	if (check.protocol) {
+		const re = emitRegex(ctx, "proto", check.protocol, check.protocolFlags);
+		code += `${lastIndexReset(re, check.protocolFlags)}if(!${re}.test(${urlProtocol(urlVar)}))return ${fail};`;
+	}
+	return `${code}${value}=${check.normalize ? `${urlVar}.href` : urlStripped(trimmedVar, ctx)};`;
+}
 function slowString(ir, g) {
 	let code = "";
 	if (ir.coerce) code += emit`try{${g.output}=String(${g.input});}catch(_){}`;
@@ -223,7 +285,7 @@ function fastStringCheck(check, x, ctx) {
 		case "starts_with": return `${x}.startsWith(${escapeString(check.prefix)})`;
 		case "ends_with": return `${x}.endsWith(${escapeString(check.suffix)})`;
 		case "string_format": {
-			if (check.format === "url" && !check.pattern) return null;
+			if (isUrlRewrite(check)) return null;
 			let pattern;
 			let prefix;
 			if (check.format === "email") {
@@ -259,6 +321,6 @@ function fastString(ir, g) {
 	return parts.join("&&");
 }
 //#endregion
-export { fastString, fastStringCheck, slowString };
+export { buildUrlCheck, fastString, fastStringCheck, isUrlRewrite, slowString };
 
 //# sourceMappingURL=string.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"string.js","names":[],"sources":["../../../../src/core/codegen/schemas/string.ts"],"sourcesContent":["import type { CheckIR, CheckStringFormat, StringIR } from \"../../types.js\";\nimport type { CodeGenContext, FastGen, SlowGen } from \"../context.js\";\nimport {\n  checkPriority,\n  emitEffectFn,\n  emitRegex,\n  emitRegexSourceString,\n  emitRuntimeHelper,\n  escapeString,\n} from \"../context.js\";\nimport { emit } from \"../emit.js\";\nimport { invalidFormat, invalidType, tooBig, tooSmall } from \"../emit-issue.js\";\nimport { ZC_EMAIL_DECL } from \"../issue-decls.js\";\nimport {\n  EMAIL_REGEX_SOURCE,\n  fastTestSource,\n  isDefaultEmailPattern,\n  UUID_REGEX_SOURCE,\n} from \"../well-known-regex.js\";\nimport { fastRefineTest, refineCheck, superRefineCheck, superRefineFastTest } from \"./effect.js\";\nimport { stringLengthTests, whenGatedSizeChecks } from \"./sizeable.js\";\n\n/** `re.lastIndex=0;` reset statement for stateful (g/y-flagged) regexes. */\nfunction lastIndexReset(regexVar: string, flags: string | undefined): string {\n  return flags && /[gy]/.test(flags) ? `${regexVar}.lastIndex=0;` : \"\";\n}\n\n/**\n * `regexes.httpProtocol.source`. `parseURLObject` compares a url check's\n * protocol SOURCE against it — not the schema constructor — so any check whose\n * protocol is spelled this way gets the guard, `z.httpUrl()` or not.\n */\nconst HTTP_PROTOCOL_SOURCE = \"^https?$\";\n\n/**\n * Generate the url check, mirroring $ZodURL semantics:\n * trim → (for an http(s)-protocol check without normalize) require `://` →\n * new URL(trimmed) → optional hostname/protocol regex tests → write back\n * url.href (normalize) or the trimmed input with its tabs and newlines deleted.\n *\n * The `://` guard is `parseURLObject`'s: without it the URL parser accepts\n * `http:example.com`, and its rejection is a distinct issue (`note: \"Invalid\n * URL format\"`, no `pattern`) pushed BEFORE the parser runs. The deletion of\n * `\\t`, `\\n` and `\\r` (`stripTabAndNewline`) matches what the parser itself\n * drops before it reads the host, so the returned value names the host that was\n * validated.\n *\n * $ZodURL is another constructor that OVERRIDES the `??=`-installed default\n * check, so none of the issues below carries `origin` — and the two that do\n * carry a `pattern` use `regex.source`, not the default check's\n * `regex.toString()` (no delimiters, no flags). Both are reproduced verbatim.\n */\nfunction slowUrlCheck(check: CheckStringFormat, g: SlowGen): string {\n  const trimmedVar = g.temp(\"ut\");\n  const urlVar = g.temp(\"u\");\n  let inner = \"\";\n  if (check.hostname) {\n    const re = g.regex(\"host\", check.hostname, check.hostnameFlags);\n    inner += emit`\n      ${lastIndexReset(re, check.hostnameFlags)}\n      if(!${re}.test(${urlVar}.hostname)){\n        ${invalidFormat(g, \"url\", {\n          extra: `note:\"Invalid hostname\",pattern:${escapeString(check.hostname)}`,\n          message: check.message,\n        })}\n      }`;\n  }\n  if (check.protocol) {\n    const re = g.regex(\"proto\", check.protocol, check.protocolFlags);\n    const protoExpr = `(${urlVar}.protocol.endsWith(\":\")?${urlVar}.protocol.slice(0,-1):${urlVar}.protocol)`;\n    inner += emit`\n      ${lastIndexReset(re, check.protocolFlags)}\n      if(!${re}.test(${protoExpr})){\n        ${invalidFormat(g, \"url\", {\n          extra: `note:\"Invalid protocol\",pattern:${escapeString(check.protocol)}`,\n          message: check.message,\n        })}\n      }`;\n  }\n  // Zod writes the value back even when hostname/protocol issues were pushed.\n  const stripped = check.normalize\n    ? `${urlVar}.href`\n    : `${trimmedVar}.replace(${g.regex(\"tnl\", \"[\\\\t\\\\n\\\\r]\", \"g\")},\"\")`;\n  inner += `${g.output}=${stripped};`;\n  let parse = emit`\n    var ${urlVar}=null;\n    try{${urlVar}=new URL(${trimmedVar});}catch(_){}\n    if(${urlVar}===null){\n      ${invalidFormat(g, \"url\", { message: check.message })}\n    }else{\n      ${inner}\n    }`;\n  if (!check.normalize && check.protocol === HTTP_PROTOCOL_SOURCE) {\n    const re = g.regex(\"httpUrl\", \"^https?:\\\\/\\\\/\", \"i\");\n    parse = emit`\n      if(!${re}.test(${trimmedVar})){\n        ${invalidFormat(g, \"url\", { extra: `note:\"Invalid URL format\"`, message: check.message })}\n      }else{\n        ${parse}\n      }`;\n  }\n  return emit`\n    var ${trimmedVar}=${g.input}.trim();\n    ${parse}`;\n}\n\nexport function slowString(ir: StringIR, g: SlowGen): string {\n  let code = \"\";\n  if (ir.coerce) {\n    code += emit`try{${g.output}=String(${g.input});}catch(_){}`;\n  }\n  code += emit`\n    if(typeof ${g.input}!==\"string\"){\n      ${invalidType(g, \"string\")}\n      ${whenGatedSizeChecks(ir.checks, g, \"length\")}\n    }`;\n\n  if (ir.checks.length > 0) {\n    code += `else{`;\n    // Insertion order mirrors zod's issue order for multi-failure inputs;\n    // the slow path collects all issues with no short-circuit.\n    for (const check of ir.checks) {\n      switch (check.kind) {\n        // Length is measured in code points where the unit count leaves the\n        // verdict in doubt — see stringLengthTests.\n        case \"min_length\":\n          code += emit`\n            if(${stringLengthTests.minFails(g.input, check.minimum, g.ctx)}){\n              ${tooSmall(g, check.minimum, \"string\", true, { message: check.message })}\n            }`;\n          break;\n        case \"max_length\":\n          code += emit`\n            if(${stringLengthTests.maxFails(g.input, check.maximum, g.ctx)}){\n              ${tooBig(g, check.maximum, \"string\", true, { message: check.message })}\n            }`;\n          break;\n        case \"length_equals\": {\n          const length = g.temp(\"cl\");\n          code += emit`\n            var ${length}=${stringLengthTests.measure(g.input, check.length, g.ctx)};\n            if(${length}<${check.length}){\n              ${tooSmall(g, check.length, \"string\", true, { exact: true, message: check.message })}\n            }else if(${length}>${check.length}){\n              ${tooBig(g, check.length, \"string\", true, { exact: true, message: check.message })}\n            }`;\n          break;\n        }\n        // includes/starts_with/ends_with each carry `origin:\"string\"` but NO\n        // `pattern`: $ZodCheckIncludes/StartsWith/EndsWith bypass\n        // $ZodCheckStringFormat entirely (they init from $ZodCheck and assign\n        // `inst._zod.check` directly), and the pattern they build is registered\n        // in the bag for JSON Schema only, never put on the issue.\n        case \"includes\":\n          code += emit`\n            if(!${g.input}.includes(${escapeString(check.includes)}${check.position !== undefined ? `,${check.position}` : \"\"})){\n              ${invalidFormat(g, \"includes\", { origin: \"string\", extra: `includes:${escapeString(check.includes)}`, message: check.message })}\n            }`;\n          break;\n        case \"starts_with\":\n          code += emit`\n            if(!${g.input}.startsWith(${escapeString(check.prefix)})){\n              ${invalidFormat(g, \"starts_with\", { origin: \"string\", extra: `prefix:${escapeString(check.prefix)}`, message: check.message })}\n            }`;\n          break;\n        case \"ends_with\":\n          code += emit`\n            if(!${g.input}.endsWith(${escapeString(check.suffix)})){\n              ${invalidFormat(g, \"ends_with\", { origin: \"string\", extra: `suffix:${escapeString(check.suffix)}`, message: check.message })}\n            }`;\n          break;\n        case \"refine_effect\":\n          code += refineCheck(check, g.input, g);\n          break;\n        case \"super_refine_effect\":\n          code += superRefineCheck(check, g.input, g);\n          break;\n        case \"overwrite_effect\":\n          // $ZodCheckOverwrite: value = tx(value). Later checks read the\n          // rewritten value because input aliases the output location.\n          code += emit`${g.output}=${emitEffectFn(g.ctx, check.source)}(${g.input});`;\n          break;\n        case \"string_format\": {\n          let prefix: string;\n          let pattern: string;\n          // Only the BUILT-IN z.url() gets the URL-parser check, and extraction\n          // never gives that one a pattern. A `pattern` on a \"url\"-named check\n          // therefore marks a custom format that merely borrowed the name\n          // (`z.stringFormat(\"url\", /re/)`); it validates through its own regex,\n          // so fall through and compile that instead of the URL parser.\n          if (check.format === \"url\" && !check.pattern) {\n            code += slowUrlCheck(check, g);\n            continue;\n          }\n          if (check.format === \"email\") {\n            pattern = check.pattern ?? EMAIL_REGEX_SOURCE;\n            prefix = \"email\";\n          } else if (check.format === \"regex\" && check.pattern) {\n            pattern = check.pattern;\n            prefix = \"str\";\n          } else if (check.format === \"uuid\") {\n            pattern = check.pattern ?? UUID_REGEX_SOURCE;\n            prefix = \"uuid\";\n          } else {\n            if (check.pattern) {\n              pattern = check.pattern;\n              prefix = \"str\";\n            } else {\n              // Extraction guarantees a pattern for non-special formats;\n              // defensive skip kept for hand-built IR.\n              continue;\n            }\n          }\n          // Zod's default email pattern is tested by the `__zcEmail` scanner, so\n          // no RegExp is declared for it at all (see ZC_EMAIL_DECL); the issue\n          // below still names the pattern, through the shared source string.\n          const scanner = isDefaultEmailPattern(pattern, check.patternFlags)\n            ? emitRuntimeHelper(g.ctx, \"__zcEmail\", ZC_EMAIL_DECL)\n            : null;\n          const regexVar = scanner === null ? g.regex(prefix, pattern, check.patternFlags) : null;\n          // Zod's invalid_format shape depends on WHICH check instance ran.\n          // `$ZodCheckStringFormat.init` installs the default pattern check with\n          // `??=`, and that default pushes `origin:\"string\"` + `pattern`. A\n          // constructor that OVERRIDES `inst._zod.check` pushes its own issue\n          // instead — `$ZodCustomStringFormat` (z.stringFormat/z.hex/z.hostname/\n          // z.hash) pushes a bare `{code, format, input}` because it validates\n          // through `def.fn` and never reads `def.pattern`. We test the pattern\n          // either way, so the issue shape is driven off the extracted flag.\n          let extra: string | undefined;\n          if (!check.bareIssue) {\n            // When emitRegex swapped in a faster equivalent pattern (or the\n            // scanner stands in for the RegExp), the runtime regex's toString()\n            // would leak the rewrite into the issue. Reference the shared\n            // original-pattern string instead (pattern came from RegExp.source,\n            // so it matches zod's `.toString()` byte-for-byte).\n            const rewritten = !check.patternFlags && fastTestSource(pattern) !== null;\n            const patternExpr =\n              rewritten || regexVar === null\n                ? emitRegexSourceString(g.ctx, pattern)\n                : `${regexVar}.toString()`;\n            extra = `pattern:${patternExpr}`;\n          }\n          const test =\n            regexVar === null ? `${scanner}(${g.input})` : `${regexVar}.test(${g.input})`;\n          code += emit`\n            ${regexVar === null ? \"\" : lastIndexReset(regexVar, check.patternFlags)}\n            if(!${test}){\n              ${invalidFormat(g, { expr: escapeString(check.format) }, { origin: check.bareIssue ? undefined : \"string\", extra, message: check.message })}\n            }`;\n          break;\n        }\n      }\n    }\n    code += `}`;\n  }\n\n  return `${code}\\n`;\n}\n\n/**\n * Boolean expression testing ONE compiled string check against `x`, or null when\n * the check is not expressible as a pure predicate (`z.url()`, which trims and\n * normalizes, and an unknown format with no pattern).\n *\n * Shared by the fast path — which sorts the checks cheapest-first and joins them\n * with `&&` — and by the build path, which emits them one statement at a time in\n * DECLARATION order so an interleaved `.trim()` rewrite is visible to the checks\n * that follow it (see buildString).\n */\nexport function fastStringCheck(check: CheckIR, x: string, ctx: CodeGenContext): string | null {\n  switch (check.kind) {\n    case \"min_length\":\n      return stringLengthTests.min(x, check.minimum, ctx);\n    case \"max_length\":\n      return stringLengthTests.max(x, check.maximum, ctx);\n    case \"length_equals\":\n      return stringLengthTests.equals(x, check.length, ctx);\n    case \"includes\":\n      return check.position !== undefined\n        ? `${x}.includes(${escapeString(check.includes)},${check.position})`\n        : `${x}.includes(${escapeString(check.includes)})`;\n    case \"starts_with\":\n      return `${x}.startsWith(${escapeString(check.prefix)})`;\n    case \"ends_with\":\n      return `${x}.endsWith(${escapeString(check.suffix)})`;\n    case \"string_format\": {\n      // URL validation mutates (trims) and uses try/catch — not a predicate.\n      // A patterned \"url\" check is a custom format that borrowed the name (see\n      // buildString), and its regex IS a predicate.\n      if (check.format === \"url\" && !check.pattern) return null;\n      let pattern: string;\n      let prefix: string;\n      if (check.format === \"email\") {\n        prefix = \"email\";\n        pattern = check.pattern ?? EMAIL_REGEX_SOURCE;\n      } else if (check.format === \"uuid\") {\n        prefix = \"uuid\";\n        pattern = check.pattern ?? UUID_REGEX_SOURCE;\n      } else if (check.pattern) {\n        prefix = \"re\";\n        pattern = check.pattern;\n      } else {\n        // Unknown format without pattern — can't generate a check\n        return null;\n      }\n      // Zod's default email pattern runs as a linear scan instead of a RegExp\n      // (see ZC_EMAIL_DECL) — a plain call, so it needs no parens either.\n      if (isDefaultEmailPattern(pattern, check.patternFlags)) {\n        return `${emitRuntimeHelper(ctx, \"__zcEmail\", ZC_EMAIL_DECL)}(${x})`;\n      }\n      const v = emitRegex(ctx, prefix, pattern, check.patternFlags);\n      // Stateful (g/y) regexes need lastIndex reset; comma expression keeps\n      // this usable inside the boolean chain.\n      return check.patternFlags && /[gy]/.test(check.patternFlags)\n        ? `((${v}.lastIndex=0),${v}.test(${x}))`\n        : `${v}.test(${x})`;\n    }\n    default:\n      // A check kind this generator does not model (number/bigint/date/set\n      // shapes never reach here from a string node).\n      return null;\n  }\n}\n\nexport function fastString(ir: StringIR, g: FastGen): string | null {\n  if (ir.coerce) return null;\n  // Overwrite effects rewrite the value — the fast path returns input\n  // unchanged, so any mutation makes it ineligible.\n  if (ir.checks.some((c) => c.kind === \"overwrite_effect\")) return null;\n\n  const x = g.input;\n  const parts: string[] = [`typeof ${x}===\"string\"`];\n  const checks = ir.checks.filter(\n    (c): c is CheckIR => c.kind !== \"refine_effect\" && c.kind !== \"overwrite_effect\",\n  );\n\n  for (const check of checks.sort(checkPriority)) {\n    const expr = fastStringCheck(check, x, g.ctx);\n    if (expr === null) return null;\n    parts.push(expr);\n  }\n\n  // Refine effect checks (appended last — run after cheap checks short-circuit)\n  for (const check of ir.checks) {\n    if (check.kind === \"refine_effect\") {\n      parts.push(fastRefineTest(check, x, g));\n    } else if (check.kind === \"super_refine_effect\") {\n      parts.push(superRefineFastTest(check, x, g));\n    }\n  }\n\n  return parts.join(\"&&\");\n}\n"],"mappings":"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"}
+{"version":3,"file":"string.js","names":[],"sources":["../../../../src/core/codegen/schemas/string.ts"],"sourcesContent":["import type { CheckIR, CheckStringFormat, StringIR } from \"../../types.js\";\nimport type { CodeGenContext, FastGen, SlowGen } from \"../context.js\";\nimport {\n  checkPriority,\n  emitEffectFn,\n  emitRegex,\n  emitRegexSourceString,\n  emitRuntimeHelper,\n  escapeString,\n} from \"../context.js\";\nimport { emit } from \"../emit.js\";\nimport { invalidFormat, invalidType, tooBig, tooSmall } from \"../emit-issue.js\";\nimport { ZC_EMAIL_DECL, ZC_URL_DECL } from \"../issue-decls.js\";\nimport {\n  EMAIL_REGEX_SOURCE,\n  fastTestSource,\n  isDefaultEmailPattern,\n  UUID_REGEX_SOURCE,\n} from \"../well-known-regex.js\";\nimport { fastRefineTest, refineCheck, superRefineCheck, superRefineFastTest } from \"./effect.js\";\nimport { stringLengthTests, whenGatedSizeChecks } from \"./sizeable.js\";\n\n/** `re.lastIndex=0;` reset statement for stateful (g/y-flagged) regexes. */\nfunction lastIndexReset(regexVar: string, flags: string | undefined): string {\n  return flags && /[gy]/.test(flags) ? `${regexVar}.lastIndex=0;` : \"\";\n}\n\n/**\n * `regexes.httpProtocol.source`. `parseURLObject` compares a url check's\n * protocol SOURCE against it — not the schema constructor — so any check whose\n * protocol is spelled this way gets the guard, `z.httpUrl()` or not.\n */\nconst HTTP_PROTOCOL_SOURCE = \"^https?$\";\n\n/**\n * Is this a `z.url()` check — one that trims the value and writes back a\n * rewrite of it? A patterned \"url\" is a custom format that borrowed the name\n * (see buildString), validating through its own regex like any other format.\n */\nexport function isUrlRewrite(check: StringIR[\"checks\"][number]): boolean {\n  return check.kind === \"string_format\" && check.format === \"url\" && !check.pattern;\n}\n\n/**\n * Does the url check read the PARSED url — a hostname or protocol test, or\n * `normalize`'s href? Only then is the URL object needed; a check that only asks\n * whether the input parses goes through `__zcUrl` (see ZC_URL_DECL) instead.\n */\nfunction urlReadsParsed(check: CheckStringFormat): boolean {\n  return Boolean(check.hostname) || Boolean(check.protocol) || check.normalize === true;\n}\n\n/** $ZodURL's write-back without `normalize`: the trimmed input, tabs and newlines deleted. */\nfunction urlStripped(trimmedVar: string, ctx: CodeGenContext): string {\n  return `${trimmedVar}.replace(${emitRegex(ctx, \"tnl\", \"[\\\\t\\\\n\\\\r]\", \"g\")},\"\")`;\n}\n\n/** `url.protocol` without its trailing colon, the form $ZodURL tests. */\nfunction urlProtocol(urlVar: string): string {\n  return `(${urlVar}.protocol.endsWith(\":\")?${urlVar}.protocol.slice(0,-1):${urlVar}.protocol)`;\n}\n\n/**\n * Generate the url check, mirroring $ZodURL semantics:\n * trim → (for an http(s)-protocol check without normalize) require `://` →\n * new URL(trimmed) → optional hostname/protocol regex tests → write back\n * url.href (normalize) or the trimmed input with its tabs and newlines deleted.\n * A check that reads nothing off the parsed URL only asks `__zcUrl` whether the\n * input parses, which skips constructing it.\n *\n * The `://` guard is `parseURLObject`'s: without it the URL parser accepts\n * `http:example.com`, and its rejection is a distinct issue (`note: \"Invalid\n * URL format\"`, no `pattern`) pushed BEFORE the parser runs. The deletion of\n * `\\t`, `\\n` and `\\r` (`stripTabAndNewline`) matches what the parser itself\n * drops before it reads the host, so the returned value names the host that was\n * validated.\n *\n * $ZodURL is another constructor that OVERRIDES the `??=`-installed default\n * check, so none of the issues below carries `origin` — and the two that do\n * carry a `pattern` use `regex.source`, not the default check's\n * `regex.toString()` (no delimiters, no flags). Both are reproduced verbatim.\n */\nfunction slowUrlCheck(check: CheckStringFormat, g: SlowGen): string {\n  const trimmedVar = g.temp(\"ut\");\n  let parse: string;\n  if (!urlReadsParsed(check)) {\n    parse = emit`\n      if(!${emitRuntimeHelper(g.ctx, \"__zcUrl\", ZC_URL_DECL)}(${trimmedVar})){\n        ${invalidFormat(g, \"url\", { message: check.message })}\n      }else{\n        ${g.output}=${urlStripped(trimmedVar, g.ctx)};\n      }`;\n  } else {\n    const urlVar = g.temp(\"u\");\n    let inner = \"\";\n    if (check.hostname) {\n      const re = g.regex(\"host\", check.hostname, check.hostnameFlags);\n      inner += emit`\n        ${lastIndexReset(re, check.hostnameFlags)}\n        if(!${re}.test(${urlVar}.hostname)){\n          ${invalidFormat(g, \"url\", {\n            extra: `note:\"Invalid hostname\",pattern:${escapeString(check.hostname)}`,\n            message: check.message,\n          })}\n        }`;\n    }\n    if (check.protocol) {\n      const re = g.regex(\"proto\", check.protocol, check.protocolFlags);\n      inner += emit`\n        ${lastIndexReset(re, check.protocolFlags)}\n        if(!${re}.test(${urlProtocol(urlVar)})){\n          ${invalidFormat(g, \"url\", {\n            extra: `note:\"Invalid protocol\",pattern:${escapeString(check.protocol)}`,\n            message: check.message,\n          })}\n        }`;\n    }\n    // Zod writes the value back even when hostname/protocol issues were pushed.\n    inner += `${g.output}=${check.normalize ? `${urlVar}.href` : urlStripped(trimmedVar, g.ctx)};`;\n    parse = emit`\n      var ${urlVar}=null;\n      try{${urlVar}=new URL(${trimmedVar});}catch(_){}\n      if(${urlVar}===null){\n        ${invalidFormat(g, \"url\", { message: check.message })}\n      }else{\n        ${inner}\n      }`;\n  }\n  if (!check.normalize && check.protocol === HTTP_PROTOCOL_SOURCE) {\n    const re = g.regex(\"httpUrl\", \"^https?:\\\\/\\\\/\", \"i\");\n    parse = emit`\n      if(!${re}.test(${trimmedVar})){\n        ${invalidFormat(g, \"url\", { extra: `note:\"Invalid URL format\"`, message: check.message })}\n      }else{\n        ${parse}\n      }`;\n  }\n  return emit`\n    var ${trimmedVar}=${g.input}.trim();\n    ${parse}`;\n}\n\n/**\n * The url check on the build path: {@link slowUrlCheck}'s verdict and\n * write-back as statements over `value`, which leave the rewritten value in it\n * and `return fail` at the first failure rather than push an issue — the\n * deferred walk reports those.\n */\nexport function buildUrlCheck(\n  check: CheckStringFormat,\n  value: string,\n  fail: string,\n  temp: (prefix: string) => string,\n  ctx: CodeGenContext,\n): string {\n  const trimmedVar = temp(\"but\");\n  let code = `${trimmedVar}=${value}.trim();`;\n  if (!check.normalize && check.protocol === HTTP_PROTOCOL_SOURCE) {\n    const re = emitRegex(ctx, \"httpUrl\", \"^https?:\\\\/\\\\/\", \"i\");\n    code += `if(!${re}.test(${trimmedVar}))return ${fail};`;\n  }\n  if (!urlReadsParsed(check)) {\n    const parses = `${emitRuntimeHelper(ctx, \"__zcUrl\", ZC_URL_DECL)}(${trimmedVar})`;\n    return `${code}if(!${parses})return ${fail};${value}=${urlStripped(trimmedVar, ctx)};`;\n  }\n  const urlVar = temp(\"bur\");\n  code += `try{${urlVar}=new URL(${trimmedVar});}catch(_){return ${fail};}`;\n  if (check.hostname) {\n    const re = emitRegex(ctx, \"host\", check.hostname, check.hostnameFlags);\n    code += `${lastIndexReset(re, check.hostnameFlags)}if(!${re}.test(${urlVar}.hostname))return ${fail};`;\n  }\n  if (check.protocol) {\n    const re = emitRegex(ctx, \"proto\", check.protocol, check.protocolFlags);\n    code += `${lastIndexReset(re, check.protocolFlags)}if(!${re}.test(${urlProtocol(urlVar)}))return ${fail};`;\n  }\n  return `${code}${value}=${check.normalize ? `${urlVar}.href` : urlStripped(trimmedVar, ctx)};`;\n}\n\nexport function slowString(ir: StringIR, g: SlowGen): string {\n  let code = \"\";\n  if (ir.coerce) {\n    code += emit`try{${g.output}=String(${g.input});}catch(_){}`;\n  }\n  code += emit`\n    if(typeof ${g.input}!==\"string\"){\n      ${invalidType(g, \"string\")}\n      ${whenGatedSizeChecks(ir.checks, g, \"length\")}\n    }`;\n\n  if (ir.checks.length > 0) {\n    code += `else{`;\n    // Insertion order mirrors zod's issue order for multi-failure inputs;\n    // the slow path collects all issues with no short-circuit.\n    for (const check of ir.checks) {\n      switch (check.kind) {\n        // Length is measured in code points where the unit count leaves the\n        // verdict in doubt — see stringLengthTests.\n        case \"min_length\":\n          code += emit`\n            if(${stringLengthTests.minFails(g.input, check.minimum, g.ctx)}){\n              ${tooSmall(g, check.minimum, \"string\", true, { message: check.message })}\n            }`;\n          break;\n        case \"max_length\":\n          code += emit`\n            if(${stringLengthTests.maxFails(g.input, check.maximum, g.ctx)}){\n              ${tooBig(g, check.maximum, \"string\", true, { message: check.message })}\n            }`;\n          break;\n        case \"length_equals\": {\n          const length = g.temp(\"cl\");\n          code += emit`\n            var ${length}=${stringLengthTests.measure(g.input, check.length, g.ctx)};\n            if(${length}<${check.length}){\n              ${tooSmall(g, check.length, \"string\", true, { exact: true, message: check.message })}\n            }else if(${length}>${check.length}){\n              ${tooBig(g, check.length, \"string\", true, { exact: true, message: check.message })}\n            }`;\n          break;\n        }\n        // includes/starts_with/ends_with each carry `origin:\"string\"` but NO\n        // `pattern`: $ZodCheckIncludes/StartsWith/EndsWith bypass\n        // $ZodCheckStringFormat entirely (they init from $ZodCheck and assign\n        // `inst._zod.check` directly), and the pattern they build is registered\n        // in the bag for JSON Schema only, never put on the issue.\n        case \"includes\":\n          code += emit`\n            if(!${g.input}.includes(${escapeString(check.includes)}${check.position !== undefined ? `,${check.position}` : \"\"})){\n              ${invalidFormat(g, \"includes\", { origin: \"string\", extra: `includes:${escapeString(check.includes)}`, message: check.message })}\n            }`;\n          break;\n        case \"starts_with\":\n          code += emit`\n            if(!${g.input}.startsWith(${escapeString(check.prefix)})){\n              ${invalidFormat(g, \"starts_with\", { origin: \"string\", extra: `prefix:${escapeString(check.prefix)}`, message: check.message })}\n            }`;\n          break;\n        case \"ends_with\":\n          code += emit`\n            if(!${g.input}.endsWith(${escapeString(check.suffix)})){\n              ${invalidFormat(g, \"ends_with\", { origin: \"string\", extra: `suffix:${escapeString(check.suffix)}`, message: check.message })}\n            }`;\n          break;\n        case \"refine_effect\":\n          code += refineCheck(check, g.input, g);\n          break;\n        case \"super_refine_effect\":\n          code += superRefineCheck(check, g.input, g);\n          break;\n        case \"overwrite_effect\":\n          // $ZodCheckOverwrite: value = tx(value). Later checks read the\n          // rewritten value because input aliases the output location.\n          code += emit`${g.output}=${emitEffectFn(g.ctx, check.source)}(${g.input});`;\n          break;\n        case \"string_format\": {\n          let prefix: string;\n          let pattern: string;\n          // Only the BUILT-IN z.url() gets the URL-parser check, and extraction\n          // never gives that one a pattern. A `pattern` on a \"url\"-named check\n          // therefore marks a custom format that merely borrowed the name\n          // (`z.stringFormat(\"url\", /re/)`); it validates through its own regex,\n          // so fall through and compile that instead of the URL parser.\n          if (check.format === \"url\" && !check.pattern) {\n            code += slowUrlCheck(check, g);\n            continue;\n          }\n          if (check.format === \"email\") {\n            pattern = check.pattern ?? EMAIL_REGEX_SOURCE;\n            prefix = \"email\";\n          } else if (check.format === \"regex\" && check.pattern) {\n            pattern = check.pattern;\n            prefix = \"str\";\n          } else if (check.format === \"uuid\") {\n            pattern = check.pattern ?? UUID_REGEX_SOURCE;\n            prefix = \"uuid\";\n          } else {\n            if (check.pattern) {\n              pattern = check.pattern;\n              prefix = \"str\";\n            } else {\n              // Extraction guarantees a pattern for non-special formats;\n              // defensive skip kept for hand-built IR.\n              continue;\n            }\n          }\n          // Zod's default email pattern is tested by the `__zcEmail` scanner, so\n          // no RegExp is declared for it at all (see ZC_EMAIL_DECL); the issue\n          // below still names the pattern, through the shared source string.\n          const scanner = isDefaultEmailPattern(pattern, check.patternFlags)\n            ? emitRuntimeHelper(g.ctx, \"__zcEmail\", ZC_EMAIL_DECL)\n            : null;\n          const regexVar = scanner === null ? g.regex(prefix, pattern, check.patternFlags) : null;\n          // Zod's invalid_format shape depends on WHICH check instance ran.\n          // `$ZodCheckStringFormat.init` installs the default pattern check with\n          // `??=`, and that default pushes `origin:\"string\"` + `pattern`. A\n          // constructor that OVERRIDES `inst._zod.check` pushes its own issue\n          // instead — `$ZodCustomStringFormat` (z.stringFormat/z.hex/z.hostname/\n          // z.hash) pushes a bare `{code, format, input}` because it validates\n          // through `def.fn` and never reads `def.pattern`. We test the pattern\n          // either way, so the issue shape is driven off the extracted flag.\n          let extra: string | undefined;\n          if (!check.bareIssue) {\n            // When emitRegex swapped in a faster equivalent pattern (or the\n            // scanner stands in for the RegExp), the runtime regex's toString()\n            // would leak the rewrite into the issue. Reference the shared\n            // original-pattern string instead (pattern came from RegExp.source,\n            // so it matches zod's `.toString()` byte-for-byte).\n            const rewritten = !check.patternFlags && fastTestSource(pattern) !== null;\n            const patternExpr =\n              rewritten || regexVar === null\n                ? emitRegexSourceString(g.ctx, pattern)\n                : `${regexVar}.toString()`;\n            extra = `pattern:${patternExpr}`;\n          }\n          const test =\n            regexVar === null ? `${scanner}(${g.input})` : `${regexVar}.test(${g.input})`;\n          code += emit`\n            ${regexVar === null ? \"\" : lastIndexReset(regexVar, check.patternFlags)}\n            if(!${test}){\n              ${invalidFormat(g, { expr: escapeString(check.format) }, { origin: check.bareIssue ? undefined : \"string\", extra, message: check.message })}\n            }`;\n          break;\n        }\n      }\n    }\n    code += `}`;\n  }\n\n  return `${code}\\n`;\n}\n\n/**\n * Boolean expression testing ONE compiled string check against `x`, or null when\n * the check is not expressible as a pure predicate (`z.url()`, which trims and\n * normalizes, and an unknown format with no pattern).\n *\n * Shared by the fast path — which sorts the checks cheapest-first and joins them\n * with `&&` — and by the build path, which emits them one statement at a time in\n * DECLARATION order so an interleaved `.trim()` rewrite is visible to the checks\n * that follow it (see buildString).\n */\nexport function fastStringCheck(check: CheckIR, x: string, ctx: CodeGenContext): string | null {\n  switch (check.kind) {\n    case \"min_length\":\n      return stringLengthTests.min(x, check.minimum, ctx);\n    case \"max_length\":\n      return stringLengthTests.max(x, check.maximum, ctx);\n    case \"length_equals\":\n      return stringLengthTests.equals(x, check.length, ctx);\n    case \"includes\":\n      return check.position !== undefined\n        ? `${x}.includes(${escapeString(check.includes)},${check.position})`\n        : `${x}.includes(${escapeString(check.includes)})`;\n    case \"starts_with\":\n      return `${x}.startsWith(${escapeString(check.prefix)})`;\n    case \"ends_with\":\n      return `${x}.endsWith(${escapeString(check.suffix)})`;\n    case \"string_format\": {\n      // URL validation rewrites the value (see isUrlRewrite) — not a predicate.\n      // A patterned \"url\" check is a custom format that borrowed the name, and\n      // its regex IS a predicate.\n      if (isUrlRewrite(check)) return null;\n      let pattern: string;\n      let prefix: string;\n      if (check.format === \"email\") {\n        prefix = \"email\";\n        pattern = check.pattern ?? EMAIL_REGEX_SOURCE;\n      } else if (check.format === \"uuid\") {\n        prefix = \"uuid\";\n        pattern = check.pattern ?? UUID_REGEX_SOURCE;\n      } else if (check.pattern) {\n        prefix = \"re\";\n        pattern = check.pattern;\n      } else {\n        // Unknown format without pattern — can't generate a check\n        return null;\n      }\n      // Zod's default email pattern runs as a linear scan instead of a RegExp\n      // (see ZC_EMAIL_DECL) — a plain call, so it needs no parens either.\n      if (isDefaultEmailPattern(pattern, check.patternFlags)) {\n        return `${emitRuntimeHelper(ctx, \"__zcEmail\", ZC_EMAIL_DECL)}(${x})`;\n      }\n      const v = emitRegex(ctx, prefix, pattern, check.patternFlags);\n      // Stateful (g/y) regexes need lastIndex reset; comma expression keeps\n      // this usable inside the boolean chain.\n      return check.patternFlags && /[gy]/.test(check.patternFlags)\n        ? `((${v}.lastIndex=0),${v}.test(${x}))`\n        : `${v}.test(${x})`;\n    }\n    default:\n      // A check kind this generator does not model (number/bigint/date/set\n      // shapes never reach here from a string node).\n      return null;\n  }\n}\n\nexport function fastString(ir: StringIR, g: FastGen): string | null {\n  if (ir.coerce) return null;\n  // Overwrite effects rewrite the value — the fast path returns input\n  // unchanged, so any mutation makes it ineligible.\n  if (ir.checks.some((c) => c.kind === \"overwrite_effect\")) return null;\n\n  const x = g.input;\n  const parts: string[] = [`typeof ${x}===\"string\"`];\n  const checks = ir.checks.filter(\n    (c): c is CheckIR => c.kind !== \"refine_effect\" && c.kind !== \"overwrite_effect\",\n  );\n\n  for (const check of checks.sort(checkPriority)) {\n    const expr = fastStringCheck(check, x, g.ctx);\n    if (expr === null) return null;\n    parts.push(expr);\n  }\n\n  // Refine effect checks (appended last — run after cheap checks short-circuit)\n  for (const check of ir.checks) {\n    if (check.kind === \"refine_effect\") {\n      parts.push(fastRefineTest(check, x, g));\n    } else if (check.kind === \"super_refine_effect\") {\n      parts.push(superRefineFastTest(check, x, g));\n    }\n  }\n\n  return parts.join(\"&&\");\n}\n"],"mappings":"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"}

package/dist/core/iife.d.ts

@@ -53,18 +53,17 @@ declare const ZOD_MSG_DECLARATION: string;
  * trace) — stays deferred inside the cached accessor exactly as before, since
  * the issues array is observable solely through `.error`.
  *
- * `input` is `delete`d, not assigned `undefined`. Key PRESENCE is observable —
- * `"input" in issue`, `Object.keys(issue)`, object spread, `toStrictEqual`
- * against a zod issue — and zod's `util.finalizeIssue` does `delete full.input`
- * whenever `reportInput` is off, so assignment left every compiled issue one
- * enumerable key wider than zod's. The delete's dictionary-mode transition is
- * affordable precisely BECAUSE of the deferral above: it runs only after a
- * caller asks for `.error` on a failed parse, and is memoised in `_c`. Neither
- * a successful parse nor a `.success`/`.is()` check on a rejected one reaches
- * it — measured, the two are unchanged, while the `.error` read itself goes
- * ~3.95us -> ~4.19us per failure, i.e. ~6% of a path whose cost is already
- * dominated by the ZodError construction on the next line (stack capture plus a
- * JSON.stringify of every issue).
+ * `input` and `continue` are left OUT, not assigned `undefined`. Key PRESENCE is
+ * observable — `"input" in issue`, `Object.keys(issue)`, object spread,
+ * `toStrictEqual` against a zod issue — and zod's `util.finalizeIssue` deletes
+ * `continue`, and `input` whenever `reportInput` is off, so assignment left every
+ * compiled issue one enumerable key wider than zod's. Each issue is COPIED
+ * without them rather than `delete`d from: removing a key that is not the last
+ * one added drops the object into V8's dictionary mode, ~70 ns an issue. `.error`
+ * over six issues went 1.49 -> 1.06 us, over one 653 -> 608 ns. The copy keeps
+ * key order and takes own keys only, so an enumerable key added to
+ * `Object.prototype` stays out, as it does from zod's spread. All of it runs only
+ * after a caller asks for `.error` on a failed parse, and is memoised in `_c`.
  */
 declare const FAIL_CLASS_DECL: string;
 /** Eager finalizer (mutation / partial-fast-path schemas): issues already

package/dist/core/iife.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"iife.d.ts","names":[],"sources":["../../src/core/iife.ts"],"mappings":";;;;;;;;cAca;;;;;;;;;;;;;;;;;;;;cAsBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8CA;;;cAUA;;;;;;;;;;;;;;;;;;;;;;;cAyBA;;;;;;;;;;;;;;;;;;;;;;;;;;cA2BA;;cAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAqGA;;;;;;;;;;;;;;;;;iBA6BG,iBAAiB,QAAQ;;;;;;;;;;;;;iBAgBzB,aACd,oBACA,QAAQ,oBACR;EAAY;EAAiC"}
+{"version":3,"file":"iife.d.ts","names":[],"sources":["../../src/core/iife.ts"],"mappings":";;;;;;;;cAca;;;;;;;;;;;;;;;;;;;;cAsBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA6CA;;;cAWA;;;;;;;;;;;;;;;;;;;;;;;cAyBA;;;;;;;;;;;;;;;;;;;;;;;;;;cA2BA;;cAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAqGA;;;;;;;;;;;;;;;;;iBA6BG,iBAAiB,QAAQ;;;;;;;;;;;;;iBAgBzB,aACd,oBACA,QAAQ,oBACR;EAAY;EAAiC"}

package/dist/core/iife.js

@@ -57,20 +57,19 @@ const ZOD_MSG_DECLARATION = "function __zcUw(m){return typeof m===\"string\"?m:(
 * trace) — stays deferred inside the cached accessor exactly as before, since
 * the issues array is observable solely through `.error`.
 *
-* `input` is `delete`d, not assigned `undefined`. Key PRESENCE is observable —
-* `"input" in issue`, `Object.keys(issue)`, object spread, `toStrictEqual`
-* against a zod issue — and zod's `util.finalizeIssue` does `delete full.input`
-* whenever `reportInput` is off, so assignment left every compiled issue one
-* enumerable key wider than zod's. The delete's dictionary-mode transition is
-* affordable precisely BECAUSE of the deferral above: it runs only after a
-* caller asks for `.error` on a failed parse, and is memoised in `_c`. Neither
-* a successful parse nor a `.success`/`.is()` check on a rejected one reaches
-* it — measured, the two are unchanged, while the `.error` read itself goes
-* ~3.95us -> ~4.19us per failure, i.e. ~6% of a path whose cost is already
-* dominated by the ZodError construction on the next line (stack capture plus a
-* JSON.stringify of every issue).
+* `input` and `continue` are left OUT, not assigned `undefined`. Key PRESENCE is
+* observable — `"input" in issue`, `Object.keys(issue)`, object spread,
+* `toStrictEqual` against a zod issue — and zod's `util.finalizeIssue` deletes
+* `continue`, and `input` whenever `reportInput` is off, so assignment left every
+* compiled issue one enumerable key wider than zod's. Each issue is COPIED
+* without them rather than `delete`d from: removing a key that is not the last
+* one added drops the object into V8's dictionary mode, ~70 ns an issue. `.error`
+* over six issues went 1.49 -> 1.06 us, over one 653 -> 608 ns. The copy keeps
+* key order and takes own keys only, so an enumerable key added to
+* `Object.prototype` stays out, as it does from zod's spread. All of it runs only
+* after a caller asks for `.error` on a failed parse, and is memoised in `_c`.
 */
-const FAIL_CLASS_DECL = "function __ZcFail(e,f,i){this.success=false;this._e=e;this._f=f;this._i=i;this._c=undefined;}Object.defineProperty(__ZcFail.prototype,\"error\",{configurable:true,get:function(){if(this._c)return this._c;var e=this._f!==null?this._f(this._i):this._e;for(var i=0;i<e.length;i++){if(e[i].message===undefined&&typeof __zcMsg===\"function\")e[i].message=__zcMsg(e[i]);delete e[i].input;delete e[i].continue;}return this._c=new __zcZodError(e);}});";
+const FAIL_CLASS_DECL = "function __ZcFail(e,f,i){this.success=false;this._e=e;this._f=f;this._i=i;this._c=undefined;}Object.defineProperty(__ZcFail.prototype,\"error\",{configurable:true,get:function(){if(this._c)return this._c;var e=this._f!==null?this._f(this._i):this._e;for(var i=0;i<e.length;i++){var s=e[i],o={},k;if(s.message===undefined&&typeof __zcMsg===\"function\")s.message=__zcMsg(s);for(k in s){if(k!==\"input\"&&k!==\"continue\"&&Object.prototype.hasOwnProperty.call(s,k))o[k]=s[k];}e[i]=o;}return this._c=new __zcZodError(e);}});";
 /** Eager finalizer (mutation / partial-fast-path schemas): issues already
 * collected in `e`; success short-circuits to a plain result literal. */
 const FIN_DECL = "function __zcFin(e,d){if(!e.length)return{success:true,data:d};return new __ZcFail(e,null,null);}";