parseman 0.37.0 → 0.38.0

package/dist/combinators/keywords.d.ts

@@ -8,6 +8,7 @@ export type KeywordsOptions = {
      */
     boundary?: string;
 };
+export type WordOptions = Omit<KeywordsOptions, 'boundary'>;
 /**
  * Match a single keyword with an automatic word-boundary guard. Prevents
  * matching `true` inside `trueish`. The boundary defaults to `_0-9A-Za-z`,
@@ -24,21 +25,21 @@ export type KeywordsOptions = {
  * `regex(/media/i)` — which `analyzeGating` correctly flags as the `keyword-regex`
  * anti-pattern — or `keywords(['media'], …)` for a single word.
  */
-export declare function word(str: string, boundary?: string, opts?: Omit<KeywordsOptions, 'boundary'>): Combinator<string>;
-export declare function word(str: string, opts: Omit<KeywordsOptions, 'boundary'>): Combinator<string>;
+export declare function word(str: string, boundary?: string, opts?: WordOptions): Combinator<string>;
+export declare function word(str: string, opts: WordOptions): Combinator<string>;
 /**
  * Create a keyword factory with a fixed word-boundary class. Use when many
  * keywords share the same boundary (e.g. CSS identifiers). For a single keyword,
- * `word(str, boundary?)` is enough; you can also roll your own factory with
- * `(s) => word(s, boundary)`.
+ * `word(str, boundary?)` is enough.
  *
- *   const kw = makeWord()                    // default: '_0-9A-Za-z'
- *   const cssKw = makeWord('A-Za-z0-9_-')    // dashes allowed in CSS idents
+ *   const kw = makeWord()                                      // default boundary
+ *   const cssKw = makeWord('A-Za-z0-9_-', { caseInsensitive: true })
  *
  *   const query = kw('query')
- *   const color = cssKw('color')             // matches "color" but not "color-scheme"
+ *   const color = cssKw('color')                               // matches "COLOR" but not "color-scheme"
  */
