parseman 0.15.0 → 0.16.0

package/dist/index.js

@@ -261,12 +261,16 @@ function pushTriviaLogEntry(ctx, start, end, kindIndex) {
 }
 
 // src/combinators/literal.ts
-var _collatorCache = null;
-function collator() {
-  if (_collatorCache === null) {
-    _collatorCache = new Intl.Collator(void 0, { sensitivity: "accent" });
+function asciiFoldEq(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    let ca = a.charCodeAt(i);
+    let cb = b.charCodeAt(i);
+    if (ca >= 65 && ca <= 90) ca += 32;
+    if (cb >= 65 && cb <= 90) cb += 32;
+    if (ca !== cb) return false;
   }
-  return _collatorCache;
+  return true;
 }
 function literal(value, opts = {}) {
   const caseInsensitive = opts.caseInsensitive ?? false;
@@ -281,8 +285,9 @@ function literal(value, opts = {}) {
     const lower = value.toLowerCase();
     const firstUpper = upper.codePointAt(0);
     const firstLower = lower.codePointAt(0);
-    meta.firstSet = firstLower !== void 0 && firstUpper !== void 0 ? { kind: "ranges", ranges: [
-      { lo: Math.min(firstLower, firstUpper), hi: Math.max(firstLower, firstUpper) }
+    meta.firstSet = firstLower !== void 0 && firstUpper !== void 0 ? firstLower === firstUpper ? { kind: "ranges", ranges: [{ lo: firstLower, hi: firstLower }] } : { kind: "ranges", ranges: [
+      { lo: firstLower, hi: firstLower },
+      { lo: firstUpper, hi: firstUpper }
     ] } : firstSet;
   }
   return {
@@ -295,7 +300,7 @@ function literal(value, opts = {}) {
         return failAt(ctx, [JSON.stringify(value)], pos);
       }
       const slice = input.slice(pos, end);
-      const matched = caseInsensitive ? collator().compare(slice, value) === 0 : slice === value;
+      const matched = caseInsensitive ? asciiFoldEq(slice, value) : slice === value;
       if (matched) {
         const span = { start: pos, end };
         const leaf = { _tag: "leaf", value: slice, span };
@@ -1629,8 +1634,8 @@ function classToRanges(cls) {
   return parseClassRanges(body);
 }
 var foldEq = (cVar, cp) => {
-  if (cp >= 65 && cp <= 90) return `(${cVar} === ${cp} || ${cVar} === ${cp + 32})`;
-  if (cp >= 97 && cp <= 122) return `(${cVar} === ${cp} || ${cVar} === ${cp - 32})`;
+  if (cp >= 65 && cp <= 90) return `(${cVar} | 32) === ${cp + 32}`;
+  if (cp >= 97 && cp <= 122) return `(${cVar} | 32) === ${cp}`;
   return `${cVar} === ${cp}`;
 };
 function literalCodePoints(frag) {
@@ -1881,6 +1886,12 @@ function firstSetsDisjoint(a, b) {
   return classDisjoint(a, b);
 }
 function fixedClassSeq(shape) {
+  if (shape.kind === "litFold") {
+    return shape.open.map((cp) => {
+      const other = cp >= 65 && cp <= 90 ? cp + 32 : cp >= 97 && cp <= 122 ? cp - 32 : cp;
+      return other === cp ? { ranges: [[cp, cp]], negated: false } : { ranges: [[Math.min(cp, other), Math.min(cp, other)], [Math.max(cp, other), Math.max(cp, other)]], negated: false };
+    });
+  }
   if (shape.kind !== "seq") return null;
   const out = [];
   for (const p of shape.parts) {
@@ -2302,12 +2313,34 @@ function parseScanShapeCore(source) {
 }
 function scanShapeFromRegex(source, flags) {
   if (/[msu]/.test(flags)) return null;
-  if (/i/.test(flags)) {
-    const open = literalCodePoints(source);
-    return open ? { kind: "litFold", open } : null;
-  }
+  if (/i/.test(flags)) return caseFoldShape(source);
   return parseScanShape(source);
 }
+function caseFoldShape(source) {
+  const la = stripTrailingLookahead(source);
+  if (la) {
+    const inner = caseFoldLiteralOrAlt(la.base);
+    if (!inner) return null;
+    const operand = { ranges: la.ranges, negated: la.classNegated };
+    if (!lookaheadUnambiguous(inner, operand, la.negative)) return null;
+    return { kind: "lookahead", inner, ranges: la.ranges, classNegated: la.classNegated, negative: la.negative };
+  }
+  return caseFoldLiteralOrAlt(source);
+}
+function caseFoldLiteralOrAlt(source) {
+  const asciiOnly = (cps) => cps.every((cp) => cp <= 127);
+  const open = literalCodePoints(source);
+  if (open) return asciiOnly(open) ? { kind: "litFold", open } : null;
+  const arms = splitTopLevelAlternation(source);
+  if (!arms || arms.length < 2) return null;
+  const litArms = [];
+  for (const arm of arms) {
+    const cp = literalCodePoints(arm);
+    if (!cp || !asciiOnly(cp)) return null;
+    litArms.push({ kind: "litFold", open: cp });
+  }
+  return { kind: "alt", arms: litArms, disjoint: false, firsts: litArms.map(() => null) };
+}
 var classCond = (cVar, ranges) => ranges.map(([lo, hi]) => lo === hi ? `${cVar} === ${lo}` : `(${cVar} >= ${lo} && ${cVar} <= ${hi})`).join(" || ");
 var litCond = (base, cps, firstVar) => cps.map(
   (cp, k) => k === 0 && firstVar ? `${firstVar} === ${cp}` : `input.charCodeAt(${base}${k ? ` + ${k}` : ""}) === ${cp}`
@@ -2319,6 +2352,25 @@ function stringHardStop(shape) {
   );
 }
 var codeAt = (start, firstChar) => firstChar ?? `input.charCodeAt(${start})`;
+var ALT_SWITCH_RANGE_LIMIT = 4;
+var ALT_SWITCH_MAX_CASES = 48;
+var ALT_SWITCH_MIN_CASES = 3;
+function planAltSwitch(firsts) {
+  const cases = [];
+  let total = 0;
+  for (const fs of firsts) {
+    if (!fs || fs.negated) return { kind: "if" };
+    const pts = [];
+    for (const [lo, hi] of fs.ranges) {
+      if (hi - lo + 1 > ALT_SWITCH_RANGE_LIMIT) return { kind: "if" };
+      for (let cp = lo; cp <= hi; cp++) pts.push(cp);
+    }
+    total += pts.length;
+    if (total > ALT_SWITCH_MAX_CASES) return { kind: "if" };
+    cases.push(pts);
+  }
+  return total >= ALT_SWITCH_MIN_CASES ? { kind: "switch", cases } : { kind: "if" };
+}
 function emitShapeMatch(shape, start, mint, ind2, firstChar) {
   if (shape.kind === "lookahead") {
     const inner = emitShapeMatch(shape.inner, start, mint, ind2, firstChar);
@@ -2343,18 +2395,57 @@ function emitShapeMatch(shape, start, mint, ind2, firstChar) {
     const okV = mint("_ok");
     const endV2 = mint("_end");
     const lines = [`${ind2}let ${okV} = false`, `${ind2}let ${endV2} = ${start}`];
+    if (shape.arms.length >= 2 && shape.arms.every((a) => a.kind === "litFold" && a.open.length >= 1)) {
+      const groups = /* @__PURE__ */ new Map();
+      for (const a of shape.arms) {
+        const open = a.open;
+        const f = open[0];
+        const lower = f >= 65 && f <= 90 ? f + 32 : f;
+        (groups.get(lower) ?? groups.set(lower, []).get(lower)).push(open);
+      }
+      lines.push(`${ind2}if (${start} < input.length) switch (${codeAt(start, firstChar)}) {`);
+      for (const [lower, arms] of groups) {
+        const labels = lower >= 97 && lower <= 122 ? `case ${lower}: case ${lower - 32}:` : `case ${lower}:`;
+        lines.push(`${ind2}  ${labels} {`);
+        for (const open of arms) {
+          const tail = open.slice(1).map((cp, i) => foldEq(`input.charCodeAt(${start} + ${i + 1})`, cp));
+          const cond = tail.length ? ` && ${tail.join(" && ")}` : "";
+          lines.push(`${ind2}    if (${start} + ${open.length} <= input.length${cond}) { ${okV} = true; ${endV2} = ${start} + ${open.length}; break }`);
+        }
+        lines.push(`${ind2}    break`);
+        lines.push(`${ind2}  }`);
+      }
+      lines.push(`${ind2}}`);
+      return { setup: lines, ok: okV, end: endV2 };
+    }
     if (shape.disjoint) {
-      const c0 = codeAt(start, firstChar);
-      shape.arms.forEach((arm, k) => {
-        const fs = shape.firsts[k];
-        const cond = fs.negated ? `!(${classCond(c0, fs.ranges)})` : `(${classCond(c0, fs.ranges)})`;
-        const m = emitShapeMatch(arm, start, mint, `${ind2}  `, firstChar);
-        lines.push(`${ind2}${k === 0 ? "if" : "else if"} (${start} < input.length && ${cond}) {`);
-        lines.push(...m.setup);
-        lines.push(`${ind2}  ${okV} = ${m.ok}`);
-        lines.push(`${ind2}  ${endV2} = ${m.ok} ? ${m.end} : ${start}`);
+      const plan = planAltSwitch(shape.firsts);
+      if (plan.kind === "switch") {
+        lines.push(`${ind2}if (${start} < input.length) switch (${codeAt(start, firstChar)}) {`);
+        shape.arms.forEach((arm, k) => {
+          const labels = plan.cases[k].map((cp) => `case ${cp}:`).join(" ");
+          const m = emitShapeMatch(arm, start, mint, `${ind2}    `, firstChar);
+          lines.push(`${ind2}  ${labels} {`);
+          lines.push(...m.setup);
+          lines.push(`${ind2}    ${okV} = ${m.ok}`);
+          lines.push(`${ind2}    ${endV2} = ${m.ok} ? ${m.end} : ${start}`);
+          lines.push(`${ind2}    break`);
+          lines.push(`${ind2}  }`);
+        });
         lines.push(`${ind2}}`);
-      });
+      } else {
+        const c0 = codeAt(start, firstChar);
+        shape.arms.forEach((arm, k) => {
+          const fs = shape.firsts[k];
+          const cond = fs.negated ? `!(${classCond(c0, fs.ranges)})` : `(${classCond(c0, fs.ranges)})`;
+          const m = emitShapeMatch(arm, start, mint, `${ind2}  `, firstChar);
+          lines.push(`${ind2}${k === 0 ? "if" : "else if"} (${start} < input.length && ${cond}) {`);
+          lines.push(...m.setup);
+          lines.push(`${ind2}  ${okV} = ${m.ok}`);
+          lines.push(`${ind2}  ${endV2} = ${m.ok} ? ${m.end} : ${start}`);
+          lines.push(`${ind2}}`);
+        });
+      }
     } else {
       const lbl = mint("_alt");
       lines.push(`${ind2}${lbl}: {`);
@@ -2842,6 +2933,8 @@ function tryInlineDestructureTransform(src, valueVars) {
 }
 
 // src/compiler/codegen.ts
+var HOST_READS_DECL = "const _hostReads = (b, n) => { if (b === undefined) return false; let s; try { s = Function.prototype.toString.call(b) } catch (e) { return true } if (/\\barguments\\b/.test(s)) return true; const m = /^[^(]*\\(([\\s\\S]*?)\\)/.exec(s); if (m && /\\.\\.\\.|=/.test(m[1])) return true; return b.length > n }";
+var _loweringSink = null;
 function v(ctx, prefix = "_v") {
   return `${prefix}${ctx.vars++}`;
 }
@@ -3240,13 +3333,14 @@ function emitLit(def, ctx, pos) {
   const vv = v(ctx);
   const expectedStr = JSON.stringify(JSON.stringify(value));
   const stmts = [];
-  if (caseInsensitive) {
-    ctx.needsCollator = true;
+  if (caseInsensitive && len > 0) {
+    const match = Array.from(
+      { length: len },
+      (_, i) => `(${foldEq(`input.charCodeAt(${pos}${i > 0 ? ` + ${i}` : ""})`, value.charCodeAt(i))})`
+    ).join(" && ");
     stmts.push(
-      ...emitIfFail(ctx, `${pos} + ${len} > input.length`, failBody(ctx, expectedStr, pos)),
-      `${ind(ctx)}const ${vv}_s = input.slice(${pos}, ${pos} + ${len})`,
-      ...emitIfFail(ctx, `_collator.compare(${vv}_s, ${JSON.stringify(value)}) !== 0`, failBody(ctx, expectedStr, pos)),
-      `${ind(ctx)}const ${vv} = ${vv}_s`
+      ...emitIfFail(ctx, `${pos} + ${len} > input.length || !(${match})`, failBody(ctx, expectedStr, pos)),
+      `${ind(ctx)}const ${vv} = input.slice(${pos}, ${pos} + ${len})`
     );
   } else if (len === 0) {
     stmts.push(`${ind(ctx)}const ${vv} = ''`);
@@ -3367,6 +3461,7 @@ function emitRegex(def, ctx, pos) {
       return { stmts: stmts2, valueVar: vv2, endVar: scanned.endVar };
     }
   }
+  _loweringSink?.add(`/${def.source}/${def.flags}`);
   const flags = "y" + def.flags.replace(/[gy]/g, "");
   const key = `${def.source}/${flags}`;
   let rName = ctx.regexMap.get(key);
@@ -3947,15 +4042,19 @@ function emitNode(def, ctx, pos) {
     ctx.buildSrcs.push(def.buildSrc ?? null);
   }
   const i = ind(ctx);
-  const capturesTrivia = mkType !== null || structural || buildReadsTrivia(def);
-  const clonesState = structural || buildReadsState(def);
+  const capturesTrivia = mkType !== null || !structural && buildReadsTrivia(def);
+  const clonesState = !structural && buildReadsState(def);
   const chV = v(ctx, "_ch");
   const rawV = v(ctx, "_raw");
-  const tlV = capturesTrivia ? v(ctx, "_tl") : "_EMPTY_TL";
+  const capTLv = structural ? v(ctx, "_ctl") : null;
+  const capSTv = structural ? v(ctx, "_cst") : null;
+  const tlV = capturesTrivia || structural ? v(ctx, "_tl") : "_EMPTY_TL";
   if (!capturesTrivia) ctx.needsEmptyTl = true;
   const sc = v(ctx, "_sc"), sl = v(ctx, "_sl"), sr = v(ctx, "_sr"), st = v(ctx, "_st"), stl = v(ctx, "_stl");
-  const allocStmt = capturesTrivia ? `${i}const ${chV} = [], ${rawV} = [], ${tlV} = []` : `${i}const ${chV} = [], ${rawV} = []`;
-  const innerTl = capturesTrivia ? tlV : "undefined";
+  if (structural) ctx.needsHostReads = true;
+  const allocStmt = structural ? `${i}const ${capTLv} = _ctx._pmCapTL ??= _hostReads(_ctx.build, 4), ${capSTv} = _ctx._pmCapST ??= (_ctx.build === undefined || _hostReads(_ctx.build, 5))
+${i}const ${chV} = [], ${rawV} = [], ${tlV} = ${capTLv} ? [] : _EMPTY_TL` : capturesTrivia ? `${i}const ${chV} = [], ${rawV} = [], ${tlV} = []` : `${i}const ${chV} = [], ${rawV} = []`;
+  const innerTl = structural ? `${capTLv} ? ${tlV} : undefined` : capturesTrivia ? tlV : "undefined";
   const stmts = [
     allocStmt,
     `${i}const ${sc} = _ctx._cstChildren, ${sl} = _ctx._cstLeaves, ${sr} = _ctx._cstRawChildren, ${st} = _ctx.captureTrivia, ${stl} = _ctx._cstTriviaLog`,
@@ -3966,7 +4065,10 @@ function emitNode(def, ctx, pos) {
   stmts.push(`${i}_ctx._cstChildren = ${sc}; _ctx._cstLeaves = ${sl}; _ctx._cstRawChildren = ${sr}; _ctx.captureTrivia = ${st}; _ctx._cstTriviaLog = ${stl}`);
   stmts.push(...emitIfFail(ctx, `!${okVar}`, propagateFailBody(ctx)));
   let stV = "undefined";
-  if (clonesState) {
+  if (structural) {
+    stV = v(ctx, "_nst");
+    stmts.push(`${i}const ${stV} = ${capSTv} && _ctx.state !== undefined ? Object.assign({}, _ctx.state) : undefined`);
+  } else if (clonesState) {
     stV = v(ctx, "_nst");
     stmts.push(`${i}const ${stV} = _ctx.state !== undefined ? Object.assign({}, _ctx.state) : undefined`);
   }
@@ -4402,7 +4504,6 @@ function compile(combinator, mapFnSources) {
     buildFns: [],
     buildSrcs: [],
     runtimeParsers: [],
-    needsCollator: false,
     namedParsers: /* @__PURE__ */ new Map(),
     triviaCaptureNames: /* @__PURE__ */ new Map(),
     triviaFnNames: /* @__PURE__ */ new Map(),
@@ -4411,18 +4512,18 @@ function compile(combinator, mapFnSources) {
     lazyUsage: analyzeLazyUsage(combinator)
   };
   const r = emit(combinator, ctx, "_pos");
-  const collatorDecl = ctx.needsCollator ? `const _collator = new Intl.Collator(undefined, { sensitivity: 'accent' })
-` : "";
   const namedPrelude = ctx.namedFnDecls.length > 0 ? [...namedFnPrelude(), ""] : [];
   const emptyTlDecls = ctx.needsEmptyTl ? ["const _EMPTY_TL = Object.freeze([])"] : [];
+  const hostReadsDecls = ctx.needsHostReads ? [HOST_READS_DECL] : [];
   const source = [
     ...emptyTlDecls,
+    ...hostReadsDecls,
     ...ctx.regexDecls,
     ...ctx.expectedDecls,
     "",
     ...namedPrelude,
     ctx.namedFnDecls.join("\n\n"),
-    `${collatorDecl}function _parse(input, _pos, _rp, _mf, _build, _ctx) {`,
+    `function _parse(input, _pos, _rp, _mf, _build, _ctx) {`,
     `  let pos = _pos`,
     ...r.stmts,
     `  return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`,
@@ -4430,9 +4531,9 @@ function compile(combinator, mapFnSources) {
   ].join("\n");
   const fn = new Function("input", "_pos", "_rp", "_mf", "_build", "_ctx", [
     ...emptyTlDecls,
+    ...hostReadsDecls,
     ...ctx.regexDecls,
     ...ctx.expectedDecls,
-    collatorDecl,
     ...namedPrelude,
     ...ctx.namedFnDecls.flatMap((decl, i) => i > 0 ? ["", decl] : [decl]),
     `let pos = _pos`,
@@ -4449,7 +4550,7 @@ function compile(combinator, mapFnSources) {
   const buildSources = ctx.buildFns.length === 0 ? void 0 : ctx.buildSrcs;
   const mfCovered = ctx.mapFns.length === 0 || effectiveSources !== void 0 && effectiveSources.length === ctx.mapFns.length;
   const canInline = ctx.runtimeParsers.length === 0 && mfCovered && buildCovered;
-  const inlineExpression = canInline ? buildInlineExpression(ctx, r, collatorDecl, effectiveSources, buildSources) : null;
+  const inlineExpression = canInline ? buildInlineExpression(ctx, r, effectiveSources, buildSources) : null;
   return {
     source,
     inlineExpression,
@@ -4505,7 +4606,6 @@ function compileLinkable(ruleMapArg, ns) {
     buildFns: [],
     buildSrcs: [],
     runtimeParsers: [],
-    needsCollator: false,
     namedParsers: /* @__PURE__ */ new Map(),
     triviaCaptureNames: /* @__PURE__ */ new Map(),
     triviaFnNames: /* @__PURE__ */ new Map(),
@@ -4636,12 +4736,12 @@ function compileLinkable(ruleMapArg, ns) {
     firstSets,
     deps: ruleDependencies(ruleMap),
     needsEmptyTl: !!ctx.needsEmptyTl,
-    needsCollator: ctx.needsCollator,
+    needsHostReads: !!ctx.needsHostReads,
     mfFns: mfSrcs ? [] : ctx.mapFns,
     buildFns: buildSrcs ? [] : ctx.buildFns
   };
 }
-function buildInlineExpression(ctx, r, collatorDecl, mapFnSources, buildSources) {
+function buildInlineExpression(ctx, r, mapFnSources, buildSources) {
   const bodyLines = [
     `  let pos = _pos`,
     ...r.stmts,
@@ -4655,14 +4755,15 @@ function buildInlineExpression(ctx, r, collatorDecl, mapFnSources, buildSources)
   const mfDecl = mapFnSources?.length ? `  const _mf = [${mapFnSources.join(", ")}]` : "";
   const buildDecl = buildSources?.length ? `  const _build = [${buildSources.join(", ")}]` : "";
   const emptyTlDecl = ctx.needsEmptyTl ? `  const _EMPTY_TL = Object.freeze([])` : "";
-  const needsWrapper = ctx.regexDecls.length > 0 || ctx.expectedDecls.length > 0 || !!collatorDecl || ctx.namedFnDecls.length > 0 || !!mfDecl || !!buildDecl || !!emptyTlDecl;
+  const hostReadsDecl = ctx.needsHostReads ? `  ${HOST_READS_DECL}` : "";
+  const needsWrapper = ctx.regexDecls.length > 0 || ctx.expectedDecls.length > 0 || ctx.namedFnDecls.length > 0 || !!mfDecl || !!buildDecl || !!emptyTlDecl || !!hostReadsDecl;
   if (!needsWrapper) return innerFn;
   const namedPrelude = ctx.namedFnDecls.length > 0 ? namedFnPrelude() : [];
   const hoistedDecls = [
     emptyTlDecl,
+    hostReadsDecl,
     ...ctx.regexDecls.map((d) => `  ${d}`),
     ...ctx.expectedDecls.map((d) => `  ${d}`),
-    collatorDecl ? `  ${collatorDecl.trim()}` : "",
     mfDecl,
     buildDecl,
     ...namedPrelude.map((l) => `  ${l}`),
@@ -4721,13 +4822,13 @@ function fusedBody(pieces) {
   }
   const contributing = new Set(winner.values());
   const needsEmptyTl = [...contributing].some((p) => p.needsEmptyTl);
-  const needsCollator = [...contributing].some((p) => p.needsCollator);
+  const needsHostReads = [...contributing].some((p) => p.needsHostReads);
   const lines = [
     // Shared sentinel protocol (must match NAMED_FN_FAIL / NAMED_FN_END in codegen).
     "const _pfFail = {}",
     "let _pfEnd",
     ...needsEmptyTl ? ["const _EMPTY_TL = Object.freeze([])"] : [],
-    ...needsCollator ? ["const _collator = new Intl.Collator(undefined, { sensitivity: 'accent' })"] : [],
+    ...needsHostReads ? [HOST_READS_DECL] : [],
     // Each contributing artifact's namespaced private prelude (regexes, _pf, …).
     ...[...contributing].flatMap((p) => p.prelude),
     // The winning `_r_<Name>` function for each rule (one per name → no redeclare).