parseman 0.50.5 → 0.50.7

package/dist/spec/index.js

@@ -31,7 +31,7 @@ function intersects(a, b) {
   return false;
 }
 function fromChar(code) {
-  return { kind: "ranges", ranges: [{ lo: code, hi: code }] };
+  return fromRange(code, code);
 }
 function startsFirstSet(combinator, input, pos) {
   const fs = combinator._meta.firstSet;
@@ -124,11 +124,10 @@ function matchesEmptyBody(p, seen, resolve) {
   }
 }
 function isZeroWidthAssertion(p) {
-  const tag = p._def.tag;
-  return tag === "not" || tag === "adjacency";
+  return p._tag === "not" || p._tag === "adjacency";
 }
 function isPositiveLookahead(p) {
-  return p._def.tag === "peek";
+  return p._tag === "peek";
 }
 function narrowBy(acc, constraint) {
   if (constraint.kind === "any") return acc;
@@ -144,34 +143,42 @@ function narrowBy(acc, constraint) {
   return ranges.length === 0 ? { kind: "empty" } : { kind: "ranges", ranges };
 }
 function applyAssertion(fs, assertion) {
-  if (assertion === null) return fs;
-  if (fs.kind === "empty") return assertion;
-  return narrowBy(fs, assertion) ?? fs;
+  return assertion === null ? fs : fs.kind === "empty" ? assertion : narrowBy(fs, assertion);
 }
-function sequenceFirstSet(parsers) {
-  let fs = empty();
-  let assertion = null;
-  for (const p of parsers) {
+function sequenceSet(parsers, fs, empties, trivia2) {
+  const afterBoundary = (i) => {
+    const rest = at(i);
+    return trivia2 ? union(rest, fs(trivia2)) : rest;
+  };
+  const at = (i) => {
+    const p = parsers[i];
     if (isPositiveLookahead(p)) {
-      assertion = narrowBy(assertion, p._meta.firstSet);
-      continue;
+      const constraint = fs(p);
+      return i + 1 === parsers.length ? constraint : applyAssertion(afterBoundary(i + 1), constraint);
     }
-    if (!isZeroWidthAssertion(p)) fs = union(fs, p._meta.firstSet);
-    if (!matchesEmpty(p)) return applyAssertion(fs, assertion);
-  }
-  return applyAssertion(fs, assertion);
+    if (isZeroWidthAssertion(p)) {
+      return i + 1 === parsers.length ? empty() : afterBoundary(i + 1);
+    }
+    const first = fs(p);
+    if (!empties(p) || i + 1 === parsers.length) return first;
+    return union(first, afterBoundary(i + 1));
+  };
+  return at(0);
 }
-function firstSetOf(p, seen = /* @__PURE__ */ new Set(), resolve) {
+function sequenceFirstSet(parsers) {
+  return sequenceSet(parsers, (p) => p._meta.firstSet, matchesEmpty);
+}
+function firstSetOf(p, seen = /* @__PURE__ */ new Set(), resolve, activeTrivia) {
   if (seen.has(p)) return any();
   seen.add(p);
   try {
-    return firstSetBody(p, seen, resolve);
+    return firstSetBody(p, seen, resolve, activeTrivia);
   } finally {
     seen.delete(p);
   }
 }
-function firstSetBody(p, seen, resolve) {
-  const fs = (c) => firstSetOf(c, seen, resolve);
+function firstSetBody(p, seen, resolve, activeTrivia) {
+  const fs = (c) => firstSetOf(c, seen, resolve, activeTrivia);
   const empties = (c) => matchesEmpty(c, /* @__PURE__ */ new Set(), resolve);
   const d = p._def;
   switch (d.tag) {
@@ -197,17 +204,7 @@ function firstSetBody(p, seen, resolve) {
       return out;
     }
     case "sequence": {
-      let out = empty();
-      let assertion = null;
-      for (const term of d.parsers) {
-        if (isPositiveLookahead(term)) {
-          assertion = narrowBy(assertion, fs(term));
-          continue;
-        }
-        if (!isZeroWidthAssertion(term)) out = union(out, fs(term));
-        if (!empties(term)) return applyAssertion(out, assertion);
-      }
-      return applyAssertion(out, assertion);
+      return sequenceSet(d.parsers, fs, empties, activeTrivia);
     }
     case "peek": {
       const inner = d.parser;
@@ -222,12 +219,16 @@ function firstSetBody(p, seen, resolve) {
     case "token":
     case "leaf":
     case "node":
-    case "grammar":
-    case "expect":
-      return fs(d.parser);
     case "sepBy":
+    case "expect":
       return fs(d.parser);
-    // both min 0 and min 1 start with the item
+    case "grammar":
+      return firstSetOf(
+        d.parser,
+        seen,
+        resolve,
+        d.clearTrivia ? null : d.triviaParser ?? activeTrivia
+      );
     default:
       return p._meta.firstSet;
   }