-export declare function makeWord(boundary?: string): (str: string) => Combinator<string>;
+export declare function makeWord(boundary?: string, opts?: WordOptions): (str: string) => Combinator<string>;
+export declare function makeWord(opts: WordOptions): (str: string) => Combinator<string>;
 /**
  * Match any one of a set of fixed keywords, longest-first (so `border` wins over
  * `bord`), with an optional trailing word-boundary guard. Compiles to a single

package/dist/combinators/keywords.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"keywords.d.ts","sourceRoot":"","sources":["../../src/combinators/keywords.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAmD,MAAM,aAAa,CAAA;AAM9F,MAAM,MAAM,eAAe,GAAG;IAC5B,gCAAgC;IAChC,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,CAAA;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,IAAI,CAAC,eAAe,EAAE,UAAU,CAAC,GAAG,UAAU,CAAC,MAAM,CAAC,CAAA;AAClH,wBAAgB,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,eAAe,EAAE,UAAU,CAAC,GAAG,UAAU,CAAC,MAAM,CAAC,CAAA;AAW9F;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,SAAe,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK,UAAU,CAAC,MAAM,CAAC,CAErF;AAMD;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,EAAE,IAAI,GAAE,eAAoB,GAAG,UAAU,CAAC,MAAM,CAAC,CA8DjG"}
+{"version":3,"file":"keywords.d.ts","sourceRoot":"","sources":["../../src/combinators/keywords.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAmD,MAAM,aAAa,CAAA;AAM9F,MAAM,MAAM,eAAe,GAAG;IAC5B,gCAAgC;IAChC,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,MAAM,MAAM,WAAW,GAAG,IAAI,CAAC,eAAe,EAAE,UAAU,CAAC,CAAA;AAE3D;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,UAAU,CAAC,MAAM,CAAC,CAAA;AAC5F,wBAAgB,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,GAAG,UAAU,CAAC,MAAM,CAAC,CAAA;AAWxE;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK,UAAU,CAAC,MAAM,CAAC,CAAA;AACpG,wBAAgB,QAAQ,CAAC,IAAI,EAAE,WAAW,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK,UAAU,CAAC,MAAM,CAAC,CAAA;AAchF;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,EAAE,IAAI,GAAE,eAAoB,GAAG,UAAU,CAAC,MAAM,CAAC,CA8DjG"}

package/dist/combinators/parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/combinators/parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAC7C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAA;AAItD;;;;GAIG;AACH,eAAO,MAAM,UAAU,wBAAwB,CAAA;AAO/C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB;8EAC0E;IAC1E,MAAM,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,IAAI,CAAA;IACnC;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,GAAG,IAAI,CAAA;IACvC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,QAAQ,CAAC,EAAE,QAAQ,CAAA;CACpB,CAAA;AAKD,wBAAgB,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,CAAC,GAAG,CAAC,CAAA;AAClG,wBAAgB,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,EAAE,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,CAAC,GAAG,CAAC,CAAA"}
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/combinators/parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAC7C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAA;AAItD;;;;GAIG;AACH,eAAO,MAAM,UAAU,wBAAwB,CAAA;AA0B/C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB;8EAC0E;IAC1E,MAAM,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,IAAI,CAAA;IACnC;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,GAAG,IAAI,CAAA;IACvC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,QAAQ,CAAC,EAAE,QAAQ,CAAA;CACpB,CAAA;AAKD,wBAAgB,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,CAAC,GAAG,CAAC,CAAA;AAClG,wBAAgB,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,EAAE,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,CAAC,GAAG,CAAC,CAAA"}

package/dist/index.cjs

@@ -1036,8 +1036,10 @@ function word(str, boundaryOrOpts, opts) {
   const rest = typeof boundaryOrOpts === "object" && boundaryOrOpts !== null ? boundaryOrOpts : opts;
   return keywords([str], { ...rest, boundary });
 }
-function makeWord(boundary = "_0-9A-Za-z") {
-  return (str) => keywords([str], { boundary });
+function makeWord(boundaryOrOpts = "_0-9A-Za-z", opts) {
+  const boundary = typeof boundaryOrOpts === "string" ? boundaryOrOpts : "_0-9A-Za-z";
+  const rest = typeof boundaryOrOpts === "object" && boundaryOrOpts !== null ? boundaryOrOpts : opts;
+  return (str) => keywords([str], { ...rest, boundary });
 }
 function escapeRe(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -2474,6 +2476,16 @@ function tagRule(r, key) {
   r._ruleName = key;
   if (r._def.tag === "node" && r._def.type === void 0) r._def.type = key;
 }
+function isDefinableRef(v2) {
+  return !!v2 && typeof v2 === "object" && "_def" in v2 && v2._def.tag === "lazy" && typeof v2.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;
@@ -2494,11 +2506,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;
@@ -3151,7 +3173,7 @@ function leaf(root, fn) {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.37.0";
+var PARSEMAN_VERSION = "0.38.0";
 
 // src/cst/host-mode.ts
 var FUSED_HOST_MODE = /* @__PURE__ */ Symbol.for("parseman.fusedHostMode");
@@ -3205,7 +3227,7 @@ function firstSetToString(fs) {
   if (fs.kind === "empty") return "(empty)";
   return fs.ranges.map((r) => r.lo === r.hi ? ch(r.lo) : `${ch(r.lo)}-${ch(r.hi)}`).join(",");
 }
