zod-compiler 1.23.0 → 1.23.2

package/dist/core/codegen/regex-unroll.js

@@ -1,231 +1,207 @@
+//#region src/core/codegen/regex-unroll.ts
 /**
- * Bounded-repeat unrolling for `.test()` regexes.
- *
- * V8's irregexp compiles a counted quantifier (`[0-9a-fA-F]{12}`) into a
- * backtrack-capable loop carrying a counter register, but compiles the same
- * atom written out (`[0-9a-fA-F][0-9a-fA-F]…`) into straight-line matching
- * code. Rewriting one into the other is purely structural — the language the
- * pattern accepts is unchanged — and is worth a lot on exactly the string
- * formats everyday schemas lean on:
- *
- *   z.uuid()   3.1x    z.guid()   3.4x    z.ksuid()  2.7x
- *   z.xid()    2.2x    z.ulid()   2.1x    z.base64() 2.1x
- *   z.nanoid() 1.9x    z.e164()   1.5x    z.iso.date() 1.3x
- *
- * Measured on V8 13.x (node 24). The win starts at `{4}` (1.28x) and grows
- * with the count (2.7x at `{64}`); `{2}`/`{3}` are a wash, which is what
- * {@link MIN_REPEAT} encodes.
- *
- * The rewrite applies only to quantifiers whose atom is a SINGLE CHARACTER
- * matcher — a character class, an escape, or a literal character. A group's
- * repeat is left alone: unrolling it would duplicate capture groups and
- * renumber every backreference after it. Anything the scanner cannot account
- * for exactly makes the whole transform bail (`null`), leaving the original
- * pattern in place.
- *
- * Callers must keep reporting the ORIGINAL source in issues — the rewritten
- * regex's `toString()` would otherwise leak into `pattern:` and diverge from
- * zod. See `emitRegexSourceString`.
- */
+* Bounded-repeat unrolling for `.test()` regexes.
+*
+* V8's irregexp compiles a counted quantifier (`[0-9a-fA-F]{12}`) into a
+* backtrack-capable loop carrying a counter register, but compiles the same
+* atom written out (`[0-9a-fA-F][0-9a-fA-F]…`) into straight-line matching
+* code. Rewriting one into the other is purely structural — the language the
+* pattern accepts is unchanged — and is worth a lot on exactly the string
+* formats everyday schemas lean on:
+*
+*   z.uuid()   3.1x    z.guid()   3.4x    z.ksuid()  2.7x
+*   z.xid()    2.2x    z.ulid()   2.1x    z.base64() 2.1x
+*   z.nanoid() 1.9x    z.e164()   1.5x    z.iso.date() 1.3x
+*
+* Measured on V8 13.x (node 24). The win starts at `{4}` (1.28x) and grows
+* with the count (2.7x at `{64}`); `{2}`/`{3}` are a wash, which is what
+* {@link MIN_REPEAT} encodes.
+*
+* The rewrite applies only to quantifiers whose atom is a SINGLE CHARACTER
+* matcher — a character class, an escape, or a literal character. A group's
+* repeat is left alone: unrolling it would duplicate capture groups and
+* renumber every backreference after it. Anything the scanner cannot account
+* for exactly makes the whole transform bail (`null`), leaving the original
+* pattern in place.
+*
+* Callers must keep reporting the ORIGINAL source in issues — the rewritten
+* regex's `toString()` would otherwise leak into `pattern:` and diverge from
+* zod. See `emitRegexSourceString`.
+*/
 /**
- * Smallest mandatory repeat count worth unrolling. Below this the counter loop
- * and the straight-line form measure the same (0.97-1.00x), so leaving the
- * pattern untouched keeps generated output smaller for no speed cost.
- */
+* Smallest mandatory repeat count worth unrolling. Below this the counter loop
+* and the straight-line form measure the same (0.97-1.00x), so leaving the
+* pattern untouched keeps generated output smaller for no speed cost.
+*/
 const MIN_REPEAT = 4;
 /**
- * Largest repeat count unrolled. A `{500}` would expand to a pattern longer
- * than anything it could save, so it keeps the counter loop.
- */
+* Largest repeat count unrolled. A `{500}` would expand to a pattern longer
+* than anything it could save, so it keeps the counter loop.
+*/
 const MAX_REPEAT = 64;
 /** Largest `max - min` optional tail expanded (`{6,14}` → 6 copies + 8 `?` copies). */
 const MAX_OPTIONAL = 32;
 /**
- * Total characters the rewrite may add across a whole pattern. Once spent,
- * later quantifiers are copied verbatim — the rewrite degrades gradually
- * instead of failing, and emitted size stays bounded for hand-written patterns.
- */
-const GROWTH_BUDGET = 2_048;
+* Total characters the rewrite may add across a whole pattern. Once spent,
+* later quantifiers are copied verbatim — the rewrite degrades gradually
+* instead of failing, and emitted size stays bounded for hand-written patterns.
+*/
+const GROWTH_BUDGET = 2048;
 /** Characters that begin something other than a literal single-character atom. */
