parseman 0.37.0 → 0.39.0

package/dist/spec/index.cjs

@@ -108,6 +108,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":
@@ -181,6 +183,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());
@@ -313,6 +317,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;
@@ -384,6 +393,16 @@ function tagRule(r, key) {
   r._ruleName = key;
   if (r._def.tag === "node" && r._def.type === void 0) r._def.type = key;
 }
+function isDefinableRef(v) {
+  return !!v && typeof v === "object" && "_def" in v && v._def.tag === "lazy" && typeof v.define === "function";
+}
+function ruleNameOf(r) {
+  return r._ruleName;
+}
+function isNamedRuleRefForAnotherRule(r, key) {
+  const name = r._def.tag === "lazy" ? ruleNameOf(r) : void 0;
+  return name !== void 0 && name !== key;
+}
 function rules(a, b) {
   const factory = typeof a === "function" ? a : b;
   const options = typeof a === "function" ? b : a;
@@ -404,11 +423,21 @@ function rules(a, b) {
   for (const key of Object.keys(definitions)) {
     const placeholder = cache[key];
     const parser2 = definitions[key];
-    if (placeholder !== void 0 && typeof placeholder.define === "function") {
-      tagRule(parser2, key);
+    if (placeholder === parser2) {
+      throw new Error(`rules(): rule "${key}" cannot be a direct alias to itself`);
+    }
+    if (isDefinableRef(placeholder)) {
+      if (!isNamedRuleRefForAnotherRule(parser2, key)) tagRule(parser2, key);
       placeholder.define(parser2);
       placeholder._meta.firstSet = parser2._meta.firstSet;
       placeholder._meta.canMatchNewline = parser2._meta.canMatchNewline;
+    } else if (isNamedRuleRefForAnotherRule(parser2, key)) {
+      const alias = ref();
+      tagRule(alias, key);
+      alias.define(parser2);
+      alias._meta.firstSet = parser2._meta.firstSet;
+      alias._meta.canMatchNewline = parser2._meta.canMatchNewline;
+      cache[key] = alias;
     } else {
       tagRule(parser2, key);
       cache[key] = parser2;
@@ -703,6 +732,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
@@ -841,6 +872,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 {
@@ -881,6 +913,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];
@@ -1831,6 +1864,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) {
@@ -1874,6 +1908,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;
@@ -1918,6 +1953,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 } };
         }
@@ -1930,6 +1966,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;
@@ -1968,6 +2005,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 } };
     }
   };
@@ -2004,6 +2042,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);
@@ -2031,6 +2070,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);
@@ -2046,6 +2086,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);
@@ -2279,6 +2320,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":
@@ -2393,6 +2436,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);
@@ -2415,6 +2527,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 } };
     }
   };
@@ -2824,6 +2937,9 @@ function evalRuleMapIR(ir) {
     "keywords",
     "sequence",
     "choice",
+    "dispatch",
+    "when",
+    "otherwise",
     "attempt",
     "many",
     "oneOrMore",
@@ -2857,6 +2973,9 @@ function evalRuleMapIR(ir) {
     keywords,
     sequence,
     choice,
+    dispatch,
+    when,
+    otherwise,
     attempt,
     many,
     oneOrMore,
@@ -2947,7 +3066,7 @@ function recoverComposedRules(grammar) {
 }
 
 // src/spec/model.ts
-function ruleNameOf(c) {
+function ruleNameOf2(c) {
   return c._ruleName;
 }
 function resolveLazy(c) {
@@ -3012,7 +3131,7 @@ var Builder = class {
     if (pinned !== void 0) return { kind: "terminal", text: pinned, literal: false };
     let c = comb;
     const guard = /* @__PURE__ */ new Set();
-    while (c._def.tag === "lazy" && ruleNameOf(c) === name && !guard.has(c)) {
+    while (c._def.tag === "lazy" && ruleNameOf2(c) === name && !guard.has(c)) {
       guard.add(c);
       const next = resolveLazy(c);
       if (!next) break;
@@ -3022,7 +3141,7 @@ var Builder = class {
   }
   /** Walk any combinator. `isRuleRoot` suppresses treating it as a self-reference. */
   walk(c, isRuleRoot = false) {
-    const rn = ruleNameOf(c);
+    const rn = ruleNameOf2(c);
     if (rn !== void 0 && !isRuleRoot) {
       if (!this.record[rn]) this.record[rn] = c;
       this.enqueue(rn, c);
@@ -3051,6 +3170,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+`.
@@ -3139,7 +3266,7 @@ function flattenChoice(items) {
 }
 function toRecord(grammar) {
   if (isCombinator(grammar)) {
-    const name = ruleNameOf(grammar) ?? "start";
+    const name = ruleNameOf2(grammar) ?? "start";
     return { [name]: grammar };
   }
   const recovered = recoverComposedRules(grammar);