parseman 0.47.1 → 0.48.0

package/dist/spec/index.js

@@ -817,6 +817,179 @@ function parseClassRanges(body) {
   return ranges.length ? ranges : null;
 }
 
+// src/cst/trivia-css-scanner.ts
+var CSS_WS_SOURCE = "[ \\t\\n\\r\\f]+";
+var CSS_LINE_COMMENT_SOURCE = "\\/\\/[^\\n\\r]*";
+var CSS_BLOCK_COMMENT_SOURCE = "\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\/";
+function scanWhitespace(input, cur) {
+  let pos = cur;
+  while (pos < input.length) {
+    const c = input.charCodeAt(pos);
+    if (c !== 32 && c !== 9 && c !== 10 && c !== 13 && c !== 12) break;
+    pos++;
+  }
+  return pos;
+}
+function scanLineComment(input, cur) {
+  if (input.charCodeAt(cur) !== 47 || input.charCodeAt(cur + 1) !== 47) return cur;
+  let pos = cur + 2;
+  while (pos < input.length) {
+    const c = input.charCodeAt(pos);
+    if (c === 10 || c === 13) break;
+    pos++;
+  }
+  return pos;
+}
+function scanBlockComment(input, cur) {
+  if (input.charCodeAt(cur) !== 47 || input.charCodeAt(cur + 1) !== 42) return cur;
+  const close = input.indexOf("*/", cur + 2);
+  return close < 0 ? cur : close + 2;
+}
+function scanWsLineBlockTrivia(input, cur) {
+  let pos = cur;
+  for (; ; ) {
+    const ws = scanWhitespace(input, pos);
+    if (ws !== pos) {
+      pos = ws;
+      continue;
+    }
+    const line = scanLineComment(input, pos);
+    if (line !== pos) {
+      pos = line;
+      continue;
+    }
+    const block = scanBlockComment(input, pos);
+    if (block !== pos) {
+      pos = block;
+      continue;
+    }
+    return pos;
+  }
+}
+function scanWsBlockTrivia(input, cur) {
+  let pos = cur;
+  for (; ; ) {
+    const ws = scanWhitespace(input, pos);
+    if (ws !== pos) {
+      pos = ws;
+      continue;
+    }
+    const block = scanBlockComment(input, pos);
+    if (block !== pos) {
+      pos = block;
+      continue;
+    }
+    return pos;
+  }
+}
+function scanLineBlockTrivia(input, cur) {
+  let pos = cur;
+  for (; ; ) {
+    const line = scanLineComment(input, pos);
+    if (line !== pos) {
+      pos = line;
+      continue;
+    }
+    const block = scanBlockComment(input, pos);
+    if (block !== pos) {
+      pos = block;
+      continue;
+    }
+    return pos;
+  }
+}
+function scanBlockTrivia(input, cur) {
+  let pos = cur;
+  for (; ; ) {
+    const block = scanBlockComment(input, pos);
+    if (block === pos) return pos;
+    pos = block;
+  }
+}
+function visitWsLineBlock(input, cur, visit) {
+  let pos = cur;
+  for (; ; ) {
+    let end = scanWhitespace(input, pos);
+    if (end !== pos) {
+      visit(pos, end, 0);
+      pos = end;
+      continue;
+    }
+    end = scanLineComment(input, pos);
+    if (end !== pos) {
+      visit(pos, end, 1);
+      pos = end;
+      continue;
+    }
+    end = scanBlockComment(input, pos);
+    if (end !== pos) {
+      visit(pos, end, 2);
+      pos = end;
+      continue;
+    }
+    return pos;
+  }
+}
+function visitWsBlock(input, cur, visit) {
+  let pos = cur;
+  for (; ; ) {
+    let end = scanWhitespace(input, pos);
+    if (end !== pos) {
+      visit(pos, end, 0);
+      pos = end;
+      continue;
+    }
+    end = scanBlockComment(input, pos);
+    if (end !== pos) {
+      visit(pos, end, 1);
+      pos = end;
+      continue;
+    }
+    return pos;
+  }
+}
+function visitLineBlock(input, cur, visit) {
+  let pos = cur;
+  for (; ; ) {
+    let end = scanLineComment(input, pos);
+    if (end !== pos) {
+      visit(pos, end, 0);
+      pos = end;
+      continue;
+    }
+    end = scanBlockComment(input, pos);
+    if (end !== pos) {
+      visit(pos, end, 1);
+      pos = end;
+      continue;
+    }
+    return pos;
+  }
+}
+function visitBlock(input, cur, visit) {
+  let pos = cur;
+  for (; ; ) {
+    const end = scanBlockComment(input, pos);
+    if (end === pos) return pos;
+    visit(pos, end, 0);
+    pos = end;
+  }
+}
+function commonCssTriviaScanner(sources) {
+  if (sources.length === 3 && sources[0] === CSS_WS_SOURCE && sources[1] === CSS_LINE_COMMENT_SOURCE && sources[2] === CSS_BLOCK_COMMENT_SOURCE) return scanWsLineBlockTrivia;
+  if (sources.length === 2 && sources[0] === CSS_WS_SOURCE && sources[1] === CSS_BLOCK_COMMENT_SOURCE) return scanWsBlockTrivia;
+  if (sources.length === 2 && sources[0] === CSS_LINE_COMMENT_SOURCE && sources[1] === CSS_BLOCK_COMMENT_SOURCE) return scanLineBlockTrivia;
+  if (sources.length === 1 && sources[0] === CSS_BLOCK_COMMENT_SOURCE) return scanBlockTrivia;
+  return null;
+}
+function commonCssTriviaVisitor(sources) {
+  if (sources.length === 3 && sources[0] === CSS_WS_SOURCE && sources[1] === CSS_LINE_COMMENT_SOURCE && sources[2] === CSS_BLOCK_COMMENT_SOURCE) return visitWsLineBlock;
+  if (sources.length === 2 && sources[0] === CSS_WS_SOURCE && sources[1] === CSS_BLOCK_COMMENT_SOURCE) return visitWsBlock;
+  if (sources.length === 2 && sources[0] === CSS_LINE_COMMENT_SOURCE && sources[1] === CSS_BLOCK_COMMENT_SOURCE) return visitLineBlock;
+  if (sources.length === 1 && sources[0] === CSS_BLOCK_COMMENT_SOURCE) return visitBlock;
+  return null;
+}
+
 // src/cst/trivia-charscan.ts
 function inRanges(cp, ranges) {
   for (let i = 0; i < ranges.length; i++) {
@@ -970,6 +1143,35 @@ function classifyParser(p) {
   if (d.tag !== "regex" || d.flags) return null;
   return classifyArm(d.source);
 }
+function plainRegexSource(p) {
+  const d = p._def;
+  return d.tag === "regex" && d.flags === "" ? d.source : null;
+}
+var visitSpec0;
+var visitSpec1;
+var visitSpec2;
+var visitSpec3;
+var visitValue0;
+var visitValue1;
+var visitValue2;
+var visitValue3;
+function commonLabeledTriviaVisitor(spec) {
+  if (spec === visitSpec0) return visitValue0;
+  if (spec === visitSpec1) return visitValue1;
+  if (spec === visitSpec2) return visitValue2;
+  if (spec === visitSpec3) return visitValue3;
+  const sources = spec.minRepeats <= 1 ? spec.arms.map((arm) => plainRegexSource(arm.parser)) : [];
+  const visitor = commonCssTriviaVisitor(sources);
+  visitSpec3 = visitSpec2;
+  visitValue3 = visitValue2;
+  visitSpec2 = visitSpec1;
+  visitValue2 = visitValue1;
+  visitSpec1 = visitSpec0;
+  visitValue1 = visitValue0;
+  visitSpec0 = spec;
+  visitValue0 = visitor;
+  return visitor;
+}
 var armSpec0;
 var armSpec1;
 var armSpec2;
@@ -1168,6 +1370,8 @@ function scanLabeledTriviaEnd(input, cur, spec, state) {
 }
 function visitLabeledTrivia(input, cur, spec, state, visit) {
   if (spec.minRepeats > 1) return void 0;
+  const common = commonLabeledTriviaVisitor(spec);
+  if (common !== null) return common(input, cur, visit);
   const chars = charArmsFor(spec);
   if (chars !== null) return charTriviaVisit(input, cur, chars, visit);
   let pos = cur;
@@ -1301,11 +1505,12 @@ function parser(opts, root) {
   const scopeLabels = scopeTrivia?._meta?.triviaKindLabels;
   const refuseUnclassified = scopeTrivia !== void 0 && !scopeTrivia._meta?.rootTriviaClassified && !opaqueRootCapture;
   const forceCaptureTrivia = opts.captureTrivia === true;
-  const trackLinesOf = opts.trackLines === true ? TRACK_LINES_ON : opts.trackLines === false ? TRACK_LINES_OFF : TRACK_LINES_INHERIT;
+  const trackLinesPolicy = opts.trackLines === true ? "on" : opts.trackLines === false ? "off" : "inherit";
+  const trackLinesOf = trackLinesPolicy === "on" ? TRACK_LINES_ON : trackLinesPolicy === "off" ? TRACK_LINES_OFF : TRACK_LINES_INHERIT;
   const captureKinds = clearTrivia ? void 0 : opts.captureTriviaKinds;
   const ownCaptureMask = captureKinds === void 0 ? void 0 : scopeLabels !== void 0 ? triviaKindMask(scopeLabels, captureKinds) : void 0;
   const inheritCaptureMask = captureKinds !== void 0 && scopeLabels === void 0;
-  return {
+  const grammar = {
     _tag: "grammar",
     _meta: {
       ...root._meta,
@@ -1324,7 +1529,9 @@ function parser(opts, root) {
       clearTrivia,
       ...opaqueRootCapture ? { rootCapture: "opaque" } : {},
       ...opts.captureTrivia ? { captureTrivia: true } : {},
-      trackLines: opts.trackLines ?? false
+      trackLines: opts.trackLines ?? false,
+      constructionTrackLines: trackLinesPolicy,
+      ...captureKinds === void 0 ? {} : { constructionCaptureTriviaKinds: captureKinds }
     },
     parse(input, pos, _ctx) {
       if (refuseUnclassified) refuseUnclassifiedRootScope(_ctx?._rootTriviaStrictScopes);
@@ -1353,6 +1560,7 @@ function parser(opts, root) {
       return lineIndex ? annotateResultLines(result, normalizeLineIndex(lineIndex)) : result;
     }
   };
+  return grammar;
 }
 
 // src/cst/reflection-symbols.ts
@@ -1831,6 +2039,21 @@ function firstSetFromRegex(source) {
   return { firstSet: firstSet(ast), canMatchNewline: canConsumeNewline(ast) };
 }
 
+// src/combinators/expected.ts
+function directTerminalFailureExpected(def) {
+  switch (def.tag) {
+    case "literal":
+      return [JSON.stringify(def.value)];
+    case "regex":
+      return [`/${def.source}/`];
+    case "keywords":
+      return ["keyword"];
+  }
+}
+function assertionFailureExpected(positive, childTag) {
+  return [`${positive ? "peek" : "not"}(${childTag})`];
+}
+
 // src/combinators/regex.ts
 var SCAN_BAIL_AT = 64;
 function inRanges2(cp, ranges) {
@@ -1902,14 +2125,15 @@ function regex(pattern, flags = "") {
   const firstSet2 = !resolvedFlags.includes("i") ? raw.firstSet : resolvedFlags.includes("u") || resolvedFlags.includes("v") ? any() : asciiCaseFold(raw.firstSet);
   const canMatchNewline = raw.canMatchNewline;
   const meta = { firstSet: firstSet2, canMatchNewline, isTrivia: false };
+  const def = { tag: "regex", source, flags: resolvedFlags };
   return {
     _tag: "regex",
     _meta: meta,
-    _def: { tag: "regex", source, flags: resolvedFlags },
+    _def: def,
     parse(input, pos, ctx) {
       const scanEnd = scan?.(input, pos);
       if (scanEnd !== void 0) {
-        if (scanEnd === null) return failAt(ctx, [`/${source}/`], pos);
+        if (scanEnd === null) return failAt(ctx, directTerminalFailureExpected(def), pos);
         const value = input.slice(pos, scanEnd);
         const span2 = { start: pos, end: scanEnd };
         if (canMatchNewline && ctx.trackLines) recordLineRangeFromContext(ctx, input, pos, scanEnd);
@@ -1919,7 +2143,7 @@ function regex(pattern, flags = "") {
       anchored.lastIndex = pos;
       const m = anchored.exec(input);
       if (m === null) {
-        return failAt(ctx, [`/${source}/`], pos);
+        return failAt(ctx, directTerminalFailureExpected(def), pos);
       }
       const span = { start: pos, end: pos + m[0].length };
       if (canMatchNewline && ctx.trackLines) recordLineRangeFromContext(ctx, input, pos, span.end);
@@ -1960,7 +2184,7 @@ function literal(value, opts = {}) {
       { lo: firstUpper, hi: firstUpper }
     ] } : firstSet2;
   }
-  const expected = [JSON.stringify(value)];
+  const expected = directTerminalFailureExpected({ tag: "literal", value, caseInsensitive });
   const parse = !caseInsensitive && value.length === 1 ? (() => {
     const code = value.charCodeAt(0);
     return function parse2(input, pos, ctx) {
@@ -2033,12 +2257,14 @@ function caseFoldVariants(cp) {
 function escapeRe(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+function keywordsRegExp(words, boundary, caseInsensitive) {
+  const alt = words.map(escapeRe).join("|");
+  const boundarySource = boundary ? `(?![${boundary}])` : "";
+  return new RegExp(`(?:${alt})${boundarySource}`, caseInsensitive ? "iy" : "uy");
+}
 function keywords(words, opts = {}) {
   const sorted = [...new Set(words)].sort((a, b) => b.length - a.length);
-  const alt = sorted.map(escapeRe).join("|");
-  const boundary = opts.boundary ? `(?![${opts.boundary}])` : "";
-  const flags = opts.caseInsensitive ? "iy" : "uy";
-  const re = new RegExp(`(?:${alt})${boundary}`, flags);
+  const re = keywordsRegExp(sorted, opts.boundary, opts.caseInsensitive ?? false);
   let firstSet2 = empty();
   for (const w of sorted) {
     if (w.length === 0) continue;
@@ -2049,15 +2275,21 @@ function keywords(words, opts = {}) {
     }
   }
   const meta = { firstSet: firstSet2, canMatchNewline: false, isTrivia: false };
+  const def = {
+    tag: "keywords",
+    words: sorted,
+    caseInsensitive: opts.caseInsensitive ?? false,
+    boundary: opts.boundary
+  };
   return {
     _tag: "keywords",
     _meta: meta,
-    _def: { tag: "keywords", words: sorted, caseInsensitive: opts.caseInsensitive ?? false, boundary: opts.boundary },
+    _def: def,
     parse(input, pos, ctx) {
       re.lastIndex = pos;
       const m = re.exec(input);
       if (m === null || m.index !== pos) {
-        return failAt(ctx, ["keyword"], pos);
+        return failAt(ctx, directTerminalFailureExpected(def), pos);
       }
       const value = m[0];
       const span = { start: pos, end: pos + value.length };
@@ -2070,6 +2302,14 @@ function keywords(words, opts = {}) {
 // src/combinators/trivia-skip.ts
 var NOOP_COMMIT = () => {
 };
+function triviaScanEnd(scan) {
+  return typeof scan === "number" ? scan : scan.end;
+}
+function commitTriviaScan(scan) {
+  if (typeof scan === "number") return scan;
+  scan.commit();
+  return scan.end;
+}
 var fastTrivia0;
 var fastTrivia1;
 var fastTrivia2;
@@ -2134,7 +2374,7 @@ function rollbackLookahead(ctx, mark) {
 function scanWithLabels(input, cur, ctx) {
   const triviaP = ctx.trivia;
   const spec = analyzeLabeledTrivia(triviaP);
-  if (!spec) return { end: cur, commit: NOOP_COMMIT };
+  if (!spec) return cur;
   const log = ctx._triviaLog;
   const rootLog = ctx._rootTriviaLog;
   const rootKinds = ctx._rootTriviaKindIndex;
@@ -2152,7 +2392,8 @@ function scanWithLabels(input, cur, ctx) {
     }
   });
   if (visitedEnd !== void 0) {
-    if (visitedEnd === cur) return { end: cur, commit: NOOP_COMMIT };
+    if (visitedEnd === cur) return cur;
+    if (fullRows === void 0 && rootRows === void 0 && cstRows === void 0) return visitedEnd;
     return {
       end: visitedEnd,
       commit: () => {
@@ -2171,7 +2412,7 @@ function scanWithLabels(input, cur, ctx) {
     };
   }
   const { end, chunks } = scanLabeledTriviaChunks(input, cur, spec, ctx.state);
-  if (end === cur) return { end: cur, commit: NOOP_COMMIT };
+  if (end === cur) return cur;
   return {
     end,
     commit: () => recordTriviaChunks(ctx, chunks)
@@ -2212,7 +2453,7 @@ function advanceTrivia(input, cur, ctx) {
   const tr = parseTriviaNoCapture(triviaP, input, cur, ctx);
   return tr.ok && tr.span.end > cur ? tr.span.end : cur;
 }
-function scanTrivia(input, cur, ctx) {
+function scanTriviaCompact(input, cur, ctx) {
   const triviaP = ctx.trivia;
   if (!triviaP) return { end: cur, commit: NOOP_COMMIT };
   const log = ctx._triviaLog;
@@ -2253,7 +2494,7 @@ function scanTrivia(input, cur, ctx) {
   }
   if (ctx.triviaKindLabels && (log !== void 0 || rootLog !== void 0 || captureTl)) {
     const scan = scanWithLabels(input, cur, ctx);
-    if (trackTriviaLines) recordLineRangeFromContext(ctx, input, cur, scan.end);
+    if (trackTriviaLines) recordLineRangeFromContext(ctx, input, cur, triviaScanEnd(scan));
     return scan;
   }
   if (ctx.triviaKindLabels) {
@@ -2285,14 +2526,12 @@ function scanTrivia(input, cur, ctx) {
 }
 function consumeTrivia(input, cur, ctx) {
   if (!needsDeferredTriviaCommit(ctx)) return advanceTrivia(input, cur, ctx);
-  const scan = scanTrivia(input, cur, ctx);
-  scan.commit();
-  return scan.end;
+  return commitTriviaScan(scanTriviaCompact(input, cur, ctx));
 }
 function probeTriviaEnd(input, cur, ctx) {
   if (!ctx.trivia) return cur;
   const probeCtx = { ...ctx, trackLines: false };
-  if (needsDeferredTriviaCommit(probeCtx)) return scanTrivia(input, cur, probeCtx).end;
+  if (needsDeferredTriviaCommit(probeCtx)) return triviaScanEnd(scanTriviaCompact(input, cur, probeCtx));
   return advanceTrivia(input, cur, probeCtx);
 }
 function fastTriviaScanner(trivia2) {
@@ -2320,10 +2559,16 @@ function buildFastTriviaScanner(trivia2) {
   const one = regexTriviaScanner(repeat);
   if (one) return loopScanner([one]);
   if (repeat._def.tag !== "choice") return null;
+  const fused = commonCssTriviaScanner(repeat._def.parsers.map(triviaRegexSource));
+  if (fused !== null) return fused;
   const arms = repeat._def.parsers.map(regexTriviaScanner);
   if (arms.some((s) => s === null)) return null;
   return loopScanner(arms);
 }
+function triviaRegexSource(parser2) {
+  const d = parser2._def.tag === "label" ? parser2._def.parser._def : parser2._def;
+  return d.tag === "regex" && d.flags === "" ? d.source : null;
+}
 function loopScanner(arms) {
   return (input, cur) => {
     let pos = cur;
@@ -2813,9 +3058,7 @@ function sequence(...parsers) {
           const mRootLog = ctx._rootTriviaLog?.length ?? 0;
           let scanEnd;
           if (needsDeferredTriviaCommit(ctx)) {
-            const scan = scanTrivia(input, cur, ctx);
-            scan.commit();
-            scanEnd = scan.end;
+            scanEnd = commitTriviaScan(scanTriviaCompact(input, cur, ctx));
           } else {
             scanEnd = advanceTrivia(input, cur, ctx);
           }
@@ -2825,7 +3068,15 @@ function sequence(...parsers) {
           const result2 = parsers[i].parse(input, scanEnd, ctx);
           if (!result2.ok) return result2;
           if (result2.span.end > scanEnd) cur = result2.span.end;
-          else rollbackScannedTriviaAt(ctx, mTlog, scanTlog, mLog, scanLog, mRootLog, scanRootLog);
+          else rollbackScannedTriviaAt(
+            ctx,
+            mTlog,
+            scanTlog,
+            mLog,
+            scanLog,
+            mRootLog,
+            scanRootLog
+          );
           if (values !== void 0) values.push(result2.value);
           continue;
         }
@@ -2860,9 +3111,7 @@ function sequence(...parsers) {
         const mLog = ctx._triviaLog?.length ?? 0;
         const mRootLog = ctx._rootTriviaLog?.length ?? 0;
         if (needsDeferredTriviaCommit(ctx)) {
-          const scan = scanTrivia(input, cur, ctx);
-          scan.commit();
-          scanEnd = scan.end;
+          scanEnd = commitTriviaScan(scanTriviaCompact(input, cur, ctx));
         } else {
           scanEnd = advanceTrivia(input, cur, ctx);
         }
@@ -2872,7 +3121,15 @@ function sequence(...parsers) {
         const result2 = parsers[i].parse(input, scanEnd, ctx);
         if (!result2.ok) return result2;
         if (result2.span.end > scanEnd) cur = result2.span.end;
-        else rollbackScannedTriviaAt(ctx, mTlog, scanTlog, mLog, scanLog, mRootLog, scanRootLog);
+        else rollbackScannedTriviaAt(
+          ctx,
+          mTlog,
+          scanTlog,
+          mLog,
+          scanLog,
+          mRootLog,
+          scanRootLog
+        );
         if (values !== void 0) values.push(result2.value);
         continue;
       }
@@ -2904,9 +3161,7 @@ function sequence(...parsers) {
           const mLog = ctx._triviaLog?.length ?? 0;
           const mRootLog = ctx._rootTriviaLog?.length ?? 0;
           if (needsDeferredTriviaCommit(ctx)) {
-            const scan = scanTrivia(input, cur, ctx);
-            scan.commit();
-            scanEnd = scan.end;
+            scanEnd = commitTriviaScan(scanTriviaCompact(input, cur, ctx));
           } else {
             scanEnd = advanceTrivia(input, cur, ctx);
           }
@@ -2918,7 +3173,15 @@ function sequence(...parsers) {
           if (result2.span.end > scanEnd) {
             cur = result2.span.end;
           } else {
-            rollbackScannedTriviaAt(ctx, mTlog, scanTlog, mLog, scanLog, mRootLog, scanRootLog);
+            rollbackScannedTriviaAt(
+              ctx,
+              mTlog,
+              scanTlog,
+              mLog,
+              scanLog,
+              mRootLog,
+              scanRootLog
+            );
           }
           if (values !== void 0) values.push(result2.value);
           continue;
@@ -3610,9 +3873,7 @@ function repItem(combinator, input, cur, ctx, guardable, mandatory) {
   let pos = cur;
   if (ctx.trivia) {
     if (needsDeferredTriviaCommit(ctx)) {
-      const scan = scanTrivia(input, cur, ctx);
-      scan.commit();
-      pos = scan.end;
+      pos = commitTriviaScan(scanTriviaCompact(input, cur, ctx));
     } else {
       pos = advanceTrivia(input, cur, ctx);
     }
@@ -3835,9 +4096,7 @@ function sepBy(combinator, separatorArg, opts = {}) {
         let sepPos = cur;
         if (ctx.trivia) {
           if (needsDeferredTriviaCommit(ctx)) {
-            const scan = scanTrivia(input, cur, ctx);
-            scan.commit();
-            sepPos = scan.end;
+            sepPos = commitTriviaScan(scanTriviaCompact(input, cur, ctx));
           } else {
             sepPos = advanceTrivia(input, cur, ctx);
           }
@@ -3853,9 +4112,7 @@ function sepBy(combinator, separatorArg, opts = {}) {
         let nextPos = sep.span.end;
         if (ctx.trivia) {
           if (needsDeferredTriviaCommit(ctx)) {
-            const scan = scanTrivia(input, sep.span.end, ctx);
-            scan.commit();
-            nextPos = scan.end;
+            nextPos = commitTriviaScan(scanTriviaCompact(input, sep.span.end, ctx));
           } else {
             nextPos = advanceTrivia(input, sep.span.end, ctx);
           }
@@ -3906,7 +4163,11 @@ function not(combinator) {
       const result = combinator.parse(input, pos, ctx);
       rollbackLookahead(ctx, mark);
       if (result.ok) {
-        return { ok: false, expected: [`not(${combinator._tag})`], span: { start: pos, end: pos } };
+        return {
+          ok: false,
+          expected: assertionFailureExpected(false, combinator._tag),
+          span: { start: pos, end: pos }
+        };
       }
       return { ok: true, value: null, span: { start: pos, end: pos } };
     }
@@ -3930,7 +4191,11 @@ function peek(combinator) {
       const result = combinator.parse(input, pos, ctx);
       rollbackLookahead(ctx, mark);
       if (result.ok) return { ok: true, value: null, span: { start: pos, end: pos } };
-      return { ok: false, expected: [`peek(${combinator._tag})`], span: { start: pos, end: pos } };
+      return {
+        ok: false,
+        expected: assertionFailureExpected(true, combinator._tag),
+        span: { start: pos, end: pos }
+      };
     }
   };
 }
@@ -4857,6 +5122,8 @@ var OP_ATTEMPT = 38;
 var OP_LABEL = 39;
 var OP_COV = 40;
 var OP_SCOPE_PLAIN = 41;
+var OP_LEX_BODY = 42;
+var OP_LEX_PROGRAM = 43;
 var OP_DISPATCH = 25;
 var OP_ROUTED = 26;
 var OP_NAMES = {
@@ -4900,7 +5167,9 @@ var OP_NAMES = {
   [OP_ATTEMPT]: "ATTEMPT",
   [OP_LABEL]: "LABEL",
   [OP_COV]: "COV",
-  [OP_SCOPE_PLAIN]: "SCOPE_PLAIN"
+  [OP_SCOPE_PLAIN]: "SCOPE_PLAIN",
+  [OP_LEX_BODY]: "LEX_BODY",
+  [OP_LEX_PROGRAM]: "LEX_PROGRAM"
 };
 
 // src/table/scan-shapes.ts