-const NON_ATOM = new Set(["^", "$", "|", "(", ")", "*", "+", "?"]);
+const NON_ATOM = /* @__PURE__ */ new Set([
+	"^",
+	"$",
+	"|",
+	"(",
+	")",
+	"*",
+	"+",
+	"?"
+]);
 /**
- * Rewrite bounded repeats of single-character atoms into explicit repetition.
- * Returns `null` when nothing changed or the pattern could not be scanned
- * exactly (in which case the caller keeps the original source).
- */
-export function unrollRepeats(source) {
-    let out = "";
-    let index = 0;
-    /** Offset in `out` where the most recent atom starts, or -1 when the preceding construct is not a single-character atom. */
-    let atomOffset = -1;
-    let budget = GROWTH_BUDGET;
-    let changed = false;
-    while (index < source.length) {
-        const char = source[index];
-        if (char === "\\") {
-            const end = readEscape(source, index);
-            if (end === null)
-                return null;
-            atomOffset = out.length;
-            out += source.slice(index, end);
-            index = end;
-            continue;
-        }
-        if (char === "[") {
-            const end = readClass(source, index);
-            if (end === null)
-                return null;
-            atomOffset = out.length;
-            out += source.slice(index, end);
-            index = end;
-            continue;
-        }
-        if (char === "{") {
-            const quantifier = readQuantifier(source, index);
-            if (quantifier !== null) {
-                const expansion = 
-                // A lazy quantifier (`{n,m}?`) prefers the shortest match; the
-                // unrolled form's `?` copies are greedy, so it is left alone.
-                source[quantifier.end] === "?" || atomOffset < 0
-                    ? null
-                    : expand(out.slice(atomOffset), quantifier, budget);
-                if (expansion === null) {
-                    out += source.slice(index, quantifier.end);
-                }
-                else {
-                    budget -= expansion.length - (out.length - atomOffset);
-                    out = out.slice(0, atomOffset) + expansion;
-                    changed = true;
-                }
-                // A quantifier cannot itself be quantified, so whatever follows starts
-                // a fresh atom.
-                atomOffset = -1;
-                index = quantifier.end;
-                continue;
-            }
-            // Not a valid quantifier — an unescaped `{` is a literal in Annex B.
-        }
-        atomOffset = NON_ATOM.has(char) || isSurrogate(char) ? -1 : out.length;
-        out += char;
-        index += 1;
-    }
-    return changed ? out : null;
+* Rewrite bounded repeats of single-character atoms into explicit repetition.
+* Returns `null` when nothing changed or the pattern could not be scanned
+* exactly (in which case the caller keeps the original source).
+*/
+function unrollRepeats(source) {
+	let out = "";
+	let index = 0;
+	/** Offset in `out` where the most recent atom starts, or -1 when the preceding construct is not a single-character atom. */
+	let atomOffset = -1;
+	let budget = GROWTH_BUDGET;
+	let changed = false;
+	while (index < source.length) {
+		const char = source[index];
+		if (char === "\\") {
+			const end = readEscape(source, index);
+			if (end === null) return null;
+			atomOffset = out.length;
+			out += source.slice(index, end);
+			index = end;
+			continue;
+		}
+		if (char === "[") {
+			const end = readClass(source, index);
+			if (end === null) return null;
+			atomOffset = out.length;
+			out += source.slice(index, end);
+			index = end;
+			continue;
+		}
+		if (char === "{") {
+			const quantifier = readQuantifier(source, index);
+			if (quantifier !== null) {
+				const expansion = source[quantifier.end] === "?" || atomOffset < 0 ? null : expand(out.slice(atomOffset), quantifier, budget);
+				if (expansion === null) out += source.slice(index, quantifier.end);
+				else {
+					budget -= expansion.length - (out.length - atomOffset);
+					out = out.slice(0, atomOffset) + expansion;
+					changed = true;
+				}
+				atomOffset = -1;
+				index = quantifier.end;
+				continue;
+			}
+		}
+		atomOffset = NON_ATOM.has(char) || isSurrogate(char) ? -1 : out.length;
+		out += char;
+		index += 1;
+	}
+	return changed ? out : null;
 }
 /** Repeated-atom form of `atom{min,max}`, or null when it is not worth (or safe to) expand. */
 function expand(atom, { min, max }, budget) {
-    if (min < MIN_REPEAT || min > MAX_REPEAT)
-        return null;
-    const optional = max === Infinity ? 0 : max - min;
-    if (optional > MAX_OPTIONAL)
-        return null;
-    const mandatory = atom.repeat(min);
-    const tail = max === Infinity ? `${atom}*` : `${atom}?`.repeat(optional);
-    const expansion = mandatory + tail;
-    // `atom{min,max}` is being replaced by `expansion`; charge the difference.
-    if (expansion.length - atom.length > budget)
-        return null;
-    return expansion;
+	if (min < MIN_REPEAT || min > MAX_REPEAT) return null;
+	const optional = max === Infinity ? 0 : max - min;
+	if (optional > MAX_OPTIONAL) return null;
+	const expansion = atom.repeat(min) + (max === Infinity ? `${atom}*` : `${atom}?`.repeat(optional));
+	if (expansion.length - atom.length > budget) return null;
+	return expansion;
 }
 /** True for a lone UTF-16 surrogate code unit, which is never treated as its own atom. */
 function isSurrogate(char) {
-    const code = char.charCodeAt(0);
-    return code >= 0xd8_00 && code <= 0xdf_ff;
+	const code = char.charCodeAt(0);
+	return code >= 55296 && code <= 57343;
 }
 /**
- * End offset (exclusive) of the escape sequence starting at `start`, or null
- * when the sequence is not one whose extent is unambiguous.
- *
- * Everything here hinges on the caller only passing FLAG-LESS patterns, where
- * Annex B's "identity escape" fallback makes several sequences mean something
- * other than they would under `u`: `\p{L}` is the letter `p` followed by three
- * literal characters, not a property escape, and `\uZZZZ` is `u` followed by
- * four literal `Z`s. Consuming those as one atom would attach a following
- * quantifier to the wrong character, so the well-formed fixed-width escapes
- * are recognised exactly and every ambiguous form bails.
- */
+* End offset (exclusive) of the escape sequence starting at `start`, or null
+* when the sequence is not one whose extent is unambiguous.
+*
+* Everything here hinges on the caller only passing FLAG-LESS patterns, where
+* Annex B's "identity escape" fallback makes several sequences mean something
+* other than they would under `u`: `\p{L}` is the letter `p` followed by three
+* literal characters, not a property escape, and `\uZZZZ` is `u` followed by
+* four literal `Z`s. Consuming those as one atom would attach a following
+* quantifier to the wrong character, so the well-formed fixed-width escapes
+* are recognised exactly and every ambiguous form bails.
+*/
 function readEscape(source, start) {
-    const next = source[start + 1];
-    if (next === undefined)
-        return null;
-    // Property escapes and named backreferences read differently with and
-    // without the `u` flag — never worth resolving for the sake of a rewrite.
-    if (next === "p" || next === "P" || next === "k")
-        return null;
-    // `\12` may be backreference 12 or backreference 1 followed by a literal 2,
-    // depending on how many groups the pattern has.
-    if (next >= "0" && next <= "9") {
-        const after = source[start + 2];
-        return after !== undefined && after >= "0" && after <= "9" ? null : start + 2;
-    }
-    if (next === "u")
-        return fixedWidth(source, start, 4, isHexDigit);
-    if (next === "x")
-        return fixedWidth(source, start, 2, isHexDigit);
-    if (next === "c")
-        return fixedWidth(source, start, 1, isAsciiLetter);
-    // Character-class escapes (`\d`, `\w`, `\s`), control escapes (`\n`, `\t`)
-    // and identity escapes (`\.`, `\\`, `\{`) are all one character wide.
-    return start + 2;
+	const next = source[start + 1];
+	if (next === void 0) return null;
+	if (next === "p" || next === "P" || next === "k") return null;
+	if (next >= "0" && next <= "9") {
+		const after = source[start + 2];
+		return after !== void 0 && after >= "0" && after <= "9" ? null : start + 2;
+	}
+	if (next === "u") return fixedWidth(source, start, 4, isHexDigit);
+	if (next === "x") return fixedWidth(source, start, 2, isHexDigit);
+	if (next === "c") return fixedWidth(source, start, 1, isAsciiLetter);
+	return start + 2;
 }
 /** End offset of `\<kind>` plus exactly `width` chars satisfying `valid`, or null. */
 function fixedWidth(source, start, width, valid) {
-    const end = start + 2 + width;
-    if (end > source.length)
-        return null;
-    for (let index = start + 2; index < end; index++) {
-        if (!valid(source[index]))
-            return null;
-    }
-    return end;
+	const end = start + 2 + width;
+	if (end > source.length) return null;
+	for (let index = start + 2; index < end; index++) if (!valid(source[index])) return null;
+	return end;
 }
 function isHexDigit(char) {
-    return /[0-9a-fA-F]/.test(char);
+	return /[0-9a-fA-F]/.test(char);
 }
 function isAsciiLetter(char) {
-    return /[a-zA-Z]/.test(char);
+	return /[a-zA-Z]/.test(char);
 }
 /**
- * End offset (exclusive) of the character class starting at `start`, or null
- * when unterminated. The first unescaped `]` closes the class — `[]]` is an
- * empty class followed by a literal `]`, not a class containing `]`.
- */
+* End offset (exclusive) of the character class starting at `start`, or null
+* when unterminated. The first unescaped `]` closes the class — `[]]` is an
+* empty class followed by a literal `]`, not a class containing `]`.
+*/
 function readClass(source, start) {
-    let index = start + 1;
-    if (source[index] === "^")
-        index += 1;
-    while (index < source.length) {
-        const char = source[index];
-        if (char === "\\") {
-            const end = readEscape(source, index);
-            if (end === null)
-                return null;
-            index = end;
-            continue;
-        }
-        // A `v`-mode nested class would need its own nesting rules; callers only
-        // pass flag-less patterns, where `[` inside a class is a literal.
-        if (char === "]")
-            return index + 1;
-        index += 1;
-    }
-    return null;
+	let index = start + 1;
+	if (source[index] === "^") index += 1;
+	while (index < source.length) {
+		const char = source[index];
+		if (char === "\\") {
+			const end = readEscape(source, index);
+			if (end === null) return null;
+			index = end;
+			continue;
+		}
+		if (char === "]") return index + 1;
+		index += 1;
+	}
+	return null;
 }
 /**
- * Parse `{n}`, `{n,}` or `{n,m}` at `start`. Returns null when the braces do
- * not form a quantifier, which Annex B treats as literal `{` characters.
- */
+* Parse `{n}`, `{n,}` or `{n,m}` at `start`. Returns null when the braces do
+* not form a quantifier, which Annex B treats as literal `{` characters.
+*/
 function readQuantifier(source, start) {
-    const close = source.indexOf("}", start);
-    if (close === -1)
-        return null;
-    const body = source.slice(start + 1, close);
-    const match = /^(\d+)(?:,(\d*))?$/.exec(body);
-    if (!match)
-        return null;
-    const min = Number(match[1]);
-    const max = match[2] === undefined ? min : match[2] === "" ? Infinity : Number(match[2]);
-    if (max < min)
-        return null;
-    return { end: close + 1, max, min };
+	const close = source.indexOf("}", start);
+	if (close === -1) return null;
+	const body = source.slice(start + 1, close);
+	const match = /^(\d+)(?:,(\d*))?$/.exec(body);
+	if (!match) return null;
+	const min = Number(match[1]);
+	const max = match[2] === void 0 ? min : match[2] === "" ? Infinity : Number(match[2]);
+	if (max < min) return null;
+	return {
+		end: close + 1,
+		max,
+		min
+	};
 }
+//#endregion
+export { unrollRepeats };
+
 //# sourceMappingURL=regex-unroll.js.map

package/dist/core/codegen/regex-unroll.js.map

@@ -1 +1 @@
-{"version":3,"file":"regex-unroll.js","sourceRoot":"","sources":["../../../src/core/codegen/regex-unroll.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"regex-unroll.js","names":[],"sources":["../../../src/core/codegen/regex-unroll.ts"],"sourcesContent":["/**\n * Bounded-repeat unrolling for `.test()` regexes.\n *\n * V8's irregexp compiles a counted quantifier (`[0-9a-fA-F]{12}`) into a\n * backtrack-capable loop carrying a counter register, but compiles the same\n * atom written out (`[0-9a-fA-F][0-9a-fA-F]…`) into straight-line matching\n * code. Rewriting one into the other is purely structural — the language the\n * pattern accepts is unchanged — and is worth a lot on exactly the string\n * formats everyday schemas lean on:\n *\n *   z.uuid()   3.1x    z.guid()   3.4x    z.ksuid()  2.7x\n *   z.xid()    2.2x    z.ulid()   2.1x    z.base64() 2.1x\n *   z.nanoid() 1.9x    z.e164()   1.5x    z.iso.date() 1.3x\n *\n * Measured on V8 13.x (node 24). The win starts at `{4}` (1.28x) and grows\n * with the count (2.7x at `{64}`); `{2}`/`{3}` are a wash, which is what\n * {@link MIN_REPEAT} encodes.\n *\n * The rewrite applies only to quantifiers whose atom is a SINGLE CHARACTER\n * matcher — a character class, an escape, or a literal character. A group's\n * repeat is left alone: unrolling it would duplicate capture groups and\n * renumber every backreference after it. Anything the scanner cannot account\n * for exactly makes the whole transform bail (`null`), leaving the original\n * pattern in place.\n *\n * Callers must keep reporting the ORIGINAL source in issues — the rewritten\n * regex's `toString()` would otherwise leak into `pattern:` and diverge from\n * zod. See `emitRegexSourceString`.\n */\n\n/**\n * Smallest mandatory repeat count worth unrolling. Below this the counter loop\n * and the straight-line form measure the same (0.97-1.00x), so leaving the\n * pattern untouched keeps generated output smaller for no speed cost.\n */\nconst MIN_REPEAT = 4;\n\n/**\n * Largest repeat count unrolled. A `{500}` would expand to a pattern longer\n * than anything it could save, so it keeps the counter loop.\n */\nconst MAX_REPEAT = 64;\n\n/** Largest `max - min` optional tail expanded (`{6,14}` → 6 copies + 8 `?` copies). */\nconst MAX_OPTIONAL = 32;\n\n/**\n * Total characters the rewrite may add across a whole pattern. Once spent,\n * later quantifiers are copied verbatim — the rewrite degrades gradually\n * instead of failing, and emitted size stays bounded for hand-written patterns.\n */\nconst GROWTH_BUDGET = 2_048;\n\n/** Characters that begin something other than a literal single-character atom. */\nconst NON_ATOM = new Set([\"^\", \"$\", \"|\", \"(\", \")\", \"*\", \"+\", \"?\"]);\n\n/**\n * Rewrite bounded repeats of single-character atoms into explicit repetition.\n * Returns `null` when nothing changed or the pattern could not be scanned\n * exactly (in which case the caller keeps the original source).\n */\nexport function unrollRepeats(source: string): string | null {\n  let out = \"\";\n  let index = 0;\n  /** Offset in `out` where the most recent atom starts, or -1 when the preceding construct is not a single-character atom. */\n  let atomOffset = -1;\n  let budget = GROWTH_BUDGET;\n  let changed = false;\n\n  while (index < source.length) {\n    const char = source[index] as string;\n\n    if (char === \"\\\\\") {\n      const end = readEscape(source, index);\n      if (end === null) return null;\n      atomOffset = out.length;\n      out += source.slice(index, end);\n      index = end;\n      continue;\n    }\n\n    if (char === \"[\") {\n      const end = readClass(source, index);\n      if (end === null) return null;\n      atomOffset = out.length;\n      out += source.slice(index, end);\n      index = end;\n      continue;\n    }\n\n    if (char === \"{\") {\n      const quantifier = readQuantifier(source, index);\n      if (quantifier !== null) {\n        const expansion =\n          // A lazy quantifier (`{n,m}?`) prefers the shortest match; the\n          // unrolled form's `?` copies are greedy, so it is left alone.\n          source[quantifier.end] === \"?\" || atomOffset < 0\n            ? null\n            : expand(out.slice(atomOffset), quantifier, budget);\n        if (expansion === null) {\n          out += source.slice(index, quantifier.end);\n        } else {\n          budget -= expansion.length - (out.length - atomOffset);\n          out = out.slice(0, atomOffset) + expansion;\n          changed = true;\n        }\n        // A quantifier cannot itself be quantified, so whatever follows starts\n        // a fresh atom.\n        atomOffset = -1;\n        index = quantifier.end;\n        continue;\n      }\n      // Not a valid quantifier — an unescaped `{` is a literal in Annex B.\n    }\n\n    atomOffset = NON_ATOM.has(char) || isSurrogate(char) ? -1 : out.length;\n    out += char;\n    index += 1;\n  }\n\n  return changed ? out : null;\n}\n\n/** Repeated-atom form of `atom{min,max}`, or null when it is not worth (or safe to) expand. */\nfunction expand(\n  atom: string,\n  { min, max }: { max: number; min: number },\n  budget: number,\n): string | null {\n  if (min < MIN_REPEAT || min > MAX_REPEAT) return null;\n  const optional = max === Infinity ? 0 : max - min;\n  if (optional > MAX_OPTIONAL) return null;\n  const mandatory = atom.repeat(min);\n  const tail = max === Infinity ? `${atom}*` : `${atom}?`.repeat(optional);\n  const expansion = mandatory + tail;\n  // `atom{min,max}` is being replaced by `expansion`; charge the difference.\n  if (expansion.length - atom.length > budget) return null;\n  return expansion;\n}\n\n/** True for a lone UTF-16 surrogate code unit, which is never treated as its own atom. */\nfunction isSurrogate(char: string): boolean {\n  const code = char.charCodeAt(0);\n  return code >= 0xd8_00 && code <= 0xdf_ff;\n}\n\n/**\n * End offset (exclusive) of the escape sequence starting at `start`, or null\n * when the sequence is not one whose extent is unambiguous.\n *\n * Everything here hinges on the caller only passing FLAG-LESS patterns, where\n * Annex B's \"identity escape\" fallback makes several sequences mean something\n * other than they would under `u`: `\\p{L}` is the letter `p` followed by three\n * literal characters, not a property escape, and `\\uZZZZ` is `u` followed by\n * four literal `Z`s. Consuming those as one atom would attach a following\n * quantifier to the wrong character, so the well-formed fixed-width escapes\n * are recognised exactly and every ambiguous form bails.\n */\nfunction readEscape(source: string, start: number): number | null {\n  const next = source[start + 1];\n  if (next === undefined) return null;\n\n  // Property escapes and named backreferences read differently with and\n  // without the `u` flag — never worth resolving for the sake of a rewrite.\n  if (next === \"p\" || next === \"P\" || next === \"k\") return null;\n\n  // `\\12` may be backreference 12 or backreference 1 followed by a literal 2,\n  // depending on how many groups the pattern has.\n  if (next >= \"0\" && next <= \"9\") {\n    const after = source[start + 2];\n    return after !== undefined && after >= \"0\" && after <= \"9\" ? null : start + 2;\n  }\n\n  if (next === \"u\") return fixedWidth(source, start, 4, isHexDigit);\n  if (next === \"x\") return fixedWidth(source, start, 2, isHexDigit);\n  if (next === \"c\") return fixedWidth(source, start, 1, isAsciiLetter);\n\n  // Character-class escapes (`\\d`, `\\w`, `\\s`), control escapes (`\\n`, `\\t`)\n  // and identity escapes (`\\.`, `\\\\`, `\\{`) are all one character wide.\n  return start + 2;\n}\n\n/** End offset of `\\<kind>` plus exactly `width` chars satisfying `valid`, or null. */\nfunction fixedWidth(\n  source: string,\n  start: number,\n  width: number,\n  valid: (char: string) => boolean,\n): number | null {\n  const end = start + 2 + width;\n  if (end > source.length) return null;\n  for (let index = start + 2; index < end; index++) {\n    if (!valid(source[index] as string)) return null;\n  }\n  return end;\n}\n\nfunction isHexDigit(char: string): boolean {\n  return /[0-9a-fA-F]/.test(char);\n}\n\nfunction isAsciiLetter(char: string): boolean {\n  return /[a-zA-Z]/.test(char);\n}\n\n/**\n * End offset (exclusive) of the character class starting at `start`, or null\n * when unterminated. The first unescaped `]` closes the class — `[]]` is an\n * empty class followed by a literal `]`, not a class containing `]`.\n */\nfunction readClass(source: string, start: number): number | null {\n  let index = start + 1;\n  if (source[index] === \"^\") index += 1;\n  while (index < source.length) {\n    const char = source[index];\n    if (char === \"\\\\\") {\n      const end = readEscape(source, index);\n      if (end === null) return null;\n      index = end;\n      continue;\n    }\n    // A `v`-mode nested class would need its own nesting rules; callers only\n    // pass flag-less patterns, where `[` inside a class is a literal.\n    if (char === \"]\") return index + 1;\n    index += 1;\n  }\n  return null;\n}\n\n/**\n * Parse `{n}`, `{n,}` or `{n,m}` at `start`. Returns null when the braces do\n * not form a quantifier, which Annex B treats as literal `{` characters.\n */\nfunction readQuantifier(\n  source: string,\n  start: number,\n): { end: number; max: number; min: number } | null {\n  const close = source.indexOf(\"}\", start);\n  if (close === -1) return null;\n  const body = source.slice(start + 1, close);\n  const match = /^(\\d+)(?:,(\\d*))?$/.exec(body);\n  if (!match) return null;\n  const min = Number(match[1]);\n  const max =\n    match[2] === undefined ? min : match[2] === \"\" ? Infinity : Number(match[2] as string);\n  if (max < min) return null;\n  return { end: close + 1, max, min };\n}\n"],"mappings":"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"}

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

@@ -1,5 +1,8 @@
-import type { AnyIR } from "../../types.js";
-import type { FastGen, SlowGen } from "../context.js";
-export declare function slowAny(_ir: AnyIR, _g: SlowGen): string;
-export declare function fastAny(_ir: AnyIR, _g: FastGen): string | null;
+import { AnyIR } from "../../types.js";
+import { FastGen, SlowGen } from "../context.js";
+//#region src/core/codegen/schemas/any.d.ts
+declare function slowAny(_ir: AnyIR, _g: SlowGen): string;
+declare function fastAny(_ir: AnyIR, _g: FastGen): string | null;
+//#endregion
+export { fastAny, slowAny };
 //# sourceMappingURL=any.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"any.d.ts","sourceRoot":"","sources":["../../../../src/core/codegen/schemas/any.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAEtD,wBAAgB,OAAO,CAAC,GAAG,EAAE,KAAK,EAAE,EAAE,EAAE,OAAO,GAAG,MAAM,CAEvD;AAED,wBAAgB,OAAO,CAAC,GAAG,EAAE,KAAK,EAAE,EAAE,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAE9D"}
+{"version":3,"file":"any.d.ts","names":[],"sources":["../../../../src/core/codegen/schemas/any.ts"],"mappings":";;;iBAGgB,QAAQ,KAAK,OAAO,IAAI;iBAIxB,QAAQ,KAAK,OAAO,IAAI"}

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

@@ -1,7 +1,11 @@
-export function slowAny(_ir, _g) {
-    return "";
+//#region src/core/codegen/schemas/any.ts
+function slowAny(_ir, _g) {
+	return "";
 }
-export function fastAny(_ir, _g) {
-    return "true";
+function fastAny(_ir, _g) {
+	return "true";
 }
+//#endregion
+export { fastAny, slowAny };
+
 //# sourceMappingURL=any.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"any.js","sourceRoot":"","sources":["../../../../src/core/codegen/schemas/any.ts"],"names":[],"mappings":"AAGA,MAAM,UAAU,OAAO,CAAC,GAAU,EAAE,EAAW;IAC7C,OAAO,EAAE,CAAC;AACZ,CAAC;AAED,MAAM,UAAU,OAAO,CAAC,GAAU,EAAE,EAAW;IAC7C,OAAO,MAAM,CAAC;AAChB,CAAC"}
+{"version":3,"file":"any.js","names":[],"sources":["../../../../src/core/codegen/schemas/any.ts"],"sourcesContent":["import type { AnyIR } from \"../../types.js\";\nimport type { FastGen, SlowGen } from \"../context.js\";\n\nexport function slowAny(_ir: AnyIR, _g: SlowGen): string {\n  return \"\";\n}\n\nexport function fastAny(_ir: AnyIR, _g: FastGen): string | null {\n  return \"true\";\n}\n"],"mappings":";AAGA,SAAgB,QAAQ,KAAY,IAAqB;CACvD,OAAO;AACT;AAEA,SAAgB,QAAQ,KAAY,IAA4B;CAC9D,OAAO;AACT"}

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

@@ -1,7 +1,10 @@
-import type { ArrayIR, SchemaIR } from "../../types.js";
-import type { FastGen, SlowGen } from "../context.js";
-export declare function slowArray(ir: SchemaIR & {
-    type: "array";
+import { ArrayIR, SchemaIR } from "../../types.js";
+import { FastGen, SlowGen } from "../context.js";
+//#region src/core/codegen/schemas/array.d.ts
+declare function slowArray(ir: SchemaIR & {
+  type: "array";
 }, g: SlowGen): string;
-export declare function fastArray(ir: ArrayIR, g: FastGen): string | null;
+declare function fastArray(ir: ArrayIR, g: FastGen): string | null;
+//#endregion
+export { fastArray, slowArray };
 //# sourceMappingURL=array.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../../../../src/core/codegen/schemas/array.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAW,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AACjE,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AActD,wBAAgB,SAAS,CAAC,EAAE,EAAE,QAAQ,GAAG;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,EAAE,CAAC,EAAE,OAAO,GAAG,MAAM,CA4E9E;AAED,wBAAgB,SAAS,CAAC,EAAE,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CA4ChE"}
+{"version":3,"file":"array.d.ts","names":[],"sources":["../../../../src/core/codegen/schemas/array.ts"],"mappings":";;;iBAegB,UAAU,IAAI;EAAa;GAAiB,GAAG;iBA8E/C,UAAU,IAAI,SAAS,GAAG"}