parseman 0.38.0 → 0.39.0

package/dist/spec/index.js

@@ -74,6 +74,8 @@ function matchesEmpty(p, seen = /* @__PURE__ */ new Set(), resolve) {
       return d.parsers.every(me);
     case "choice":
       return d.parsers.some(me);
+    case "dispatch":
+      return me(d.selector);
     case "transform":
     case "label":
     case "trivia":
@@ -147,6 +149,8 @@ function firstSetOf(p, seen = /* @__PURE__ */ new Set(), resolve) {
     case "keywords":
       return p._meta.firstSet;
     // terminals: no refs, cached set is exact
+    case "dispatch":
+      return fs(d.selector);
     case "lazy":
       try {
         return fs(d.thunk());
@@ -279,6 +283,11 @@ function markUnusedValues(root) {
       case "choice":
         for (const p of def.parsers) visit(p, consumed);
         return;
+      case "dispatch":
+        visit(def.selector, consumed);
+        for (const entry of def.cases) visit(entry.parser, consumed);
+        if (def.otherwise) visit(def.otherwise, consumed);
+        return;
       case "node":
         visit(def.parser, false);
         return;
@@ -689,6 +698,8 @@ function derive(c, seen) {
       return [def.label];
     case "choice":
       return def.parsers.flatMap(deriveExpected2);
+    case "dispatch":
+      return deriveExpected2(def.selector);
     // Union through the NULLABLE prefix, mirroring `sequenceFirstSet`. A leading
     // `optional(…)`/`many(…)` can match nothing, so the term after it is equally
     // able to fail first — deriving from term 0 alone named a token the parse
@@ -827,6 +838,7 @@ function choice(...args) {
           const result = parsers[idx].parse(input, pos, ctx);
           if (result.ok) return result;
           expected.push(...result.expected);
+          if (result.committed) return { ok: false, expected, span: { start: pos, end: pos }, committed: true };
           return { ok: false, expected, span: { start: pos, end: pos } };
         }
         return {
@@ -867,6 +879,7 @@ function choice(...args) {
           rollbackCstCapture(ctx, mark);
           if (logLen !== void 0 && ctx._triviaLog && ctx._triviaLog.length !== logLen) ctx._triviaLog.length = logLen;
           expected.push(...result.expected);
+          if (result.committed) return { ok: false, expected, span: result.span, committed: true };
           continue;
         }
         const checks = autoNot[i];
@@ -1817,6 +1830,7 @@ function repItem(combinator, input, cur, ctx, guardable) {
   const result = combinator.parse(input, pos, ctx);
   if (!result.ok) {
     rollbackTrivia(ctx, mark);
+    if (result.committed) return { fail: result, failPos: pos };
     return { fail: result, failPos: pos };
   }
   if (result.span.end === pos) {
@@ -1860,6 +1874,7 @@ function many(combinator, opts = {}) {
         const item = repItem(combinator, input, cur, ctx, guardable);
         if (item === "stop") break;
         if ("fail" in item) {
+          if (!item.fail.ok && item.fail.committed) return item.fail;
           const sync = ctx._tolerant ? ctx._sync : void 0;
           if (sync === void 0) break;
           if (matchesAt(sync, input, item.failPos, ctx)) break;
@@ -1904,6 +1919,7 @@ function atLeast(combinator, min, max) {
       while (count < min) {
         const item = repItem(combinator, input, cur, ctx, guardable);
         if (item === "stop" || "fail" in item) {
+          if (item !== "stop" && !item.fail.ok && item.fail.committed) return item.fail;
           expected ??= deriveExpected(combinator);
           return { ok: false, expected: expected.length > 0 ? expected : [combinator._tag], span: { start: cur, end: cur } };
         }
@@ -1916,6 +1932,7 @@ function atLeast(combinator, min, max) {
         const item = repItem(combinator, input, cur, ctx, guardable);
         if (item === "stop") break;
         if ("fail" in item) {
+          if (!item.fail.ok && item.fail.committed) return item.fail;
           const sync = ctx._tolerant ? ctx._sync : void 0;
           if (sync === void 0) break;
           if (matchesAt(sync, input, item.failPos, ctx)) break;
@@ -1954,6 +1971,7 @@ function optional(combinator) {
       const result = combinator.parse(input, pos, ctx);
       if (result.ok) return result;
       rollbackTrivia(ctx, mark);
+      if (result.committed) return result;
       return { ok: true, value: null, span: { start: pos, end: pos } };
     }
   };
@@ -1990,6 +2008,7 @@ function sepBy(combinator, separator, opts = {}) {
         values.push(first.value);
         cur = first.span.end;
       } else {
+        if (first.committed) return first;
         const term = ctx._tolerant ? ctx._sync : void 0;
         if (term === void 0 || matchesAt(term, input, pos, ctx)) {
           if (min >= 1) return failAt2(pos);
@@ -2017,6 +2036,7 @@ function sepBy(combinator, separator, opts = {}) {
         const sep = separator.parse(input, sepPos, ctx);
         if (!sep.ok) {
           rollbackTrivia(ctx, loopMark);
+          if (sep.committed) return sep;
           break;
         }
         const sepMark = trailing === "forbid" ? void 0 : saveTriviaMark(ctx);
@@ -2032,6 +2052,7 @@ function sepBy(combinator, separator, opts = {}) {
         }
         const next = combinator.parse(input, nextPos, ctx);
         if (!next.ok) {
+          if (next.committed) return next;
           const term = ctx._tolerant ? ctx._sync : void 0;
           if (term !== void 0 && !matchesAt(term, input, nextPos, ctx)) {
             expected ??= deriveExpected(combinator);
@@ -2265,6 +2286,8 @@ function parserHasOwnFields(p, seen = /* @__PURE__ */ new Set()) {
     case "sequence":
     case "choice":
       return d.parsers.some((x) => parserHasOwnFields(x, seen));
+    case "dispatch":
+      return parserHasOwnFields(d.selector, seen) || d.cases.some((x) => parserHasOwnFields(x.parser, seen)) || (d.otherwise ? parserHasOwnFields(d.otherwise, seen) : false);
     case "sepBy":
       return parserHasOwnFields(d.parser, seen) || parserHasOwnFields(d.separator, seen);
     case "skip":
@@ -2379,6 +2402,75 @@ function keywords(words, opts = {}) {
   };
 }
 
+// src/combinators/dispatch.ts
+function when(key, parser2) {
+  const keys = Array.isArray(key) ? [...key] : [key];
+  if (keys.length === 0) throw new RangeError("parseman: when() requires at least one key");
+  for (const item of keys) {
+    if (typeof item !== "string") throw new TypeError("parseman: when() keys must be strings");
+  }
+  return { kind: "when", keys, parser: parser2 };
+}
+function otherwise(parser2) {
+  return { kind: "otherwise", parser: parser2 };
+}
+function dispatch(selector, ...arms) {
+  let fallback;
+  const cases = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = 0; i < arms.length; i++) {
+    const arm = arms[i];
+    if (arm.kind === "otherwise") {
+      if (fallback !== void 0) throw new Error("parseman: dispatch() accepts at most one otherwise() arm");
+      if (i !== arms.length - 1) throw new Error("parseman: otherwise() must be the last dispatch() arm");
+      fallback = arm.parser;
+      continue;
+    }
+    for (const key of arm.keys) {
+      if (seen.has(key)) throw new Error(`parseman: duplicate dispatch key ${JSON.stringify(key)}`);
+      seen.add(key);
+    }
+    cases.push({ keys: arm.keys, parser: arm.parser });
+  }
+  const meta = {
+    firstSet: selector._meta.firstSet,
+    canMatchNewline: selector._meta.canMatchNewline || cases.some((entry) => entry.parser._meta.canMatchNewline) || (fallback?._meta.canMatchNewline ?? false),
+    isTrivia: false
+  };
+  const byKey = /* @__PURE__ */ new Map();
+  for (const entry of cases) for (const key of entry.keys) byKey.set(key, entry.parser);
+  return {
+    _tag: "dispatch",
+    _meta: meta,
+    _def: {
+      tag: "dispatch",
+      selector,
+      cases,
+      ...fallback === void 0 ? {} : { otherwise: fallback }
+    },
+    parse(input, pos, ctx) {
+      const selected = selector.parse(input, pos, ctx);
+      if (!selected.ok) return selected;
+      const tail = byKey.get(selected.value) ?? fallback;
+      if (tail === void 0) {
+        const expected = cases.flatMap((entry) => entry.keys.map((key) => JSON.stringify(key)));
+        return { ok: false, expected, span: { start: selected.span.end, end: selected.span.end } };
+      }
+      const mark = saveTriviaMark(ctx);
+      const result = tail.parse(input, selected.span.end, ctx);
+      if (!result.ok) {
+        rollbackTrivia(ctx, mark);
+        return { ...result, committed: true };
+      }
+      return {
+        ok: true,
+        value: [selected.value, result.value],
+        span: { start: pos, end: result.span.end }
+      };
+    }
+  };
+}
+
 // src/combinators/attempt.ts
 function attempt(parser2) {
   const guardable = parser2._meta.firstSet.kind !== "any" && !matchesEmpty(parser2);
@@ -2401,6 +2493,7 @@ function attempt(parser2) {
       if (result.ok) return result;
       rollbackCstCapture(ctx, mark);
       if (log !== void 0 && ctx._triviaLog && ctx._triviaLog.length !== log) ctx._triviaLog.length = log;
+      if (result.committed) return result;
       return { ok: false, expected: result.expected, span: { start: pos, end: pos } };
     }
   };
@@ -2810,6 +2903,9 @@ function evalRuleMapIR(ir) {
     "keywords",
     "sequence",
     "choice",
+    "dispatch",
+    "when",
+    "otherwise",
     "attempt",
     "many",
     "oneOrMore",
@@ -2843,6 +2939,9 @@ function evalRuleMapIR(ir) {
     keywords,
     sequence,
     choice,
+    dispatch,
+    when,
+    otherwise,
     attempt,
     many,
     oneOrMore,
@@ -3037,6 +3136,14 @@ var Builder = class {
         const items = def.parsers.map((p) => this.walk(p)).filter(nonEmpty);
         return flattenChoice(items);
       }
+      case "dispatch": {
+        const selector = this.walk(def.selector);
+        const tails = [
+          ...def.cases.map((entry) => this.walk(entry.parser)),
+          ...def.otherwise ? [this.walk(def.otherwise)] : []
+        ].filter(nonEmpty);
+        return flattenSeq([selector, flattenChoice(tails)]);
+      }
       // `max`/`min` are carried through so a BOUNDED repeat does not render as an
       // unbounded one — the spec is generated to be read as the truth about what
       // parses, and `many(x, { min: 3, max: 8 })` is not `x+`.