-var ruleNameOf = (p) => p._ruleName;
+var ruleNameOf2 = (p) => p._ruleName;
 var SUGGESTIONS = {
   "broad-recognizer": "if this arm leads with a keyword regex, use word('kw', boundary) / keywords([...]) \u2014 they expose an EXACT, gating first-set and lower to the same charCodeAt scan. A genuine scanTo fallback is fine; accept it in the gating snapshot if intentional.",
   "leading-not": "let the arm lead with its actual consuming terminal (first-sets gate it automatically); keep not(...) only as a TRAILING boundary. Do not hand-roll not(not(...)) to fake gating \u2014 use peek(X), which is zero-width AND carries X first-set.",
@@ -3363,7 +3385,7 @@ function detectAntiPatterns(rule, arms) {
   return out;
 }
 function analyzeGating(entry, opts) {
-  return analyzeGatingRules([[ruleNameOf(entry) ?? opts?.entryName ?? "<entry>", entry]], opts);
+  return analyzeGatingRules([[ruleNameOf2(entry) ?? opts?.entryName ?? "<entry>", entry]], opts);
 }
 function analyzeGatingRules(ruleMap, opts) {
   const raw = [];
@@ -3396,7 +3418,7 @@ function analyzeGatingRules(ruleMap, opts) {
       return;
     }
     const d = def;
-    const rule = ruleNameOf(p) ?? enclosingRule;
+    const rule = ruleNameOf2(p) ?? enclosingRule;
     if (d.tag === "choice") {
       raw.push({ g: analyzeChoice(p, d, rule, opts?.resolveRef), rule });
       antiPatterns.push(...detectAntiPatterns(rule, d.parsers));
@@ -3415,7 +3437,7 @@ function analyzeGatingRules(ruleMap, opts) {
     }
     for (const k of kids) visit(k, rule);
   };
-  for (const [name, root] of ruleMap) visit(root, ruleNameOf(root) ?? name);
+  for (const [name, root] of ruleMap) visit(root, ruleNameOf2(root) ?? name);
   const perRule = /* @__PURE__ */ new Map();
   for (const r of raw) perRule.set(r.rule, (perRule.get(r.rule) ?? 0) + 1);
   const seenInRule = /* @__PURE__ */ new Map();
@@ -3539,7 +3561,7 @@ function childrenOf(d) {
     }
   }
 }
