parseman 0.39.0 → 0.39.1

package/dist/spec/index.js

@@ -48,6 +48,8 @@ function matchesEmpty(p, seen = /* @__PURE__ */ new Set(), resolve) {
       return d.value.length === 0;
     case "keywords":
       return false;
+    case "routed":
+      return false;
     case "regex":
       try {
         const m = new RegExp(d.source).exec("");
@@ -286,6 +288,7 @@ function markUnusedValues(root) {
       case "dispatch":
         visit(def.selector, consumed);
         for (const entry of def.cases) visit(entry.parser, consumed);
+        if (def.matchers) for (const entry of def.matchers) visit(entry.parser, consumed);
         if (def.otherwise) visit(def.otherwise, consumed);
         return;
       case "node":
@@ -739,6 +742,8 @@ function derive(c, seen) {
     case "not":
     case "peek":
       return deriveExpected2(def.parser);
+    case "routed":
+      return ["routed()"];
     case "lazy": {
       const name = c._ruleName;
       if (seen.has(c)) return name ? [name] : [];
@@ -2287,7 +2292,7 @@ function parserHasOwnFields(p, seen = /* @__PURE__ */ new Set()) {
     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);
+      return parserHasOwnFields(d.selector, seen) || d.cases.some((x) => parserHasOwnFields(x.parser, seen)) || (d.matchers ? d.matchers.some((entry) => parserHasOwnFields(entry.parser, seen)) : false) || (d.otherwise ? parserHasOwnFields(d.otherwise, seen) : false);
     case "sepBy":
       return parserHasOwnFields(d.parser, seen) || parserHasOwnFields(d.separator, seen);
     case "skip":
@@ -2403,42 +2408,195 @@ function keywords(words, opts = {}) {
 }
 
 // src/combinators/dispatch.ts
-function when(key, parser2) {
+function parserUsesRouted(parser2, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(parser2)) return false;
+  seen.add(parser2);
+  const def = parser2._def;
+  switch (def.tag) {
+    case "routed":
+      return true;
+    case "sequence":
+    case "choice":
+      return def.parsers.some((entry) => parserUsesRouted(entry, seen));
+    case "dispatch":
+      return false;
+    case "sepBy":
+      return parserUsesRouted(def.parser, seen) || parserUsesRouted(def.separator, seen);
+    case "skip":
+      return parserUsesRouted(def.main, seen) || parserUsesRouted(def.skipped, seen);
+    case "grammar":
+      return parserUsesRouted(def.parser, seen) || (def.triviaParser ? parserUsesRouted(def.triviaParser, seen) : false);
+    case "scanTo":
+      return parserUsesRouted(def.sentinel, seen) || def.skip.some((entry) => parserUsesRouted(entry, seen));
+    case "recover":
+      return parserUsesRouted(def.parser, seen) || parserUsesRouted(def.sentinel, seen);
+    case "lazy":
+      try {
+        return parserUsesRouted(def.thunk(), seen);
+      } catch {
+        return false;
+      }
+    case "many":
+    case "oneOrMore":
+    case "optional":
+    case "attempt":
+    case "transform":
+    case "trivia":
+    case "token":
+    case "leaf":
+    case "label":
+    case "field":
+    case "not":
+    case "peek":
+    case "node":
+    case "withCtx":
+    case "expect":
+      return parserUsesRouted(def.parser, seen);
+    default:
+      return false;
+  }
+}
+function branchUsesRouted(branch) {
+  return branch.usesRouted === true || parserUsesRouted(branch.parser);
+}
+function asciiFoldKey(key) {
+  let out = "";
+  for (let i = 0; i < key.length; i++) {
+    const c = key.charCodeAt(i);
+    out += String.fromCharCode(c >= 65 && c <= 90 ? c + 32 : c);
+  }
+  return out;
+}
+function matchesDispatchMatcher(value, matcher) {
+  const candidate = matcher.caseInsensitive ? asciiFoldKey(value) : value;
+  const expected = matcher.caseInsensitive ? asciiFoldKey(matcher.value) : matcher.value;
+  switch (matcher.kind) {
+    case "startsWith":
+      return candidate.startsWith(expected);
+    case "endsWith":
+      return candidate.endsWith(expected);
+    case "matches": {
+      const flags = matcher.caseInsensitive && !matcher.flags?.includes("i") ? `${matcher.flags ?? ""}i` : matcher.flags ?? "";
+      return new RegExp(matcher.value, flags).test(value);
+    }
+  }
+}
+function isStringMatcher(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const kind = value.kind;
+  return kind === "startsWith" || kind === "endsWith" || kind === "matches";
+}
+function fixedMatcher(kind, value) {
+  if (typeof value !== "string") throw new TypeError(`parseman: ${kind}() value must be a string`);
+  if (value.length === 0) throw new RangeError(`parseman: ${kind}() requires a non-empty value`);
+  return { kind, value };
+}
+function startsWith(prefix) {
+  return fixedMatcher("startsWith", prefix);
+}
+function endsWith(suffix) {
+  return fixedMatcher("endsWith", suffix);
+}
+function matches(pattern) {
+  if (!(pattern instanceof RegExp)) throw new TypeError("parseman: matches() requires a RegExp");
+  if (pattern.flags.includes("g") || pattern.flags.includes("y")) {
+    throw new TypeError("parseman: matches() does not accept global or sticky regex flags");
+  }
+  return { kind: "matches", value: pattern.source, flags: pattern.flags };
+}
+function when(key, parser2, opts = {}) {
+  const usesRouted = parserUsesRouted(parser2);
+  if (isStringMatcher(key)) {
+    return { kind: "whenMatcher", matcher: key, parser: parser2, caseInsensitive: opts.caseInsensitive ?? false, usesRouted };
+  }
   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 };
+  return { kind: "when", keys, parser: parser2, caseInsensitive: opts.caseInsensitive ?? false, usesRouted };
 }
 function otherwise(parser2) {
-  return { kind: "otherwise", parser: parser2 };
+  return { kind: "otherwise", parser: parser2, usesRouted: parserUsesRouted(parser2) };
+}
+function routed() {
+  return {
+    _tag: "routed",
+    _meta: { firstSet: { kind: "any" }, canMatchNewline: false, isTrivia: false },
+    _def: { tag: "routed" },
+    parse(_input, pos, ctx) {
+      const item = ctx._routed;
+      if (item === void 0) {
+        return { ok: false, expected: ["routed()"], span: { start: pos, end: pos } };
+      }
+      if (pos !== item.span.start) {
+        return { ok: false, expected: ["routed()"], span: { start: pos, end: pos } };
+      }
+      if (cstCaptureActive(ctx)) {
+        pushCstLeaf(ctx, { _tag: "leaf", value: item.value, span: item.span });
+      }
+      return { ok: true, value: item.value, span: item.span };
+    }
+  };
 }
 function dispatch(selector, ...arms) {
+  if (parserUsesRouted(selector)) {
+    throw new Error("parseman: routed() can only appear inside a dispatch() branch");
+  }
   let fallback;
+  let fallbackUsesRouted = false;
+  const matchers = [];
   const cases = [];
-  const seen = /* @__PURE__ */ new Set();
+  const seen = [];
   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;
+      fallbackUsesRouted = arm.usesRouted === true;
+      continue;
+    }
+    if (arm.kind === "whenMatcher") {
+      const matcher = arm.matcher;
+      matchers.push({
+        kind: matcher.kind,
+        value: matcher.value,
+        ...matcher.kind === "matches" ? { flags: matcher.flags } : {},
+        parser: arm.parser,
+        caseInsensitive: arm.caseInsensitive,
+        ...arm.usesRouted === true ? { usesRouted: true } : {}
+      });
       continue;
     }
     for (const key of arm.keys) {
-      if (seen.has(key)) throw new Error(`parseman: duplicate dispatch key ${JSON.stringify(key)}`);
-      seen.add(key);
+      const folded = asciiFoldKey(key);
+      for (const prior of seen) {
+        const overlaps = arm.caseInsensitive || prior.caseInsensitive ? folded === prior.folded : key === prior.raw;
+        if (overlaps) throw new Error(`parseman: duplicate dispatch key ${JSON.stringify(key)}`);
+      }
+      seen.push({ raw: key, folded, caseInsensitive: arm.caseInsensitive });
     }
-    cases.push({ keys: arm.keys, parser: arm.parser });
+    cases.push({
+      keys: arm.keys,
+      parser: arm.parser,
+      caseInsensitive: arm.caseInsensitive,
+      ...arm.usesRouted === true ? { usesRouted: true } : {}
+    });
   }
   const meta = {
     firstSet: selector._meta.firstSet,
-    canMatchNewline: selector._meta.canMatchNewline || cases.some((entry) => entry.parser._meta.canMatchNewline) || (fallback?._meta.canMatchNewline ?? false),
+    canMatchNewline: selector._meta.canMatchNewline || cases.some((entry) => entry.parser._meta.canMatchNewline) || matchers.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);
+  const byFoldedKey = /* @__PURE__ */ new Map();
+  for (const entry of cases) {
+    for (const key of entry.keys) {
+      if (entry.caseInsensitive) byFoldedKey.set(asciiFoldKey(key), entry);
+      else byKey.set(key, entry);
+    }
+  }
   return {
     _tag: "dispatch",
     _meta: meta,
@@ -2446,18 +2604,35 @@ function dispatch(selector, ...arms) {
       tag: "dispatch",
       selector,
       cases,
-      ...fallback === void 0 ? {} : { otherwise: fallback }
+      ...matchers.length === 0 ? {} : { matchers },
+      ...fallback === void 0 ? {} : { otherwise: fallback, ...fallbackUsesRouted ? { otherwiseUsesRouted: true } : {} }
     },
     parse(input, pos, ctx) {
+      if (parserUsesRouted(selector)) {
+        throw new Error("parseman: routed() can only appear inside a dispatch() branch");
+      }
+      const selectorMark = saveTriviaMark(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 branch = byKey.get(selected.value) ?? (byFoldedKey.size === 0 ? void 0 : byFoldedKey.get(asciiFoldKey(selected.value))) ?? matchers.find((matcher) => matchesDispatchMatcher(selected.value, matcher)) ?? (fallback === void 0 ? void 0 : { keys: [], parser: fallback, caseInsensitive: false, usesRouted: fallbackUsesRouted });
+      if (branch === 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);
+      const savedRouted = ctx._routed;
+      const usesRouted = branchUsesRouted(branch);
+      let mark = saveTriviaMark(ctx);
+      if (usesRouted) {
+        rollbackTrivia(ctx, selectorMark);
+        mark = saveTriviaMark(ctx);
+        ctx._routed = { value: selected.value, span: selected.span };
+      }
+      let result;
+      try {
+        result = branch.parser.parse(input, usesRouted ? pos : selected.span.end, ctx);
+      } finally {
+        if (usesRouted) ctx._routed = savedRouted;
+      }
       if (!result.ok) {
         rollbackTrivia(ctx, mark);
         return { ...result, committed: true };
@@ -2905,7 +3080,11 @@ function evalRuleMapIR(ir) {
     "choice",
     "dispatch",
     "when",
+    "startsWith",
+    "endsWith",
+    "matches",
     "otherwise",
+    "routed",
     "attempt",
     "many",
     "oneOrMore",
@@ -2941,7 +3120,11 @@ function evalRuleMapIR(ir) {
     choice,
     dispatch,
     when,
+    startsWith,
+    endsWith,
+    matches,
     otherwise,
+    routed,
     attempt,
     many,
     oneOrMore,
@@ -3140,8 +3323,9 @@ var Builder = class {
         const selector = this.walk(def.selector);
         const tails = [
           ...def.cases.map((entry) => this.walk(entry.parser)),
+          ...def.matchers ? def.matchers.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
@@ -3173,6 +3357,8 @@ var Builder = class {
         return { kind: "not", item: this.walk(def.parser) };
       case "peek":
         return { kind: "peek", item: this.walk(def.parser) };
+      case "routed":
+        return { kind: "empty" };
       // Transparent semantic wrappers — render the inner syntax.
       case "transform":
       case "token":
@@ -3330,7 +3516,7 @@ function render(node2) {
     case "choice": {
       const text = node2.items.map((it) => {
         const r = render(it);
-        return wrap(r.text, r.level, ALT);
+        return r.text.length === 0 ? "/* empty */" : wrap(r.text, r.level, ALT);
       }).join(" | ");
       return { text, level: ALT };
     }