parseman 0.18.1 → 0.18.2

package/dist/index.js

@@ -349,13 +349,12 @@ function literal(value, opts = {}) {
       if (end > input.length) {
         return failAt(ctx, [JSON.stringify(value)], pos);
       }
-      const slice = input.slice(pos, end);
-      const matched = caseInsensitive ? asciiFoldEq(slice, value) : slice === value;
-      if (matched) {
+      const matchedValue = caseInsensitive ? input.slice(pos, end) : value;
+      if (caseInsensitive ? asciiFoldEq(matchedValue, value) : input.startsWith(value, pos)) {
         const span = { start: pos, end };
-        const leaf = { _tag: "leaf", value: slice, span };
+        const leaf = { _tag: "leaf", value: matchedValue, span };
         if (cstCaptureActive(ctx)) pushCstLeaf(ctx, leaf);
-        return { ok: true, value: slice, span };
+        return { ok: true, value: matchedValue, span };
       }
       return failAt(ctx, [JSON.stringify(value)], pos);
     }
@@ -368,10 +367,102 @@ function registerRegexAnalyzer(analyzer) {
   firstSetAnalyzer = analyzer;
 }
 var permissiveFirstSet = () => ({ firstSet: any(), canMatchNewline: true });
+var SCAN_BAIL_AT = 64;
+var SPACE_RANGES = [
+  [9, 13],
+  [32, 32],
+  [160, 160],
+  [5760, 5760],
+  [8192, 8202],
+  [8232, 8233],
+  [8239, 8239],
+  [8287, 8287],
+  [12288, 12288],
+  [65279, 65279]
+];
+var CLASS_ESCAPES = { t: 9, n: 10, r: 13, f: 12, v: 11, "0": 0 };
+function shorthandRanges(ch) {
+  if (ch === "d") return [[48, 57]];
+  if (ch === "s") return SPACE_RANGES;
+  return [[48, 57], [65, 90], [97, 122], [95, 95]];
+}
+function inRanges(cp, ranges) {
+  for (let i = 0; i < ranges.length; i++) {
+    const [lo, hi] = ranges[i];
+    if (cp >= lo && cp <= hi) return true;
+  }
+  return false;
+}
+function readClassRanges(body) {
+  if (body.startsWith("^")) return null;
+  const ranges = [];
+  let i = 0;
+  const readAtom = () => {
+    const ch = body[i];
+    if (ch === void 0) return null;
+    if (ch === "\\") {
+      const esc = body[i + 1];
+      if (esc === void 0) return null;
+      i += 2;
+      if (esc === "d" || esc === "w" || esc === "s") return { ranges: shorthandRanges(esc) };
+      if (esc in CLASS_ESCAPES) return { cp: CLASS_ESCAPES[esc] };
+      if (esc >= "a" && esc <= "z" || esc >= "A" && esc <= "Z") return null;
+      return { cp: esc.charCodeAt(0) };
+    }
+    i++;
+    return { cp: ch.charCodeAt(0) };
+  };
+  while (i < body.length) {
+    const lo = readAtom();
+    if (!lo) return null;
+    if ("ranges" in lo) {
+      ranges.push(...lo.ranges);
+      continue;
+    }
+    if (body[i] === "-" && body[i + 1] !== void 0 && body[i + 1] !== "]") {
+      i++;
+      const hi = readAtom();
+      if (!hi || "ranges" in hi) return null;
+      ranges.push([lo.cp, hi.cp]);
+    } else {
+      ranges.push([lo.cp, lo.cp]);
+    }
+  }
+  return ranges.length ? ranges : null;
+}
+function shortScanner(source, flags) {
+  if (/[imsuvy]/.test(flags)) return null;
+  let ranges = null;
+  let quant = "";
+  if (source[0] === "[") {
+    let end = 1;
+    while (end < source.length && source[end] !== "]") {
+      if (source[end] === "\\") end += 2;
+      else end++;
+    }
+    if (source[end] !== "]") return null;
+    ranges = readClassRanges(source.slice(1, end));
+    quant = source.slice(end + 1);
+  } else if (source[0] === "\\" && (source[1] === "d" || source[1] === "w" || source[1] === "s")) {
+    ranges = shorthandRanges(source[1]);
+    quant = source.slice(2);
+  }
+  if (!ranges || quant !== "+" && quant !== "*") return null;
+  const minOne = quant === "+";
+  return (input, pos) => {
+    let end = pos;
+    while (end < input.length && inRanges(input.charCodeAt(end), ranges)) {
+      end++;
+      if (end - pos >= SCAN_BAIL_AT) return void 0;
+    }
+    return minOne && end === pos ? null : end;
+  };
+}
 function regex(pattern, flags = "") {
   const source = typeof pattern === "string" ? pattern : pattern.source;
   const resolvedFlags = typeof pattern === "string" ? flags : pattern.flags;
   const anchored = new RegExp(source, "y" + resolvedFlags.replace(/[gy]/g, ""));
+  const scan = shortScanner(source, resolvedFlags);
   const { firstSet, canMatchNewline } = (firstSetAnalyzer ?? permissiveFirstSet)(source);
   const meta = { firstSet, canMatchNewline, isTrivia: false };
   return {
@@ -379,6 +470,15 @@ function regex(pattern, flags = "") {
     _meta: meta,
     _def: { tag: "regex", source, flags: resolvedFlags },
     parse(input, pos, ctx) {
+      const scanEnd = scan?.(input, pos);
+      if (scanEnd !== void 0) {
+        if (scanEnd === null) return failAt(ctx, [`/${source}/`], pos);
+        const value = input.slice(pos, scanEnd);
+        const span2 = { start: pos, end: scanEnd };
+        const leaf2 = { _tag: "leaf", value, span: span2 };
+        if (cstCaptureActive(ctx)) pushCstLeaf(ctx, leaf2);
+        return { ok: true, value, span: span2 };
+      }
       anchored.lastIndex = pos;
       const m = anchored.exec(input);
       if (m === null) {
@@ -562,13 +662,10 @@ function choice(...args) {
   };
   const strategy = disjoint || hasGates ? null : detectStrategy(parsers);
   const autoNot = !disjoint && !hasGates && strategy?.tag === "firstMatch" ? computeAutoNot(parsers) : parsers.map(() => null);
-  let greedyRe = null;
   let greedyLitMap = null;
   let sortedParsers = null;
+  const asciiDispatch = disjoint ? buildAsciiDispatch(parsers) : null;
   if (strategy?.tag === "greedyClassify") {
-    const regexDef = getCoreRegexDef(parsers[strategy.superIndex]);
-    const flags = "y" + regexDef.flags.replace(/[gy]/g, "");
-    greedyRe = new RegExp(regexDef.source, flags);
     greedyLitMap = /* @__PURE__ */ new Map();
     for (let i = 0; i < parsers.length; i++) {
       if (i === strategy.superIndex) continue;
@@ -593,14 +690,21 @@ function choice(...args) {
       const expected = [];
       if (disjoint && pos < input.length) {
         const code = input.codePointAt(pos);
-        for (const parser2 of parsers) {
-          if (inFirstSet(code, parser2._meta.firstSet)) {
-            const result = parser2.parse(input, pos, ctx);
-            if (result.ok) return result;
-            expected.push(...result.expected);
-            return { ok: false, expected, span: { start: pos, end: pos } };
+        let parser2 = code < 128 ? asciiDispatch?.[code] ?? null : null;
+        if (!parser2) {
+          for (const p of parsers) {
+            if (inFirstSet(code, p._meta.firstSet)) {
+              parser2 = p;
+              break;
+            }
           }
         }
+        if (parser2) {
+          const result = parser2.parse(input, pos, ctx);
+          if (result.ok) return result;
+          expected.push(...result.expected);
+          return { ok: false, expected, span: { start: pos, end: pos } };
+        }
         return {
           ok: false,
           expected: parsers.flatMap((p) => {
@@ -776,6 +880,19 @@ function areDisjoint(sets) {
       if (intersects(sets[i], sets[j])) return false;
   return true;
 }
+function buildAsciiDispatch(parsers) {
+  const table = Array(128).fill(null);
+  for (const parser2 of parsers) {
+    const fs = parser2._meta.firstSet;
+    if (fs.kind !== "ranges") continue;
+    for (const { lo, hi } of fs.ranges) {
+      for (let code = Math.max(0, lo); code <= Math.min(127, hi); code++) {
+        table[code] = parser2;
+      }
+    }
+  }
+  return table;
+}
 
 // src/cst/trivia-kinds.ts
 function unwrapTrivia(p) {
@@ -897,6 +1014,7 @@ function recordTriviaChunks(ctx, chunks) {
 // src/combinators/trivia-skip.ts
 var NOOP_COMMIT = () => {
 };
+var fastTriviaCache = /* @__PURE__ */ new WeakMap();
 function needsDeferredTriviaCommit(ctx) {
   return ctx._triviaLog !== void 0 || ctx._cstBuf !== void 0 || ctx._cstTriviaLog !== void 0;
 }
@@ -923,6 +1041,8 @@ function scanWithLabels(input, cur, ctx) {
 function advanceTrivia(input, cur, ctx) {
   const triviaP = ctx.trivia;
   if (!triviaP) return cur;
+  const fast = fastTriviaScanner(triviaP);
+  if (fast) return fast(input, cur);
   if (ctx.triviaKindLabels) {
     const scan = scanWithLabels(input, cur, ctx);
     return scan.end;
@@ -935,6 +1055,10 @@ function scanTrivia(input, cur, ctx) {
   if (!triviaP) return { end: cur, commit: NOOP_COMMIT };
   const log = ctx._triviaLog;
   const captureTl = ctx.captureTrivia && (ctx._cstBuf !== void 0 || ctx._cstTriviaLog !== void 0);
+  const fast = !ctx.triviaKindLabels ? fastTriviaScanner(triviaP) : null;
+  if (fast && log === void 0 && !captureTl) {
+    return { end: fast(input, cur), commit: NOOP_COMMIT };
+  }
   if (ctx.triviaKindLabels && (log !== void 0 || captureTl)) {
     return scanWithLabels(input, cur, ctx);
   }
@@ -956,6 +1080,79 @@ function scanTrivia(input, cur, ctx) {
   const tr = triviaP.parse(input, cur, { trackLines: ctx.trackLines, state: ctx.state });
   return { end: tr.ok ? tr.span.end : cur, commit: NOOP_COMMIT };
 }
+function fastTriviaScanner(trivia2) {
+  const cached = fastTriviaCache.get(trivia2);
+  if (cached !== void 0) return cached;
+  const scanner = buildFastTriviaScanner(trivia2);
+  fastTriviaCache.set(trivia2, scanner);
+  return scanner;
+}
+function buildFastTriviaScanner(trivia2) {
+  const core = trivia2._def.tag === "trivia" ? trivia2._def.parser : trivia2;
+  const direct = regexTriviaScanner(core);
+  if (direct) return direct;
+  const repeat = core._def.tag === "oneOrMore" || core._def.tag === "many" && core._def.min >= 1 ? core._def.parser : null;
+  if (!repeat) return null;
+  const one = regexTriviaScanner(repeat);
+  if (one) return loopScanner([one]);
+  if (repeat._def.tag !== "choice") return null;
+  const arms = repeat._def.parsers.map(regexTriviaScanner);
+  if (arms.some((s) => s === null)) return null;
+  return loopScanner(arms);
+}
+function loopScanner(arms) {
+  return (input, cur) => {
+    let pos = cur;
+    scan: while (pos < input.length) {
+      for (const arm of arms) {
+        const end = arm(input, pos);
+        if (end > pos) {
+          pos = end;
+          continue scan;
+        }
+      }
+      break;
+    }
+    return pos;
+  };
+}
+function regexTriviaScanner(parser2) {
+  if (parser2._def.tag !== "regex" || parser2._def.flags) return null;
+  const ws = whitespaceSource(parser2._def.source);
+  if (ws) return ws;
+  return blockCommentSource(parser2._def.source) ? scanBlockComment : null;
+}
+function whitespaceSource(source) {
+  const m = /^\[([ \\tnrf]+)\][*+]$/.exec(source);
+  if (!m) return null;
+  const chars = /* @__PURE__ */ new Set();
+  for (let i = 0; i < m[1].length; i++) {
+    const ch = m[1][i];
+    if (ch !== "\\") {
+      chars.add(ch.charCodeAt(0));
+      continue;
+    }
+    const esc = m[1][++i];
+    if (esc === "t") chars.add(9);
+    else if (esc === "n") chars.add(10);
+    else if (esc === "r") chars.add(13);
+    else if (esc === "f") chars.add(12);
+    else return null;
+  }
+  return (input, cur) => {
+    let pos = cur;
+    while (pos < input.length && chars.has(input.charCodeAt(pos))) pos++;
+    return pos;
+  };
+}
+function blockCommentSource(source) {
+  return source === "\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\/" || source === "\\/\\*[^]*?\\*\\/";
+}
+function scanBlockComment(input, cur) {
+  if (input.charCodeAt(cur) !== 47 || input.charCodeAt(cur + 1) !== 42) return cur;
+  const close = input.indexOf("*/", cur + 2);
+  return close === -1 ? cur : close + 2;
+}
 
 // src/combinators/sequence.ts
 function sequence(...parsers) {
@@ -1094,11 +1291,15 @@ function optional(combinator) {
     canMatchNewline: combinator._meta.canMatchNewline,
     isTrivia: false
   };
+  const firstSetSkippable = !matchesEmpty(combinator);
   return {
     _tag: "optional",
     _meta: meta,
     _def: { tag: "optional", parser: combinator },
     parse(input, pos, ctx) {
+      if (firstSetSkippable && ctx._probe === void 0 && !startsFirstSet(combinator, input, pos)) {
+        return { ok: true, value: null, span: { start: pos, end: pos } };
+      }
       const mark = saveTriviaMark(ctx);
       const result = combinator.parse(input, pos, ctx);
       if (result.ok) return result;
@@ -1107,6 +1308,15 @@ function optional(combinator) {
     }
   };
 }
+function startsFirstSet(combinator, input, pos) {
+  const fs = combinator._meta.firstSet;
+  if (fs.kind === "any") return true;
+  if (fs.kind === "empty") return false;
+  const code = input.codePointAt(pos);
+  if (code === void 0) return false;
+  for (const r of fs.ranges) if (code >= r.lo && code <= r.hi) return true;
+  return false;
+}
 function sepBy(combinator, separator) {
   const meta = {
     firstSet: combinator._meta.firstSet,
@@ -1414,7 +1624,7 @@ function transform(combinator, fn) {
     parse(input, pos, ctx) {
       const result = combinator.parse(input, pos, ctx);
       if (!result.ok) return result;
-      return { ...result, value: fn(result.value, result.span) };
+      return { ok: true, value: fn(result.value, result.span), span: result.span };
     }
   };
 }
@@ -1428,7 +1638,7 @@ function skip(main, skipped) {
       if (!result.ok) return result;
       const s = skipped.parse(input, result.span.end, ctx);
       if (!s.ok) return result;
-      return { ...result, span: { start: result.span.start, end: s.span.end } };
+      return { ok: true, value: result.value, span: { start: result.span.start, end: s.span.end } };
     }
   };
 }
@@ -1452,7 +1662,7 @@ function label(name, combinator) {
     _def: { tag: "label", label: name, parser: combinator },
     parse(input, pos, ctx) {
       const result = combinator.parse(input, pos, ctx);
-      if (!result.ok) return { ...result, expected: [name] };
+      if (!result.ok) return { ok: false, expected: [name], span: result.span };
       return result;
     }
   };
@@ -1666,9 +1876,9 @@ function expect(combinator, label2) {
 
 // src/compiler/scannable-run.ts
 var BACKSLASH = 92;
-var CLASS_ESCAPES = { t: 9, n: 10, r: 13, f: 12, v: 11, "0": 0 };
+var CLASS_ESCAPES2 = { t: 9, n: 10, r: 13, f: 12, v: 11, "0": 0 };
 var META = new Set("()[]{}*+?|^$.".split(""));
-var SPACE_RANGES = [
+var SPACE_RANGES2 = [
   [9, 13],
   [32, 32],
   [160, 160],
@@ -1681,9 +1891,9 @@ var SPACE_RANGES = [
   [12288, 12288],
   [65279, 65279]
 ];
-function shorthandRanges(ch) {
+function shorthandRanges2(ch) {
   if (ch === "d") return [[48, 57]];
-  if (ch === "s") return SPACE_RANGES;
+  if (ch === "s") return SPACE_RANGES2;
   return [[48, 57], [65, 90], [97, 122], [95, 95]];
 }
 function readUnicodeEscape(body, i) {
@@ -1707,8 +1917,8 @@ function parseClassRanges(body) {
       const e = body[i + 1];
       if (e === void 0) return null;
       i += 2;
-      if (e in CLASS_ESCAPES) return { cp: CLASS_ESCAPES[e] };
-      if (e === "d" || e === "w" || e === "s") return { set: shorthandRanges(e) };
+      if (e in CLASS_ESCAPES2) return { cp: CLASS_ESCAPES2[e] };
+      if (e === "d" || e === "w" || e === "s") return { set: shorthandRanges2(e) };
       if (e >= "a" && e <= "z" || e >= "A" && e <= "Z") return null;
       return { cp: e.codePointAt(0) };
     }
@@ -1734,9 +1944,9 @@ function parseClassRanges(body) {
   return ranges.length ? ranges : null;
 }
 function classToRanges(cls) {
-  if (cls === "\\d") return shorthandRanges("d");
-  if (cls === "\\w") return shorthandRanges("w");
-  if (cls === "\\s") return shorthandRanges("s");
+  if (cls === "\\d") return shorthandRanges2("d");
+  if (cls === "\\w") return shorthandRanges2("w");
+  if (cls === "\\s") return shorthandRanges2("s");
   const body = cls.slice(1, -1);
   if (body.startsWith("^")) return null;
   return parseClassRanges(body);
@@ -1754,7 +1964,7 @@ function literalCodePoints(frag) {
     if (ch === "\\") {
       const e = frag[i + 1];
       if (e === void 0) return null;
-      out.push(e in CLASS_ESCAPES ? CLASS_ESCAPES[e] : e.codePointAt(0));
+      out.push(e in CLASS_ESCAPES2 ? CLASS_ESCAPES2[e] : e.codePointAt(0));
       i += 2;
       continue;
     }
@@ -1847,7 +2057,7 @@ function parseSeqParts(source) {
       if (e === "d" || e === "w" || e === "s") {
         flush();
         i += 2;
-        i += runFrom(shorthandRanges(e), false, source[i]);
+        i += runFrom(shorthandRanges2(e), false, source[i]);
         continue;
       }
       const uni = readUnicodeEscape(source, i);
@@ -1856,8 +2066,8 @@ function parseSeqParts(source) {
         cp2 = uni.cp;
         i = uni.next;
       } else if (e === void 0) return null;
-      else if (e in CLASS_ESCAPES) {
-        cp2 = CLASS_ESCAPES[e];
+      else if (e in CLASS_ESCAPES2) {
+        cp2 = CLASS_ESCAPES2[e];
         i += 2;
       } else if (e >= "a" && e <= "z" || e >= "A" && e <= "Z") return null;
       else {
@@ -1964,7 +2174,7 @@ function rangesSubset(sub, sup) {
 }
 function parseClassOperand(body) {
   if (body === "\\d" || body === "\\w" || body === "\\s") {
-    return { ranges: shorthandRanges(body[1]), negated: false };
+    return { ranges: shorthandRanges2(body[1]), negated: false };
   }
   if (body.length >= 2 && body[0] === "[" && body[body.length - 1] === "]") {
     let inner = body.slice(1, -1);
@@ -2397,7 +2607,7 @@ function parseScanShapeCore(source) {
   }
   m = /^\\([dws])([+*])$/.exec(source);
   if (m) {
-    return { kind: "chars", ranges: shorthandRanges(m[1]), minOne: m[2] === "+" };
+    return { kind: "chars", ranges: shorthandRanges2(m[1]), minOne: m[2] === "+" };
   }
   m = /^(\[(?:\\.|[^\]])+\]|\\[dws])(\[(?:\\.|[^\]])+\]|\\[dws])\*$/.exec(source);
   if (m) {