-var ruleNameOf2 = (p) => p._ruleName;
+var ruleNameOf3 = (p) => p._ruleName;
 var fnKey = (src, fn) => src ?? (typeof fn === "function" ? String(fn) : "");
 function payloadKey(p, d) {
   switch (d.tag) {
@@ -3550,7 +3572,7 @@ function payloadKey(p, d) {
     case "keywords":
       return `keywords\0${[...d.words].join("
")}\0${d.caseInsensitive}\0${d.boundary ?? ""}`;
     case "lazy": {
-      const n = ruleNameOf2(p);
+      const n = ruleNameOf3(p);
       return n === void 0 ? `ref\0#${anonId(p)}` : `ref\0${n}`;
     }
     case "label":
@@ -3617,7 +3639,7 @@ var Interner = class {
 var MAX_RENDER = 160;
 function render(p, depth = 3) {
   const d = p._def;
-  const name = ruleNameOf2(p);
+  const name = ruleNameOf3(p);
   switch (d.tag) {
     case "literal":
       return `literal('${d.value}')`;
@@ -3796,7 +3818,7 @@ function keywordAlternationHazards(words, boundary) {
   return out;
 }
 function analyzeDuplication(entry, opts) {
-  return analyzeDuplicationRules([[ruleNameOf2(entry) ?? opts?.entryName ?? "<entry>", entry]], opts);
+  return analyzeDuplicationRules([[ruleNameOf3(entry) ?? opts?.entryName ?? "<entry>", entry]], opts);
 }
 function assertAnalyzable(ruleMap) {
   for (const [name, rule] of ruleMap) {
@@ -3837,7 +3859,7 @@ function analyzeDuplicationRules(ruleMap, opts) {
   const visit = (p, rule, path, enclosingNode, enclosingReducer) => {
     if (visited.has(p)) return;
     const d = p._def;
-    const own = ruleNameOf2(p);
+    const own = ruleNameOf3(p);
     const here = own !== void 0 && own !== rule ? { rule: own, path: "" } : { rule, path };
     visited.set(p, { p, d, site: here, shape: shapeOf(p), size: sizeOf(p), enclosingNode, enclosingReducer });
     const inner = d.tag === "node" ? d.type ?? "(anonymous)" : enclosingNode;
@@ -3850,12 +3872,12 @@ function analyzeDuplicationRules(ruleMap, opts) {
     if (d.tag === "lazy") {
       try {
         const target = d.thunk();
-        visit(target, ruleNameOf2(target) ?? ruleNameOf2(p) ?? here.rule, "", null, false);
+        visit(target, ruleNameOf3(target) ?? ruleNameOf3(p) ?? here.rule, "", null, false);
       } catch {
       }
     }
   };
-  for (const [name, root] of ruleMap) visit(root, ruleNameOf2(root) ?? name, "", null, false);
+  for (const [name, root] of ruleMap) visit(root, ruleNameOf3(root) ?? name, "", null, false);
   const accept = new Set(opts?.accept ?? []);
   const used = /* @__PURE__ */ new Set();
   const keep = (f) => {
@@ -8702,7 +8724,7 @@ function ruleDependencies(ruleMap) {
     const seen = /* @__PURE__ */ new Set();
     const walk2 = (p, isRoot) => {
       const def = p._def;
-      const boundary = def.tag === "lazy" ? p._ruleName ?? nameOf.get(p) : nameOf.get(p);
+      const boundary = def.tag === "lazy" ? nameOf.get(p) ?? p._ruleName : nameOf.get(p);
       if (!isRoot && boundary !== void 0) {
         found.add(boundary);
         return;
@@ -9341,7 +9363,7 @@ function childrenOf3(def) {
       return [];
   }
 }
-var ruleNameOf3 = (c) => c._ruleName;
+var ruleNameOf4 = (c) => c._ruleName;
 function lazyTarget(c) {
   if (c._def.tag !== "lazy") return null;
   try {
@@ -9523,12 +9545,16 @@ var Serializer = class {
   emitted = /* @__PURE__ */ new Set();
   decls = [];
   ruleValues = /* @__PURE__ */ new Set();
+  localRuleNames = /* @__PURE__ */ new Map();
   ruleMap;
   scanSkip;
   constructor(ruleMap, scanSkip = []) {
     this.ruleMap = ruleMap;
     this.scanSkip = scanSkip;
-    for (const [, c] of ruleMap) this.ruleValues.add(this.body(c));
+    for (const [name, c] of ruleMap) {
+      this.localRuleNames.set(c, name);
+      this.ruleValues.add(this.body(c));
+    }
   }
   /** A grammar-level `scanSkip` unit is an opaque TERMINAL (a string, a balanced
    * bracket) — it must not reach a grammar-rule ref (`g[name]`), because the
@@ -9539,7 +9565,7 @@ var Serializer = class {
     if (seen.has(c)) return;
     seen.add(c);
     if (c._def.tag === "lazy") {
-      if (ruleNameOf3(c) !== void 0) throw new Unserializable("scanSkip unit references a grammar rule");
+      if (ruleNameOf4(c) !== void 0) throw new Unserializable("scanSkip unit references a grammar rule");
       const target = lazyTarget(c);
       if (target) this.assertNoRuleRef(target, seen);
       return;
@@ -9550,7 +9576,7 @@ var Serializer = class {
    * its target (compileLinkable unwraps the same way). A ref INSIDE a body stays a
    * `g[name]` ref — only the top-level entry is unwrapped. */
   body(c) {
-    return c._def.tag === "lazy" && ruleNameOf3(c) !== void 0 ? lazyTarget(c) ?? c : c;
+    return c._def.tag === "lazy" && ruleNameOf4(c) !== void 0 ? lazyTarget(c) ?? c : c;
   }
   run() {
     for (const [, c] of this.ruleMap) this.analyze(this.body(c), /* @__PURE__ */ new Set());
@@ -9592,7 +9618,7 @@ ${outerDecls.map((d) => "  " + d).join("\n")}
   analyze(c, active) {
     const def = c._def;
     if (def.tag === "lazy") {
-      if (ruleNameOf3(c) !== void 0) return;
+      if (ruleNameOf4(c) !== void 0) return;
       const target = lazyTarget(c);
       if (!target) throw new Unserializable("unresolved unnamed ref");
       if (active.has(target)) {
@@ -9644,7 +9670,8 @@ ${outerDecls.map((d) => "  " + d).join("\n")}
     const kid = (x) => this.ref(x, selfOf);
     switch (def.tag) {
       case "lazy": {
-        if (ruleNameOf3(c) !== void 0) return `g[${JSON.stringify(ruleNameOf3(c))}]`;
+        const name = this.localRuleNames.get(c) ?? ruleNameOf4(c);
+        if (name !== void 0) return `g[${JSON.stringify(name)}]`;
         const target = lazyTarget(c);
         if (selfOf && target === selfOf.comb) return selfOf.var;
         return this.ref(target, selfOf);