grammatik 0.1.0

package/dist/esm/index.js

@@ -0,0 +1,2959 @@
+// src/parser.js
+import { LogicEngine } from "json-logic-engine";
+
+// src/firstchars.js
+var DIGITS = [];
+for (let c = 48; c <= 57; c++) DIGITS.push(c);
+var WORD = DIGITS.concat([95]);
+for (let c = 65; c <= 90; c++) WORD.push(c);
+for (let c = 97; c <= 122; c++) WORD.push(c);
+var SPACE = [9, 10, 11, 12, 13, 32, 160, 5760, 8232, 8233, 8239, 8287, 12288, 65279];
+for (let c = 8192; c <= 8202; c++) SPACE.push(c);
+var SIMPLE_ESCAPES = {
+  n: 10,
+  r: 13,
+  t: 9,
+  f: 12,
+  v: 11,
+  0: 0
+};
+function firstCharSet(source, ignoreCase) {
+  const found = /* @__PURE__ */ new Set();
+  let pos = 0;
+  let bailed = false;
+  const bail = () => {
+    bailed = true;
+  };
+  function add(code) {
+    found.add(code);
+    if (!ignoreCase) return;
+    const char = String.fromCharCode(code);
+    const upper = char.toUpperCase();
+    const lower = char.toLowerCase();
+    if (upper.length === 1) found.add(upper.charCodeAt(0));
+    if (lower.length === 1) found.add(lower.charCodeAt(0));
+  }
+  function addAll(codes) {
+    for (const code of codes) add(code);
+  }
+  function alternation(collect) {
+    let nullable = false;
+    for (; ; ) {
+      if (sequence(collect)) nullable = true;
+      if (bailed) return true;
+      if (source[pos] === "|") {
+        pos++;
+        continue;
+      }
+      break;
+    }
+    return nullable;
+  }
+  function sequence(collect) {
+    let stillNullable = true;
+    while (pos < source.length && source[pos] !== "|" && source[pos] !== ")") {
+      const nullable = element(collect && stillNullable);
+      if (bailed) return true;
+      if (!nullable) stillNullable = false;
+    }
+    return stillNullable;
+  }
+  function element(collect) {
+    const zeroWidth = atom(collect);
+    if (bailed) return true;
+    const quantifier = source[pos];
+    if (quantifier === "?" || quantifier === "*") {
+      pos++;
+      if (source[pos] === "?" || source[pos] === "+") pos++;
+      return true;
+    }
+    if (quantifier === "+") {
+      pos++;
+      if (source[pos] === "?" || source[pos] === "+") pos++;
+      return zeroWidth;
+    }
+    if (quantifier === "{") {
+      const close = source.indexOf("}", pos);
+      if (close === -1) {
+        bail();
+        return true;
+      }
+      const body = source.slice(pos + 1, close);
+      if (!/^\d+(,\d*)?$/.test(body)) {
+        bail();
+        return true;
+      }
+      pos = close + 1;
+      if (source[pos] === "?" || source[pos] === "+") pos++;
+      const min = parseInt(body, 10);
+      return min === 0 ? true : zeroWidth;
+    }
+    return zeroWidth;
+  }
+  function atom(collect) {
+    const char = source[pos];
+    if (char === "(") {
+      let lookaround = false;
+      if (source.startsWith("(?:", pos)) pos += 3;
+      else if (source.startsWith("(?=", pos) || source.startsWith("(?!", pos)) {
+        pos += 3;
+        lookaround = true;
+      } else if (source.startsWith("(?<=", pos) || source.startsWith("(?<!", pos)) {
+        pos += 4;
+        lookaround = true;
+      } else if (source.startsWith("(?<", pos)) {
+        const close = source.indexOf(">", pos);
+        if (close === -1) {
+          if (collect) bail();
+          return true;
+        }
+        pos = close + 1;
+      } else pos += 1;
+      const nullable = alternation(collect && !lookaround);
+      if (bailed) return true;
+      if (source[pos] !== ")") {
+        if (collect) bail();
+        return true;
+      }
+      pos++;
+      return lookaround ? true : nullable;
+    }
+    if (char === "[") return charClass(collect);
+    if (char === "\\") return escape(collect);
+    if (char === ".") {
+      if (collect) {
+        bail();
+        return true;
+      }
+      pos++;
+      return false;
+    }
+    if (char === "^" || char === "$") {
+      pos++;
+      return true;
+    }
+    if (char === void 0) {
+      bail();
+      return true;
+    }
+    if (collect) add(source.charCodeAt(pos));
+    pos++;
+    return false;
+  }
+  function skipCharClass() {
+    pos++;
+    if (source[pos] === "^") pos++;
+    if (source[pos] === "]") pos++;
+    while (pos < source.length && source[pos] !== "]") {
+      if (source[pos] === "\\") pos += 2;
+      else pos++;
+    }
+    if (source[pos] !== "]") {
+      bail();
+      return false;
+    }
+    pos++;
+    return false;
+  }
+  function charClass(collect) {
+    if (source[pos + 1] === "^") {
+      if (collect) {
+        bail();
+        return false;
+      }
+      return skipCharClass();
+    }
+    if (!collect) return skipCharClass();
+    pos++;
+    while (pos < source.length && source[pos] !== "]") {
+      let low;
+      if (source[pos] === "\\") {
+        const before = pos;
+        const zero = escape(collect, true);
+        if (bailed) return false;
+        if (zero === null) {
+          low = null;
+        } else {
+          low = zero;
+        }
+        if (pos === before) {
+          bail();
+          return false;
+        }
+      } else {
+        low = source.charCodeAt(pos);
+        pos++;
+      }
+      if (low !== null && source[pos] === "-" && source[pos + 1] !== "]" && pos + 1 < source.length) {
+        pos++;
+        let high;
+        if (source[pos] === "\\") {
+          high = escape(collect, true);
+          if (bailed) return false;
+          if (high === null) {
+            bail();
+            return false;
+          }
+        } else {
+          high = source.charCodeAt(pos);
+          pos++;
+        }
+        if (high < low) {
+          bail();
+          return false;
+        }
+        if (high - low > 4096) {
+          bail();
+          return false;
+        }
+        if (collect) for (let c = low; c <= high; c++) add(c);
+      } else if (low !== null && collect) {
+        add(low);
+      }
+    }
+    if (source[pos] !== "]") {
+      bail();
+      return false;
+    }
+    pos++;
+    return false;
+  }
+  function escape(collect, inClass = false) {
+    pos++;
+    const char = source[pos];
+    if (char === void 0) {
+      bail();
+      return inClass ? null : true;
+    }
+    if (char === "d" || char === "w" || char === "s") {
+      pos++;
+      if (collect) addAll(char === "d" ? DIGITS : char === "w" ? WORD : SPACE);
+      return inClass ? null : false;
+    }
+    if (char === "D" || char === "W" || char === "S" || char === "p" || char === "P") {
+      if (collect) {
+        bail();
+        return inClass ? null : false;
+      }
+      pos++;
+      if ((char === "p" || char === "P") && source[pos] === "{") {
+        const close = source.indexOf("}", pos);
+        if (close === -1) {
+          bail();
+          return inClass ? null : false;
+        }
+        pos = close + 1;
+      }
+      return inClass ? null : false;
+    }
+    if (char === "b" || char === "B") {
+      pos++;
+      if (inClass) {
+        if (collect) add(8);
+        return 8;
+      }
+      return true;
+    }
+    if (char === "u") {
+      if (source[pos + 1] === "{") {
+        const close = source.indexOf("}", pos);
+        if (close === -1) {
+          bail();
+          return inClass ? null : false;
+        }
+        const code3 = parseInt(source.slice(pos + 2, close), 16);
+        pos = close + 1;
+        if (Number.isNaN(code3)) {
+          bail();
+          return inClass ? null : false;
+        }
+        if (collect) add(code3);
+        return inClass ? code3 : false;
+      }
+      const hex = source.slice(pos + 1, pos + 5);
+      if (!/^[0-9a-fA-F]{4}$/.test(hex)) {
+        bail();
+        return inClass ? null : false;
+      }
+      pos += 5;
+      const code2 = parseInt(hex, 16);
+      if (collect) add(code2);
+      return inClass ? code2 : false;
+    }
+    if (char === "x") {
+      const hex = source.slice(pos + 1, pos + 3);
+      if (!/^[0-9a-fA-F]{2}$/.test(hex)) {
+        bail();
+        return inClass ? null : false;
+      }
+      pos += 3;
+      const code2 = parseInt(hex, 16);
+      if (collect) add(code2);
+      return inClass ? code2 : false;
+    }
+    if (char >= "1" && char <= "9" && !inClass) {
+      if (collect) {
+        bail();
+        return false;
+      }
+      while (source[pos] >= "0" && source[pos] <= "9") pos++;
+      return false;
+    }
+    if (char in SIMPLE_ESCAPES) {
+      pos++;
+      const code2 = SIMPLE_ESCAPES[char];
+      if (collect) add(code2);
+      return inClass ? code2 : false;
+    }
+    pos++;
+    const code = char.charCodeAt(0);
+    if (collect) add(code);
+    return inClass ? code : false;
+  }
+  alternation(true);
+  if (bailed || pos !== source.length || found.size === 0) return null;
+  return found;
+}
+
+// src/lexer.js
+var LexError = class extends Error {
+  /**
+   * @param {string} message
+   * @param {{ offset: number, line: number, col: number }} position
+   */
+  constructor(message, position) {
+    super(message);
+    this.name = "LexError";
+    this.offset = position.offset;
+    this.line = position.line;
+    this.col = position.col;
+  }
+};
+var DEFAULT_MODE = "default";
+function modesOf(def) {
+  if (Array.isArray(def.modes) && def.modes.length > 0) return def.modes;
+  if (def.mode) return [def.mode];
+  return [DEFAULT_MODE];
+}
+function createLexer(defs, options = {}) {
+  const positions = options.positions === "offset" ? "offset" : "full";
+  const trackLines = positions === "full";
+  if (!Array.isArray(defs) || defs.length === 0) throw new Error("createLexer: expected a non-empty array of token definitions");
+  const tokenNames = defs.map((d) => d.name);
+  const seen = /* @__PURE__ */ new Set();
+  for (const name of tokenNames) {
+    if (seen.has(name)) throw new Error(`createLexer: duplicate token name '${name}'`);
+    seen.add(name);
+  }
+  const modeIds = /* @__PURE__ */ new Map([[DEFAULT_MODE, 0]]);
+  const modeNames = [DEFAULT_MODE];
+  const idOf = (name) => {
+    let id = modeIds.get(name);
+    if (id === void 0) {
+      id = modeNames.length;
+      modeIds.set(name, id);
+      modeNames.push(name);
+    }
+    return id;
+  };
+  for (const def of defs) for (const mode of modesOf(def)) idOf(mode);
+  const compiled = defs.map((def) => {
+    if (!def.name) throw new Error("createLexer: every token definition needs a name");
+    if (!def.pattern && !def.literal) throw new Error(`createLexer: token '${def.name}' needs a pattern or a literal`);
+    if (def.pattern && def.literal) throw new Error(`createLexer: token '${def.name}' has both a pattern and a literal; pick one`);
+    if (def.longerAlt && !seen.has(def.longerAlt)) throw new Error(`createLexer: token '${def.name}' has longerAlt '${def.longerAlt}', which is not a defined token`);
+    if (def.pushMode && def.popMode) {
+      throw new Error(
+        `createLexer: token '${def.name}' both pushes '${def.pushMode}' and pops. One token cannot do both \u2014 split it into two tokens, one per mode.`
+      );
+    }
+    if (def.pushMode && !modeIds.has(def.pushMode)) {
+      throw new Error(`createLexer: token '${def.name}' pushes mode '${def.pushMode}', which no token belongs to`);
+    }
+    return {
+      name: def.name,
+      skip: !!def.skip,
+      literal: def.literal,
+      longerAlt: def.longerAlt || null,
+      regex: def.pattern ? new RegExp(def.pattern, def.ignoreCase ? "iy" : "y") : null,
+      modes: modesOf(def),
+      pushMode: def.pushMode ? idOf(def.pushMode) : -1,
+      popMode: !!def.popMode
+    };
+  });
+  const byName = new Map(compiled.map((c) => [c.name, c]));
+  for (const c of compiled) if (c.longerAlt) c.longerAltDef = byName.get(c.longerAlt);
+  for (const c of compiled) {
+    if (!c.longerAltDef) continue;
+    for (const mode of c.modes) {
+      if (c.longerAltDef.modes.includes(mode)) continue;
+      throw new Error(
+        `createLexer: token '${c.name}' is active in mode '${mode}' with longerAlt '${c.longerAlt}', which is not active there. Add '${mode}' to '${c.longerAlt}'.`
+      );
+    }
+  }
+  for (const c of compiled) {
+    c.firstChars = c.literal !== void 0 ? c.literal.length > 0 ? /* @__PURE__ */ new Set([c.literal.charCodeAt(0)]) : null : firstCharSet(c.regex.source, !!c.regex.ignoreCase);
+  }
+  const modes = modeNames.map((name) => {
+    const members = compiled.filter((c) => c.modes.includes(name));
+    const alwaysTry = members.filter((c) => c.firstChars === null);
+    const candidatesFor = (code) => members.filter((c) => c.firstChars === null || c.firstChars.has(code));
+    const ascii = new Array(128);
+    for (let code = 0; code < 128; code++) ascii[code] = candidatesFor(code);
+    return {
+      name,
+      members,
+      ascii,
+      wide: /* @__PURE__ */ new Map(),
+      candidatesFor,
+      // If nothing could be analyzed, dispatch is pure overhead; skip it.
+      dispatch: alwaysTry.length < members.length
+    };
+  });
+  for (const mode of modes) {
+    if (mode.members.length === 0) throw new Error(`createLexer: mode '${mode.name}' has no tokens`);
+  }
+  function candidates(mode, code) {
+    if (code < 128) return mode.ascii[code];
+    let list = mode.wide.get(code);
+    if (list === void 0) {
+      list = mode.candidatesFor(code);
+      mode.wide.set(code, list);
+    }
+    return list;
+  }
+  const multiMode = modes.length > 1 || compiled.some((c) => c.popMode || c.pushMode !== -1);
+  const namesModes = modes.length > 1;
+  const initial = modes[0];
+  function longerAltEnd(def, text, offset) {
+    const alt2 = def.longerAltDef;
+    if (alt2.literal !== void 0) return text.startsWith(alt2.literal, offset) ? offset + alt2.literal.length : -1;
+    alt2.regex.lastIndex = offset;
+    return alt2.regex.test(text) ? alt2.regex.lastIndex : -1;
+  }
+  function tokenize(text) {
+    if (typeof text !== "string") throw new TypeError("tokenize: expected a string");
+    const tokens = [];
+    let offset = 0;
+    let line = 1;
+    let lineStart = 0;
+    const length = text.length;
+    let mode = initial;
+    const stack = multiMode ? [] : null;
+    let depth = 0;
+    outer: while (offset < length) {
+      const applicable = mode.dispatch ? candidates(mode, text.charCodeAt(offset)) : mode.members;
+      for (let i = 0; i < applicable.length; i++) {
+        const def = applicable[i];
+        let end = -1;
+        let matched = null;
+        if (def.literal !== void 0) {
+          if (text.startsWith(def.literal, offset)) end = offset + def.literal.length;
+        } else if (def.skip) {
+          def.regex.lastIndex = offset;
+          if (def.regex.test(text) && def.regex.lastIndex > offset) end = def.regex.lastIndex;
+        } else {
+          def.regex.lastIndex = offset;
+          const match = def.regex.exec(text);
+          if (match !== null && match[0].length > 0) matched = match[0];
+          if (matched !== null) end = offset + matched.length;
+        }
+        if (end === -1) continue;
+        let winner = def;
+        if (def.longerAltDef) {
+          const altEnd = longerAltEnd(def, text, offset);
+          if (altEnd > end) {
+            end = altEnd;
+            winner = def.longerAltDef;
+          }
+        }
+        if (!winner.skip) {
+          const image = winner.literal !== void 0 ? winner.literal : winner === def && matched !== null ? matched : text.slice(offset, end);
+          tokens.push({
+            type: winner.name,
+            image,
+            start: offset,
+            end,
+            line: trackLines ? line : 0,
+            col: trackLines ? offset - lineStart + 1 : 0
+          });
+        }
+        if (trackLines) {
+          for (let j = offset; j < end; j++) {
+            if (text.charCodeAt(j) !== 10) continue;
+            line++;
+            lineStart = j + 1;
+          }
+        }
+        if (multiMode) {
+          if (winner.popMode) {
+            if (depth === 0) {
+              throw new LexError(
+                `Token '${winner.name}' popped the initial lexer mode at ${describe(offset, line, lineStart)}`,
+                { offset, line: trackLines ? line : 0, col: trackLines ? offset - lineStart + 1 : 0 }
+              );
+            }
+            mode = stack[--depth];
+          } else if (winner.pushMode !== -1) {
+            stack[depth++] = mode;
+            mode = modes[winner.pushMode];
+          }
+        }
+        offset = end;
+        continue outer;
+      }
+      const column = offset - lineStart + 1;
+      throw new LexError(
+        trackLines ? `Unexpected character '${text[offset]}' at line ${line} column ${column}${inMode(mode)}` : `Unexpected character '${text[offset]}' at offset ${offset}${inMode(mode)}`,
+        { offset, line: trackLines ? line : 0, col: trackLines ? column : 0 }
+      );
+    }
+    return tokens;
+  }
+  const inMode = (mode) => namesModes ? ` (in lexer mode '${mode.name}')` : "";
+  const describe = (offset, line, lineStart) => trackLines ? `line ${line} column ${offset - lineStart + 1}` : `offset ${offset}`;
+  return { tokenize, tokenNames, positions, modeNames };
+}
+
+// src/state.js
+var FAIL = /* @__PURE__ */ Symbol("grammatik.fail");
+var createState = (tokens, grammar, options = {}) => ({
+  tokens,
+  idx: 0,
+  maxIdx: 0,
+  expected: [],
+  grammar,
+  memo: options.memo ? /* @__PURE__ */ new Map() : null,
+  // Entering a rule is one array store rather than an object allocation, and
+  // the stack is snapshotted only on a furthest failure — by the time an error
+  // is built it would otherwise have unwound to just the start rule.
+  ruleNames: [],
+  ruleDepth: 0,
+  failureStack: null,
+  track: options.track === true,
+  steps: 0,
+  maxSteps: options.maxSteps || 0
+});
+function expect(state, expectation) {
+  if (state.idx > state.maxIdx) {
+    state.maxIdx = state.idx;
+    if (!state.track) return;
+    state.expected = [];
+    state.failureStack = state.ruleNames.slice(0, state.ruleDepth);
+  }
+  if (!state.track || state.idx !== state.maxIdx) return;
+  if (!state.expected.includes(expectation)) state.expected.push(expectation);
+}
+var ParseError = class extends Error {
+  /**
+   * @param {string} message
+   * @param {{ token: import('./lexer.js').Token | null, expected: string[], ruleStack: string[] }} details
+   */
+  constructor(message, details) {
+    super(message);
+    this.name = "ParseError";
+    this.token = details.token;
+    this.expected = details.expected;
+    this.ruleStack = details.ruleStack;
+  }
+};
+var describeExpected = (expected) => expected.length === 0 ? "nothing" : expected.length === 1 ? expected[0] : `one of [${expected.join(", ")}]`;
+function buildParseError(state) {
+  const token = state.tokens[state.maxIdx] || null;
+  const expected = [...state.expected].sort();
+  const ruleStack = state.failureStack || state.ruleNames.slice(0, state.ruleDepth);
+  const at = (t) => state.positions === "offset" ? `offset ${t.start}` : `line ${t.line} column ${t.col}`;
+  const found = token ? `--> ${token.image} <-- (${token.type}) at ${at(token)}` : "end of input";
+  return new ParseError(
+    `Expecting ${describeExpected(expected)} but found ${found}`,
+    { token, expected, ruleStack }
+  );
+}
+
+// src/analyze.js
+var emptyFirst = () => ({ tokens: /* @__PURE__ */ new Set(), nullable: false, unknown: false });
+var epsilon = () => ({ tokens: /* @__PURE__ */ new Set(), nullable: true, unknown: false });
+var opaque = () => ({ tokens: /* @__PURE__ */ new Set(), nullable: true, unknown: true });
+function absorb(target, source) {
+  let changed = false;
+  for (const t of source.tokens) {
+    if (!target.tokens.has(t)) {
+      target.tokens.add(t);
+      changed = true;
+    }
+  }
+  if (source.unknown && !target.unknown) {
+    target.unknown = true;
+    changed = true;
+  }
+  return changed;
+}
+function opOf(node) {
+  if (!node || typeof node !== "object" || Array.isArray(node)) return null;
+  const keys = Object.keys(node);
+  return keys.length === 1 ? keys[0] : null;
+}
+var PARSER_OPS = /* @__PURE__ */ new Set([
+  "consume",
+  "seq",
+  "alt",
+  "many",
+  "many1",
+  "option",
+  "manySep",
+  "many1Sep",
+  "infixLeft",
+  "infixRight",
+  "postfix",
+  "prefix",
+  "between",
+  "as",
+  "oneOf",
+  "eof",
+  "subrule",
+  "label",
+  "action",
+  "lookahead",
+  "negLookahead",
+  "text",
+  "epsilon"
+]);
+function firstOf(node, ruleFirsts) {
+  const op = opOf(node);
+  if (op === null) return opaque();
+  const arg = node[op];
+  switch (op) {
+    case "consume": {
+      const result = emptyFirst();
+      const name = Array.isArray(arg) ? arg[0] : arg;
+      if (typeof name === "string") result.tokens.add(name);
+      else result.unknown = true;
+      return result;
+    }
+    case "epsilon":
+    case "action":
+      return epsilon();
+    case "text":
+    case "label":
+      return firstOf(op === "label" ? arg[1] : arg, ruleFirsts);
+    case "seq": {
+      const result = epsilon();
+      if (!Array.isArray(arg)) return opaque();
+      for (const child of arg) {
+        const childFirst = firstOf(child, ruleFirsts);
+        absorb(result, childFirst);
+        if (!childFirst.nullable) {
+          result.nullable = false;
+          break;
+        }
+      }
+      return result;
+    }
+    case "alt": {
+      const result = emptyFirst();
+      if (!Array.isArray(arg)) return opaque();
+      for (const child of arg) {
+        const childFirst = firstOf(child, ruleFirsts);
+        absorb(result, childFirst);
+        if (childFirst.nullable) result.nullable = true;
+      }
+      return result;
+    }
+    case "many":
+    case "option": {
+      const inner = firstOf(arg, ruleFirsts);
+      return { tokens: inner.tokens, nullable: true, unknown: inner.unknown };
+    }
+    case "many1": {
+      const inner = firstOf(arg, ruleFirsts);
+      return { tokens: inner.tokens, nullable: inner.nullable, unknown: inner.unknown };
+    }
+    case "oneOf": {
+      const result = emptyFirst();
+      const names = Array.isArray(arg) ? arg : [arg];
+      for (const name of names) {
+        if (typeof name === "string") result.tokens.add(name);
+        else result.unknown = true;
+      }
+      return result;
+    }
+    case "eof":
+      return opaque();
+    case "as":
+      return firstOf(Array.isArray(arg) ? arg[0] : arg && arg.parser, ruleFirsts);
+    case "between":
+      return firstOf({ seq: [arg && arg.open, arg && arg.body, arg && arg.close] }, ruleFirsts);
+    case "prefix": {
+      const ops = firstOf(arg && arg.operator, ruleFirsts);
+      const inner = firstOf(arg && arg.operand, ruleFirsts);
+      const result = emptyFirst();
+      absorb(result, ops);
+      absorb(result, inner);
+      result.nullable = inner.nullable;
+      return result;
+    }
+    case "postfix": {
+      const inner = firstOf(arg && arg.operand, ruleFirsts);
+      return { tokens: inner.tokens, nullable: inner.nullable, unknown: inner.unknown };
+    }
+    case "infixRight":
+    case "infixLeft": {
+      const inner = firstOf(arg && arg.operand, ruleFirsts);
+      return { tokens: inner.tokens, nullable: inner.nullable, unknown: inner.unknown };
+    }
+    case "manySep":
+    case "many1Sep": {
+      const inner = firstOf(arg && arg.rule, ruleFirsts);
+      return {
+        tokens: inner.tokens,
+        nullable: op === "manySep" ? true : inner.nullable,
+        unknown: inner.unknown
+      };
+    }
+    case "subrule": {
+      const name = Array.isArray(arg) ? arg[0] : arg;
+      const known = ruleFirsts.get(name);
+      if (!known) return opaque();
+      return { tokens: known.tokens, nullable: known.nullable, unknown: known.unknown };
+    }
+    // Zero-width assertions constrain the input without consuming it. They are
+    // nullable, but treating them as transparent would let `alt` dispatch past a
+    // guard that was meant to reject, so they are deliberately opaque.
+    case "lookahead":
+    case "negLookahead":
+      return opaque();
+    default:
+      return epsilon();
+  }
+}
+function recognizeSeqIdiom(children) {
+  if (!Array.isArray(children)) return null;
+  if (children.length === 4) {
+    const [open, labelled, close, act] = children;
+    if (opOf(labelled) === "label" && opOf(act) === "action" && isPlainParser(open) && isPlainParser(close)) {
+      const [name, body] = labelled.label;
+      const logic = act.action;
+      if (opOf(logic) === "val" && logic.val === name) {
+        return { between: { open, body, close } };
+      }
+    }
+  }
+  if (children.length === 2) {
+    const [labelled, act] = children;
+    if (opOf(labelled) === "label" && opOf(act) === "action") {
+      const [name, parser] = labelled.label;
+      const rewritten = rebaseOnLabel(act.action, name);
+      if (rewritten !== BAIL) return { as: [parser, rewritten] };
+    }
+  }
+  return null;
+}
+function isPlainParser(node) {
+  const op = opOf(node);
+  return op !== null && op !== "label" && op !== "action";
+}
+var BAIL = /* @__PURE__ */ Symbol("grammatik.bail");
+function rebaseOnLabel(logic, name) {
+  if (Array.isArray(logic)) {
+    const out2 = new Array(logic.length);
+    for (let i = 0; i < logic.length; i++) {
+      const value = rebaseOnLabel(logic[i], name);
+      if (value === BAIL) return BAIL;
+      out2[i] = value;
+    }
+    return out2;
+  }
+  if (!logic || typeof logic !== "object") return logic;
+  const keys = Object.keys(logic);
+  if (keys.length === 1 && keys[0] === "val") {
+    const path = logic.val;
+    if (path === name) return { val: [] };
+    if (Array.isArray(path) && path[0] === name) {
+      const rest = path.slice(1);
+      return { val: rest.length === 1 ? rest[0] : rest };
+    }
+    return BAIL;
+  }
+  if (keys.length === 1 && keys[0] === "var") return BAIL;
+  const out = {};
+  for (const key of keys) {
+    const value = rebaseOnLabel(logic[key], name);
+    if (value === BAIL) return BAIL;
+    out[key] = value;
+  }
+  return out;
+}
+function computeFirsts(grammar) {
+  const ruleFirsts = /* @__PURE__ */ new Map();
+  for (const name of Object.keys(grammar)) ruleFirsts.set(name, emptyFirst());
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const name of Object.keys(grammar)) {
+      const current = ruleFirsts.get(name);
+      const computed = firstOf(grammar[name], ruleFirsts);
+      if (absorb(current, computed)) changed = true;
+      if (computed.nullable && !current.nullable) {
+        current.nullable = true;
+        changed = true;
+      }
+    }
+  }
+  return ruleFirsts;
+}
+function leftmostCalls(node, ruleFirsts, out) {
+  const op = opOf(node);
+  if (op === null) return;
+  const arg = node[op];
+  switch (op) {
+    case "subrule": {
+      const name = Array.isArray(arg) ? arg[0] : arg;
+      out.add(name);
+      break;
+    }
+    case "label":
+      leftmostCalls(arg[1], ruleFirsts, out);
+      break;
+    case "text":
+    case "many":
+    case "many1":
+    case "option":
+    case "lookahead":
+    case "negLookahead":
+      leftmostCalls(arg, ruleFirsts, out);
+      break;
+    case "as":
+      leftmostCalls(Array.isArray(arg) ? arg[0] : arg && arg.parser, ruleFirsts, out);
+      break;
+    case "between":
+      if (arg) leftmostCalls({ seq: [arg.open, arg.body, arg.close] }, ruleFirsts, out);
+      break;
+    case "prefix":
+      if (arg) {
+        leftmostCalls(arg.operator, ruleFirsts, out);
+        leftmostCalls(arg.operand, ruleFirsts, out);
+      }
+      break;
+    case "infixLeft":
+    case "infixRight":
+    case "postfix":
+      if (arg) leftmostCalls(arg.operand, ruleFirsts, out);
+      break;
+    case "manySep":
+    case "many1Sep":
+      if (arg) leftmostCalls(arg.rule, ruleFirsts, out);
+      break;
+    case "alt":
+      if (Array.isArray(arg)) for (const child of arg) leftmostCalls(child, ruleFirsts, out);
+      break;
+    case "seq":
+      if (Array.isArray(arg)) {
+        for (const child of arg) {
+          leftmostCalls(child, ruleFirsts, out);
+          if (!firstOf(child, ruleFirsts).nullable) break;
+        }
+      }
+      break;
+  }
+}
+function validateNode(node, grammar, tokenNames, errors, path) {
+  const op = opOf(node);
+  if (op === null) {
+    if (Array.isArray(node)) node.forEach((c, i) => validateNode(c, grammar, tokenNames, errors, `${path}[${i}]`));
+    return;
+  }
+  const arg = node[op];
+  switch (op) {
+    case "consume": {
+      const name = Array.isArray(arg) ? arg[0] : arg;
+      if (typeof name !== "string") errors.push(`${path}: 'consume' expects a token name, got ${JSON.stringify(name)}`);
+      else if (tokenNames && !tokenNames.has(name)) errors.push(`${path}: 'consume' references unknown token '${name}'`);
+      break;
+    }
+    case "subrule": {
+      const name = Array.isArray(arg) ? arg[0] : arg;
+      if (typeof name !== "string") errors.push(`${path}: 'subrule' expects a rule name, got ${JSON.stringify(name)}`);
+      else if (!(name in grammar)) errors.push(`${path}: 'subrule' references unknown rule '${name}'`);
+      break;
+    }
+    case "label": {
+      if (!Array.isArray(arg) || arg.length !== 2 || typeof arg[0] !== "string") {
+        errors.push(`${path}: 'label' expects [name, parser]`);
+      } else validateNode(arg[1], grammar, tokenNames, errors, `${path}.label(${arg[0]})`);
+      break;
+    }
+    case "seq":
+    case "alt": {
+      if (!Array.isArray(arg)) errors.push(`${path}: '${op}' expects an array`);
+      else {
+        if (op === "alt" && arg.length === 0) errors.push(`${path}: 'alt' needs at least one branch`);
+        arg.forEach((c, i) => validateNode(c, grammar, tokenNames, errors, `${path}.${op}[${i}]`));
+      }
+      break;
+    }
+    case "many":
+    case "many1":
+    case "option":
+    case "text":
+    case "lookahead":
+    case "negLookahead":
+      validateNode(arg, grammar, tokenNames, errors, `${path}.${op}`);
+      break;
+    case "as": {
+      const parser = Array.isArray(arg) ? arg[0] : arg && arg.parser;
+      if (parser === void 0) errors.push(`${path}: 'as' expects [parser, logic]`);
+      else validateNode(parser, grammar, tokenNames, errors, `${path}.as`);
+      break;
+    }
+    case "between": {
+      if (!arg || typeof arg !== "object" || !("open" in arg) || !("body" in arg) || !("close" in arg)) {
+        errors.push(`${path}: 'between' expects { open, body, close }`);
+      } else {
+        validateNode(arg.open, grammar, tokenNames, errors, `${path}.between.open`);
+        validateNode(arg.body, grammar, tokenNames, errors, `${path}.between.body`);
+        validateNode(arg.close, grammar, tokenNames, errors, `${path}.between.close`);
+      }
+      break;
+    }
+    case "prefix": {
+      if (!arg || typeof arg !== "object" || !("operator" in arg) || !("operand" in arg) || !("combine" in arg)) {
+        errors.push(`${path}: 'prefix' expects { operator, operand, combine }`);
+      } else {
+        validateNode(arg.operator, grammar, tokenNames, errors, `${path}.prefix.operator`);
+        validateNode(arg.operand, grammar, tokenNames, errors, `${path}.prefix.operand`);
+      }
+      break;
+    }
+    case "postfix": {
+      if (!arg || typeof arg !== "object" || !("operand" in arg) || !("suffix" in arg) || !("combine" in arg)) {
+        errors.push(`${path}: 'postfix' expects { operand, suffix, combine }`);
+      } else {
+        validateNode(arg.operand, grammar, tokenNames, errors, `${path}.postfix.operand`);
+        validateNode(arg.suffix, grammar, tokenNames, errors, `${path}.postfix.suffix`);
+      }
+      break;
+    }
+    case "oneOf": {
+      const names = Array.isArray(arg) ? arg : [arg];
+      for (const name of names) {
+        if (typeof name !== "string") errors.push(`${path}: 'oneOf' expects token names`);
+        else if (tokenNames && !tokenNames.has(name)) errors.push(`${path}: 'oneOf' references unknown token '${name}'`);
+      }
+      break;
+    }
+    case "eof":
+      break;
+    case "infixRight":
+    case "infixLeft": {
+      if (!arg || typeof arg !== "object" || !("operand" in arg) || !("combine" in arg)) {
+        errors.push(`${path}: '${op}' expects { operand, combine, operator? }`);
+      } else {
+        validateNode(arg.operand, grammar, tokenNames, errors, `${path}.${op}.operand`);
+        if (arg.operator !== void 0) validateNode(arg.operator, grammar, tokenNames, errors, `${path}.${op}.operator`);
+      }
+      break;
+    }
+    case "manySep":
+    case "many1Sep": {
+      if (!arg || typeof arg !== "object" || !("rule" in arg) || !("sep" in arg)) {
+        errors.push(`${path}: '${op}' expects { rule, sep }`);
+      } else {
+        validateNode(arg.rule, grammar, tokenNames, errors, `${path}.${op}.rule`);
+        if (typeof arg.sep === "string") {
+          if (tokenNames && !tokenNames.has(arg.sep)) errors.push(`${path}: '${op}' separator references unknown token '${arg.sep}'`);
+        } else validateNode(arg.sep, grammar, tokenNames, errors, `${path}.${op}.sep`);
+      }
+      break;
+    }
+  }
+}
+function analyze(grammar, options = {}) {
+  const errors = [];
+  const tokenNames = options.tokenNames ? new Set(options.tokenNames) : null;
+  for (const name of Object.keys(grammar)) {
+    validateNode(grammar[name], grammar, tokenNames, errors, name);
+  }
+  const firsts = computeFirsts(grammar);
+  const leftEdges = /* @__PURE__ */ new Map();
+  for (const name of Object.keys(grammar)) {
+    const out = /* @__PURE__ */ new Set();
+    leftmostCalls(grammar[name], firsts, out);
+    leftEdges.set(name, out);
+  }
+  const leftRecursive = [];
+  for (const start of Object.keys(grammar)) {
+    const seen = /* @__PURE__ */ new Set();
+    const stack = [...leftEdges.get(start) || []];
+    while (stack.length) {
+      const next = stack.pop();
+      if (next === start) {
+        leftRecursive.push(start);
+        break;
+      }
+      if (seen.has(next)) continue;
+      seen.add(next);
+      for (const edge of leftEdges.get(next) || []) stack.push(edge);
+    }
+  }
+  for (const name of leftRecursive) {
+    errors.push(`rule '${name}' is left-recursive; this parser is LL-style and would not terminate. Rewrite it with 'many'/'many1Sep' (the standard left-recursion elimination).`);
+  }
+  return { firsts, errors, leftRecursive };
+}
+function buildDispatch(branches, firsts) {
+  const table = /* @__PURE__ */ new Map();
+  for (const branch of branches) {
+    const first = firstOf(branch, firsts);
+    if (first.nullable || first.unknown || first.tokens.size === 0) return null;
+    for (const token of first.tokens) {
+      if (table.has(token)) return null;
+      table.set(token, branch);
+    }
+  }
+  return table.size > 0 ? table : null;
+}
+
+// src/plan.js
+var SYNC = /* @__PURE__ */ Symbol.for("json_logic_sync");
+function declareSync(fn) {
+  fn[SYNC] = true;
+  return fn;
+}
+function usesOuterScope(logic) {
+  if (Array.isArray(logic)) return logic.some(usesOuterScope);
+  if (!logic || typeof logic !== "object") return false;
+  for (const key of Object.keys(logic)) {
+    const arg = logic[key];
+    if (key === "val" && Array.isArray(arg) && Array.isArray(arg[0])) return true;
+    if (key === "var") {
+      if (typeof arg === "string" && arg.includes("../")) return true;
+      if (Array.isArray(arg) && typeof arg[0] === "string" && arg[0].includes("../")) return true;
+    }
+    if (usesOuterScope(arg)) return true;
+  }
+  return false;
+}
+function mayReturnContext(logic) {
+  if (Array.isArray(logic)) return logic.some(mayReturnContext);
+  if (!logic || typeof logic !== "object") return false;
+  for (const key of Object.keys(logic)) {
+    const arg = logic[key];
+    if (key === "val" && Array.isArray(arg) && arg.length === 0) return true;
+    if (key === "var" && (arg === "" || arg === null || Array.isArray(arg) && (arg.length === 0 || arg[0] === ""))) return true;
+    if (mayReturnContext(arg)) return true;
+  }
+  return false;
+}
+function createPlanner(config) {
+  const { engine, rules, firsts, memo, maxSteps, unsafeEval = true } = config;
+  const slots = /* @__PURE__ */ new Map();
+  const planCache = /* @__PURE__ */ new WeakMap();
+  const opCaches = /* @__PURE__ */ new Map();
+  const guard = maxSteps > 0;
+  function tick(state) {
+    if (guard && ++state.steps > maxSteps) {
+      throw new Error(`Parser exceeded maxSteps (${maxSteps}); the grammar is likely looping.`);
+    }
+  }
+  function assertProgress(state, before, op) {
+    if (state.idx === before) {
+      throw new Error(
+        `'${op}' matched without consuming any input at token index ${before}; this would loop forever. Make the repeated parser consume at least one token.`
+      );
+    }
+  }
+  function slotFor(name) {
+    let slot = slots.get(name);
+    if (slot !== void 0) return slot;
+    slot = { fn: null };
+    slots.set(name, slot);
+    const body = rules[name];
+    if (body === void 0) {
+      slot.fn = () => {
+        throw new Error(`Unknown rule '${name}'`);
+      };
+      return slot;
+    }
+    slot.fn = plan(body);
+    return slot;
+  }
+  function planAction(logic) {
+    const interpret = (bindings, state) => engine.run(logic, bindings, { above: [state] });
+    if (!unsafeEval || usesOuterScope(logic)) return interpret;
+    try {
+      const built = engine.build(logic);
+      return typeof built === "function" ? (bindings) => built(bindings) : () => built;
+    } catch {
+      return interpret;
+    }
+  }
+  function planOp(op, args) {
+    let cache = opCaches.get(op);
+    if (cache === void 0) {
+      cache = { byObject: /* @__PURE__ */ new WeakMap(), byPrimitive: /* @__PURE__ */ new Map() };
+      opCaches.set(op, cache);
+    }
+    if (args !== null && typeof args === "object") {
+      let planned2 = cache.byObject.get(args);
+      if (planned2 === void 0) {
+        planned2 = planUncached({ [op]: args });
+        cache.byObject.set(args, planned2);
+      }
+      return planned2;
+    }
+    const key = typeof args + ":" + String(args);
+    let planned = cache.byPrimitive.get(key);
+    if (planned === void 0) {
+      planned = planUncached({ [op]: args });
+      cache.byPrimitive.set(key, planned);
+    }
+    return planned;
+  }
+  function plan(node) {
+    if (node === null || typeof node !== "object") {
+      const constant = node;
+      return () => constant;
+    }
+    const cached = planCache.get(node);
+    if (cached !== void 0) return cached;
+    const planned = planUncached(node);
+    planCache.set(node, planned);
+    publish(node, planned);
+    return planned;
+  }
+  function publish(node, planned) {
+    if (engine && engine.optimizedMap && !engine.disableInterpretedOptimization) {
+      engine.optimizedMap.set(node, planned);
+    }
+  }
+  const buildConsume = (arg) => {
+    const name = typeof arg === "string" ? arg : arg[0];
+    return (state) => {
+      const token = state.tokens[state.idx];
+      if (token !== void 0 && token.type === name) {
+        state.idx++;
+        return token;
+      }
+      expect(state, name);
+      return FAIL;
+    };
+  };
+  const buildMany = (arg) => {
+    const child = plan(arg);
+    return (state) => {
+      tick(state);
+      const results = [];
+      for (; ; ) {
+        const before = state.idx;
+        const value = child(state);
+        if (value === FAIL) {
+          state.idx = before;
+          return results;
+        }
+        assertProgress(state, before, "many");
+        results.push(value);
+      }
+    };
+  };
+  const buildMany1 = (arg) => {
+    const child = plan(arg);
+    return (state) => {
+      tick(state);
+      const start = state.idx;
+      const first = child(state);
+      if (first === FAIL) {
+        state.idx = start;
+        return FAIL;
+      }
+      assertProgress(state, start, "many1");
+      const results = [first];
+      for (; ; ) {
+        const before = state.idx;
+        const value = child(state);
+        if (value === FAIL) {
+          state.idx = before;
+          return results;
+        }
+        assertProgress(state, before, "many1");
+        results.push(value);
+      }
+    };
+  };
+  const buildOption = (arg) => {
+    const child = plan(arg);
+    return (state) => {
+      const start = state.idx;
+      const value = child(state);
+      if (value === FAIL) {
+        state.idx = start;
+        return null;
+      }
+      return value;
+    };
+  };
+  const buildInfixLeft = (arg) => {
+    const operand = plan(arg.operand);
+    const operator = arg.operator === void 0 ? null : plan(arg.operator);
+    const combine = planAction(arg.combine);
+    return (state) => {
+      tick(state);
+      let left = operand(state);
+      if (left === FAIL) return FAIL;
+      let bindings = null;
+      for (; ; ) {
+        const mark = state.idx;
+        let op = null;
+        if (operator !== null) {
+          op = operator(state);
+          if (op === FAIL) {
+            state.idx = mark;
+            return left;
+          }
+        }
+        const right = operand(state);
+        if (right === FAIL) {
+          state.idx = mark;
+          return left;
+        }
+        if (bindings === null) bindings = { left: null, op: null, right: null };
+        bindings.left = left;
+        bindings.op = op;
+        bindings.right = right;
+        left = combine(bindings, state);
+      }
+    };
+  };
+  const buildOneOf = (arg) => {
+    const names = Array.isArray(arg) ? arg : [arg];
+    const set = new Set(names);
+    const count = names.length;
+    return (state) => {
+      const token = state.tokens[state.idx];
+      if (token !== void 0 && set.has(token.type)) {
+        state.idx++;
+        return token;
+      }
+      for (let i = 0; i < count; i++) expect(state, names[i]);
+      return FAIL;
+    };
+  };
+  const buildEof = (arg) => {
+    return (state) => {
+      if (state.idx >= state.tokens.length) return null;
+      expect(state, "end of input");
+      return FAIL;
+    };
+  };
+  const buildInfixRight = (arg) => {
+    const operand = plan(arg.operand);
+    const operator = arg.operator === void 0 ? null : plan(arg.operator);
+    const combine = planAction(arg.combine);
+    return (state) => {
+      tick(state);
+      const left = operand(state);
+      if (left === FAIL) return FAIL;
+      let items = null;
+      for (; ; ) {
+        const mark = state.idx;
+        let op = null;
+        if (operator !== null) {
+          op = operator(state);
+          if (op === FAIL) {
+            state.idx = mark;
+            break;
+          }
+        }
+        const right = operand(state);
+        if (right === FAIL) {
+          state.idx = mark;
+          break;
+        }
+        if (items === null) items = [];
+        items.push(op, right);
+      }
+      if (items === null) return left;
+      const bindings = { left: null, op: null, right: null };
+      let value = items[items.length - 1];
+      for (let i = items.length - 2; i >= 0; i -= 2) {
+        bindings.left = i === 0 ? left : items[i - 1];
+        bindings.op = items[i];
+        bindings.right = value;
+        value = combine(bindings, state);
+      }
+      return value;
+    };
+  };
+  const buildAs = (arg) => {
+    const child = plan(Array.isArray(arg) ? arg[0] : arg.parser);
+    const transform = planAction(Array.isArray(arg) ? arg[1] : arg.to);
+    return (state) => {
+      const value = child(state);
+      if (value === FAIL) return FAIL;
+      return transform(value, state);
+    };
+  };
+  const buildBetween = (arg) => {
+    const open = plan(arg.open);
+    const body = plan(arg.body);
+    const close = plan(arg.close);
+    return (state) => {
+      tick(state);
+      const start = state.idx;
+      if (open(state) === FAIL) {
+        state.idx = start;
+        return FAIL;
+      }
+      const value = body(state);
+      if (value === FAIL) {
+        state.idx = start;
+        return FAIL;
+      }
+      if (close(state) === FAIL) {
+        state.idx = start;
+        return FAIL;
+      }
+      return value;
+    };
+  };
+  const buildPrefix = (arg) => {
+    const operator = plan(arg.operator);
+    const operand = plan(arg.operand);
+    const combine = planAction(arg.combine);
+    return (state) => {
+      tick(state);
+      const start = state.idx;
+      let ops = null;
+      for (; ; ) {
+        const mark = state.idx;
+        const op = operator(state);
+        if (op === FAIL) {
+          state.idx = mark;
+          break;
+        }
+        if (ops === null) ops = [];
+        ops.push(op);
+      }
+      let value = operand(state);
+      if (value === FAIL) {
+        state.idx = start;
+        return FAIL;
+      }
+      if (ops !== null) {
+        const bindings = { op: null, operand: null };
+        for (let i = ops.length - 1; i >= 0; i--) {
+          bindings.op = ops[i];
+          bindings.operand = value;
+          value = combine(bindings, state);
+        }
+      }
+      return value;
+    };
+  };
+  const buildPostfix = (arg) => {
+    const operand = plan(arg.operand);
+    const suffix = plan(arg.suffix);
+    const combine = planAction(arg.combine);
+    return (state) => {
+      tick(state);
+      let left = operand(state);
+      if (left === FAIL) return FAIL;
+      let bindings = null;
+      for (; ; ) {
+        const mark = state.idx;
+        const found = suffix(state);
+        if (found === FAIL) {
+          state.idx = mark;
+          return left;
+        }
+        if (bindings === null) bindings = { left: null, suffix: null };
+        bindings.left = left;
+        bindings.suffix = found;
+        left = combine(bindings, state);
+      }
+    };
+  };
+  const buildSubrule = (arg) => {
+    const name = typeof arg === "string" ? arg : arg[0];
+    const slot = slotFor(name);
+    if (memo) {
+      return (state) => {
+        tick(state);
+        const key = name + ":" + state.idx;
+        const hit = state.memo.get(key);
+        if (hit !== void 0) {
+          state.idx = hit.end;
+          return hit.value;
+        }
+        const start = state.idx;
+        let depth = 0;
+        if (state.track) {
+          depth = state.ruleDepth;
+          state.ruleNames[depth] = name;
+          state.ruleDepth = depth + 1;
+        }
+        const value = slot.fn(state);
+        if (state.track) state.ruleDepth = depth;
+        if (value === FAIL) state.idx = start;
+        state.memo.set(key, { value, end: state.idx });
+        return value;
+      };
+    }
+    return (state) => {
+      tick(state);
+      if (!state.track) return slot.fn(state);
+      const depth = state.ruleDepth;
+      state.ruleNames[depth] = name;
+      state.ruleDepth = depth + 1;
+      const value = slot.fn(state);
+      state.ruleDepth = depth;
+      return value;
+    };
+  };
+  const buildLabel = (arg) => {
+    const name = arg[0];
+    const child = plan(arg[1]);
+    return (state) => {
+      const value = child(state);
+      if (value !== FAIL && state.bindings) state.bindings[name] = value;
+      return value;
+    };
+  };
+  const buildAction = (arg) => {
+    const action2 = planAction(arg);
+    return (state) => action2(state.bindings || {}, state);
+  };
+  const buildLookahead = (arg) => {
+    const child = plan(arg);
+    return (state) => {
+      const start = state.idx;
+      const value = child(state);
+      state.idx = start;
+      return value;
+    };
+  };
+  const buildNegLookahead = (arg) => {
+    const child = plan(arg);
+    return (state) => {
+      const start = state.idx;
+      const value = child(state);
+      state.idx = start;
+      return value === FAIL ? null : FAIL;
+    };
+  };
+  const buildText = (arg) => {
+    const child = plan(arg);
+    return (state) => {
+      const start = state.idx;
+      const value = child(state);
+      if (value === FAIL) {
+        state.idx = start;
+        return FAIL;
+      }
+      if (state.idx === start) return "";
+      const first = state.tokens[start];
+      const last = state.tokens[state.idx - 1];
+      if (state.source !== void 0) return state.source.slice(first.start, last.end);
+      let out = "";
+      for (let i = start; i < state.idx; i++) out += state.tokens[i].image;
+      return out;
+    };
+  };
+  const buildValue = (node) => {
+    const built = planAction(node);
+    return (state) => built(state.bindings || {}, state);
+  };
+  const BUILDERS = {
+    consume: buildConsume,
+    epsilon: () => () => null,
+    seq: planSeq,
+    alt: planAlt,
+    many: buildMany,
+    many1: buildMany1,
+    option: buildOption,
+    infixLeft: buildInfixLeft,
+    oneOf: buildOneOf,
+    eof: buildEof,
+    infixRight: buildInfixRight,
+    as: buildAs,
+    between: buildBetween,
+    prefix: buildPrefix,
+    postfix: buildPostfix,
+    manySep: (arg) => planSeparated(arg, false),
+    many1Sep: (arg) => planSeparated(arg, true),
+    subrule: buildSubrule,
+    label: buildLabel,
+    action: buildAction,
+    lookahead: buildLookahead,
+    negLookahead: buildNegLookahead,
+    text: buildText
+  };
+  function planUncached(node) {
+    const op = opOf(node);
+    if (op === null) return () => node;
+    const build = BUILDERS[op];
+    return build ? build(node[op]) : buildValue(node);
+  }
+  function planSeq(children) {
+    if (!Array.isArray(children)) throw new Error("'seq' expects an array of parsers");
+    const idiom = recognizeSeqIdiom(children);
+    if (idiom !== null) return planUncached(idiom);
+    const PARSER = 0;
+    const LABELLED = 1;
+    const ACTION = 2;
+    const TERMINAL = 3;
+    const LABELLED_TERMINAL = 4;
+    const kinds = [];
+    const names = [];
+    const tokens = [];
+    const fns = [];
+    const actionLogic = [];
+    let hasAction = false;
+    let hasLabels = false;
+    const terminalOf = (node) => {
+      if (opOf(node) !== "consume") return null;
+      const arg = node.consume;
+      const name = typeof arg === "string" ? arg : Array.isArray(arg) ? arg[0] : null;
+      return typeof name === "string" ? name : null;
+    };
+    for (const child of children) {
+      const childOp = opOf(child);
+      if (childOp === "label") {
+        const [name, inner] = child.label;
+        const terminal2 = terminalOf(inner);
+        hasLabels = true;
+        if (terminal2 !== null) {
+          kinds.push(LABELLED_TERMINAL);
+          names.push(name);
+          tokens.push(terminal2);
+          fns.push(null);
+        } else {
+          kinds.push(LABELLED);
+          names.push(name);
+          tokens.push(null);
+          fns.push(plan(inner));
+        }
+        continue;
+      }
+      if (childOp === "action") {
+        kinds.push(ACTION);
+        names.push(null);
+        tokens.push(null);
+        fns.push(planAction(child.action));
+        actionLogic.push(child.action);
+        hasAction = true;
+        continue;
+      }
+      const terminal = terminalOf(child);
+      if (terminal !== null) {
+        kinds.push(TERMINAL);
+        names.push(null);
+        tokens.push(terminal);
+        fns.push(null);
+      } else {
+        kinds.push(PARSER);
+        names.push(null);
+        tokens.push(null);
+        fns.push(plan(child));
+      }
+    }
+    const count = fns.length;
+    const needsScope = hasLabels || hasAction;
+    const reusableScope = needsScope && kinds.every((k) => k === TERMINAL || k === LABELLED_TERMINAL || k === ACTION) && !actionLogic.some(mayReturnContext);
+    const scratch = reusableScope ? {} : null;
+    return (state) => {
+      tick(state);
+      const start = state.idx;
+      const previousBindings = state.bindings;
+      const bindings = reusableScope ? scratch : needsScope ? {} : previousBindings;
+      if (needsScope) state.bindings = bindings;
+      const results = hasAction ? null : [];
+      let actionResult;
+      for (let i = 0; i < count; i++) {
+        const kind = kinds[i];
+        let value;
+        if (kind === TERMINAL || kind === LABELLED_TERMINAL) {
+          const token = state.tokens[state.idx];
+          if (token !== void 0 && token.type === tokens[i]) {
+            state.idx++;
+            value = token;
+          } else {
+            expect(state, tokens[i]);
+            state.idx = start;
+            if (needsScope) state.bindings = previousBindings;
+            return FAIL;
+          }
+          if (kind === LABELLED_TERMINAL) bindings[names[i]] = value;
+        } else if (kind === ACTION) {
+          actionResult = fns[i](bindings, state);
+          continue;
+        } else {
+          value = fns[i](state);
+          if (value === FAIL) {
+            state.idx = start;
+            if (needsScope) state.bindings = previousBindings;
+            return FAIL;
+          }
+          if (kind === LABELLED) bindings[names[i]] = value;
+        }
+        if (results !== null) results.push(value);
+      }
+      if (needsScope) state.bindings = previousBindings;
+      return hasAction ? actionResult : results;
+    };
+  }
+  function planAlt(branches) {
+    if (!Array.isArray(branches)) throw new Error("'alt' expects an array of branches");
+    const planned = branches.map(plan);
+    const table = firsts ? buildDispatch(branches, firsts) : null;
+    if (table !== null) {
+      const byToken = /* @__PURE__ */ Object.create(null);
+      for (const [token, branch] of table) byToken[token] = planned[branches.indexOf(branch)];
+      const expectedTokens = [...table.keys()];
+      const expectedCount = expectedTokens.length;
+      return (state) => {
+        tick(state);
+        const token = state.tokens[state.idx];
+        if (token !== void 0) {
+          const branch = byToken[token.type];
+          if (branch !== void 0) return branch(state);
+        }
+        for (let i = 0; i < expectedCount; i++) expect(state, expectedTokens[i]);
+        return FAIL;
+      };
+    }
+    const count = planned.length;
+    return (state) => {
+      tick(state);
+      const start = state.idx;
+      for (let i = 0; i < count; i++) {
+        const value = planned[i](state);
+        if (value !== FAIL) return value;
+        state.idx = start;
+      }
+      return FAIL;
+    };
+  }
+  function planSeparated(arg, atLeastOne) {
+    if (!arg || typeof arg !== "object") throw new Error("'manySep' expects { rule, sep }");
+    const { rule, sep, trailing = false } = arg;
+    const item = plan(rule);
+    const sepToken = typeof sep === "string" ? sep : null;
+    const separator = sepToken === null ? plan(sep) : null;
+    return (state) => {
+      tick(state);
+      const start = state.idx;
+      const first = item(state);
+      if (first === FAIL) {
+        state.idx = start;
+        return atLeastOne ? FAIL : [];
+      }
+      const results = [first];
+      for (; ; ) {
+        const beforeSep = state.idx;
+        if (sepToken !== null) {
+          const token = state.tokens[state.idx];
+          if (token === void 0 || token.type !== sepToken) {
+            expect(state, sepToken);
+            return results;
+          }
+          state.idx++;
+        } else if (separator(state) === FAIL) {
+          state.idx = beforeSep;
+          return results;
+        }
+        const beforeItem = state.idx;
+        const value = item(state);
+        if (value === FAIL) {
+          state.idx = trailing ? beforeItem : beforeSep;
+          return results;
+        }
+        results.push(value);
+      }
+    };
+  }
+  return {
+    plan,
+    planOp,
+    planAction,
+    planRule: (name) => slotFor(name),
+    /** Wraps a plan so json-logic-engine's compiler can embed it. */
+    declareSync
+  };
+}
+
+// src/methods.js
+var OPERATORS = [
+  "consume",
+  "epsilon",
+  "seq",
+  "alt",
+  "oneOf",
+  "eof",
+  "many",
+  "many1",
+  "option",
+  "manySep",
+  "many1Sep",
+  "infixLeft",
+  "infixRight",
+  "prefix",
+  "postfix",
+  "between",
+  "as",
+  "subrule",
+  "label",
+  "action",
+  "lookahead",
+  "negLookahead",
+  "text"
+];
+var plannerOf = (engine) => {
+  const context = engine.__jlGrammar;
+  if (!context) throw new Error("grammar combinators require a parser built by createParser");
+  return context.planner;
+};
+var compileVia = (op) => (logic, buildState) => {
+  const context = buildState.engine.__jlGrammar;
+  if (!context) return false;
+  return buildState.compile`${declareSync(context.planner.planOp(op, logic))}(context)`;
+};
+var combinator = (op) => ({
+  lazy: true,
+  deterministic: false,
+  compile: compileVia(op),
+  method: (logic, state, above, engine) => plannerOf(engine).planOp(op, logic)(state)
+});
+var createMethods = () => Object.fromEntries(OPERATORS.map((op) => [op, combinator(op)]));
+
+// src/values.js
+var badArity = (length) => new Error(`obj expects an even number of arguments (key, value, ...), received ${length}`);
+var objectFrom = (args) => {
+  if (!Array.isArray(args) || args.length === 0 || args.length % 2 !== 0) {
+    throw badArity(Array.isArray(args) ? args.length : 1);
+  }
+  const result = {};
+  for (let i = 0; i < args.length; i += 2) result[args[i]] = args[i + 1];
+  return result;
+};
+var compileObject = (args, buildState) => {
+  if (!Array.isArray(args) || args.length === 0 || args.length % 2 !== 0) return false;
+  const strings = ["({["];
+  const items = [];
+  for (let i = 0; i < args.length; i += 2) {
+    items.push(args[i]);
+    strings.push("]: ");
+    items.push(args[i + 1]);
+    strings.push(i + 2 < args.length ? ", [" : "})");
+  }
+  return buildState.compile(strings, ...items);
+};
+var createValueMethods = () => ({
+  obj: { method: objectFrom, compile: compileObject }
+});
+
+// src/codegen.js
+function createCodegen(config) {
+  const { planner, rules, firsts, memo, maxSteps } = config;
+  const HELPERS = [];
+  const ORIGINS = [];
+  const RULES = [];
+  const SOURCES = [];
+  const ruleIndex = /* @__PURE__ */ new Map();
+  const pending = [];
+  let counter = 0;
+  const nextId = () => "_" + counter++;
+  function helper(value, origin) {
+    HELPERS.push(value);
+    ORIGINS.push(origin);
+    return `H[${HELPERS.length - 1}]`;
+  }
+  const actionHelper = (logic) => helper(planner.planAction(logic), { kind: "action", logic });
+  const constantHelper = (node) => helper(planner.plan(node), { kind: "constant", node });
+  function indexOfRule(name) {
+    let index = ruleIndex.get(name);
+    if (index !== void 0) return index;
+    index = RULES.length;
+    ruleIndex.set(name, index);
+    RULES.push(null);
+    pending.push(name);
+    return index;
+  }
+  const guard = maxSteps > 0;
+  const tickSrc = guard ? `if (++c.steps > ${maxSteps}) T();` : "";
+  function gen(node, out, bindingsVar) {
+    const op = opOf(node);
+    const result = nextId();
+    if (op === null) {
+      out.push(`const ${result} = ${constantHelper(node)}(c);`);
+      return result;
+    }
+    const arg = node[op];
+    switch (op) {
+      case "consume": {
+        const name = typeof arg === "string" ? arg : arg[0];
+        const token = nextId();
+        out.push(
+          `let ${result};`,
+          `const ${token} = c.tokens[c.idx];`,
+          `if (${token} !== undefined && ${token}.type === ${JSON.stringify(name)}) { c.idx++; ${result} = ${token}; }`,
+          `else { E(c, ${JSON.stringify(name)}); ${result} = F; }`
+        );
+        return result;
+      }
+      case "epsilon":
+        out.push(`const ${result} = null;`);
+        return result;
+      case "label": {
+        const value = gen(arg[1], out, bindingsVar);
+        if (bindingsVar) out.push(`if (${value} !== F) ${bindingsVar}[${JSON.stringify(arg[0])}] = ${value};`);
+        else out.push(`if (${value} !== F && c.bindings) c.bindings[${JSON.stringify(arg[0])}] = ${value};`);
+        out.push(`const ${result} = ${value};`);
+        return result;
+      }
+      case "action": {
+        const fn = actionHelper(arg);
+        out.push(`const ${result} = ${fn}(${bindingsVar || "c.bindings || {}"}, c);`);
+        return result;
+      }
+      case "seq":
+        return genSeq(arg, out, result);
+      case "alt":
+        return genAlt(arg, out, result, bindingsVar);
+      case "option": {
+        const start = nextId();
+        out.push(`let ${result};`, `const ${start} = c.idx;`, "{");
+        const value = gen(arg, out, bindingsVar);
+        out.push(
+          `if (${value} === F) { c.idx = ${start}; ${result} = null; } else ${result} = ${value};`,
+          "}"
+        );
+        return result;
+      }
+      case "many":
+      case "many1": {
+        const atLeastOne = op === "many1";
+        const before = nextId();
+        const label2 = "L" + nextId();
+        out.push(tickSrc, `let ${result} = [];`, `${label2}: {`);
+        if (atLeastOne) {
+          const start = nextId();
+          out.push(`const ${start} = c.idx;`);
+          const first = gen(arg, out, bindingsVar);
+          out.push(
+            `if (${first} === F) { c.idx = ${start}; ${result} = F; break ${label2}; }`,
+            `if (c.idx === ${start}) P(${JSON.stringify(op)}, ${start});`,
+            `${result}.push(${first});`
+          );
+        }
+        out.push("for (;;) {", `const ${before} = c.idx;`);
+        const value = gen(arg, out, bindingsVar);
+        out.push(
+          `if (${value} === F) { c.idx = ${before}; break; }`,
+          `if (c.idx === ${before}) P(${JSON.stringify(op)}, ${before});`,
+          `${result}.push(${value});`,
+          "}",
+          "}"
+        );
+        return result;
+      }
+      case "infixLeft": {
+        const label2 = "L" + nextId();
+        const left = nextId();
+        const bindings = nextId();
+        const mark = nextId();
+        const combine = actionHelper(arg.combine);
+        out.push(tickSrc, `let ${result};`, `${label2}: {`);
+        const first = gen(arg.operand, out, bindingsVar);
+        out.push(
+          `if (${first} === F) { ${result} = F; break ${label2}; }`,
+          `let ${left} = ${first};`,
+          `let ${bindings} = null;`,
+          "for (;;) {",
+          `const ${mark} = c.idx;`
+        );
+        let operatorVar = "null";
+        if (arg.operator !== void 0) {
+          operatorVar = gen(arg.operator, out, bindingsVar);
+          out.push(`if (${operatorVar} === F) { c.idx = ${mark}; break; }`);
+        }
+        const right = gen(arg.operand, out, bindingsVar);
+        out.push(
+          `if (${right} === F) { c.idx = ${mark}; break; }`,
+          `if (${bindings} === null) ${bindings} = { left: null, op: null, right: null };`,
+          `${bindings}.left = ${left}; ${bindings}.op = ${operatorVar}; ${bindings}.right = ${right};`,
+          `${left} = ${combine}(${bindings}, c);`,
+          "}",
+          `${result} = ${left};`,
+          "}"
+        );
+        return result;
+      }
+      case "oneOf": {
+        const names = Array.isArray(arg) ? arg : [arg];
+        const token = nextId();
+        const test = names.map((n) => `${token}.type === ${JSON.stringify(n)}`).join(" || ");
+        out.push(
+          `let ${result};`,
+          `const ${token} = c.tokens[c.idx];`,
+          `if (${token} !== undefined && (${test})) { c.idx++; ${result} = ${token}; }`,
+          `else { ${names.map((n) => `E(c, ${JSON.stringify(n)});`).join(" ")} ${result} = F; }`
+        );
+        return result;
+      }
+      case "eof":
+        out.push(
+          `let ${result};`,
+          `if (c.idx >= c.tokens.length) ${result} = null;`,
+          `else { E(c, "end of input"); ${result} = F; }`
+        );
+        return result;
+      case "infixRight": {
+        const label2 = "L" + nextId();
+        const left = nextId();
+        const items = nextId();
+        const mark = nextId();
+        const bindings = nextId();
+        const value = nextId();
+        const combine = actionHelper(arg.combine);
+        out.push(tickSrc, `let ${result};`, `${label2}: {`);
+        const first = gen(arg.operand, out, bindingsVar);
+        out.push(
+          `if (${first} === F) { ${result} = F; break ${label2}; }`,
+          `const ${left} = ${first};`,
+          `let ${items} = null;`,
+          "for (;;) {",
+          `const ${mark} = c.idx;`
+        );
+        let operatorVar = "null";
+        if (arg.operator !== void 0) {
+          operatorVar = gen(arg.operator, out, bindingsVar);
+          out.push(`if (${operatorVar} === F) { c.idx = ${mark}; break; }`);
+        }
+        const right = gen(arg.operand, out, bindingsVar);
+        out.push(
+          `if (${right} === F) { c.idx = ${mark}; break; }`,
+          `if (${items} === null) ${items} = [];`,
+          `${items}.push(${operatorVar}, ${right});`,
+          "}",
+          `if (${items} === null) { ${result} = ${left}; break ${label2}; }`,
+          `const ${bindings} = { left: null, op: null, right: null };`,
+          `let ${value} = ${items}[${items}.length - 1];`,
+          `for (let i = ${items}.length - 2; i >= 0; i -= 2) {`,
+          `${bindings}.left = i === 0 ? ${left} : ${items}[i - 1];`,
+          `${bindings}.op = ${items}[i]; ${bindings}.right = ${value};`,
+          `${value} = ${combine}(${bindings}, c);`,
+          "}",
+          `${result} = ${value};`,
+          "}"
+        );
+        return result;
+      }
+      case "lookahead": {
+        const start = nextId();
+        out.push(`const ${start} = c.idx;`);
+        const value = gen(arg, out, bindingsVar);
+        out.push(`c.idx = ${start};`, `const ${result} = ${value};`);
+        return result;
+      }
+      case "negLookahead": {
+        const start = nextId();
+        out.push(`const ${start} = c.idx;`);
+        const value = gen(arg, out, bindingsVar);
+        out.push(`c.idx = ${start};`, `const ${result} = ${value} === F ? null : F;`);
+        return result;
+      }
+      case "text": {
+        const label2 = "L" + nextId();
+        const start = nextId();
+        const first = nextId();
+        const last = nextId();
+        out.push(`let ${result};`, `${label2}: {`, `const ${start} = c.idx;`);
+        const value = gen(arg, out, bindingsVar);
+        out.push(
+          `if (${value} === F) { c.idx = ${start}; ${result} = F; break ${label2}; }`,
+          `if (c.idx === ${start}) { ${result} = ''; break ${label2}; }`,
+          `const ${first} = c.tokens[${start}];`,
+          `const ${last} = c.tokens[c.idx - 1];`,
+          `if (c.source !== undefined) { ${result} = c.source.slice(${first}.start, ${last}.end); break ${label2}; }`,
+          `let ${result}_s = '';`,
+          `for (let i = ${start}; i < c.idx; i++) ${result}_s += c.tokens[i].image;`,
+          `${result} = ${result}_s;`,
+          "}"
+        );
+        return result;
+      }
+      case "as": {
+        const transform = actionHelper(Array.isArray(arg) ? arg[1] : arg.to);
+        const value = gen(Array.isArray(arg) ? arg[0] : arg.parser, out, bindingsVar);
+        out.push(`const ${result} = ${value} === F ? F : ${transform}(${value}, c);`);
+        return result;
+      }
+      case "between": {
+        const label2 = "L" + nextId();
+        const start = nextId();
+        out.push(tickSrc, `let ${result};`, `${label2}: {`, `const ${start} = c.idx;`);
+        const open = gen(arg.open, out, bindingsVar);
+        out.push(`if (${open} === F) { c.idx = ${start}; ${result} = F; break ${label2}; }`);
+        const body = gen(arg.body, out, bindingsVar);
+        out.push(`if (${body} === F) { c.idx = ${start}; ${result} = F; break ${label2}; }`);
+        const close = gen(arg.close, out, bindingsVar);
+        out.push(
+          `if (${close} === F) { c.idx = ${start}; ${result} = F; break ${label2}; }`,
+          `${result} = ${body};`,
+          "}"
+        );
+        return result;
+      }
+      case "prefix": {
+        const label2 = "L" + nextId();
+        const start = nextId();
+        const ops = nextId();
+        const mark = nextId();
+        const bindings = nextId();
+        const value = nextId();
+        const combine = actionHelper(arg.combine);
+        out.push(tickSrc, `let ${result};`, `${label2}: {`, `const ${start} = c.idx;`, `let ${ops} = null;`, "for (;;) {", `const ${mark} = c.idx;`);
+        const op2 = gen(arg.operator, out, bindingsVar);
+        out.push(
+          `if (${op2} === F) { c.idx = ${mark}; break; }`,
+          `if (${ops} === null) ${ops} = [];`,
+          `${ops}.push(${op2});`,
+          "}"
+        );
+        const operand = gen(arg.operand, out, bindingsVar);
+        out.push(
+          `if (${operand} === F) { c.idx = ${start}; ${result} = F; break ${label2}; }`,
+          `let ${value} = ${operand};`,
+          `if (${ops} !== null) {`,
+          `const ${bindings} = { op: null, operand: null };`,
+          `for (let i = ${ops}.length - 1; i >= 0; i--) { ${bindings}.op = ${ops}[i]; ${bindings}.operand = ${value}; ${value} = ${combine}(${bindings}, c); }`,
+          "}",
+          `${result} = ${value};`,
+          "}"
+        );
+        return result;
+      }
+      case "postfix": {
+        const label2 = "L" + nextId();
+        const left = nextId();
+        const bindings = nextId();
+        const mark = nextId();
+        const combine = actionHelper(arg.combine);
+        out.push(tickSrc, `let ${result};`, `${label2}: {`);
+        const first = gen(arg.operand, out, bindingsVar);
+        out.push(
+          `if (${first} === F) { ${result} = F; break ${label2}; }`,
+          `let ${left} = ${first};`,
+          `let ${bindings} = null;`,
+          "for (;;) {",
+          `const ${mark} = c.idx;`
+        );
+        const found = gen(arg.suffix, out, bindingsVar);
+        out.push(
+          `if (${found} === F) { c.idx = ${mark}; break; }`,
+          `if (${bindings} === null) ${bindings} = { left: null, suffix: null };`,
+          `${bindings}.left = ${left}; ${bindings}.suffix = ${found};`,
+          `${left} = ${combine}(${bindings}, c);`,
+          "}",
+          `${result} = ${left};`,
+          "}"
+        );
+        return result;
+      }
+      case "manySep":
+      case "many1Sep": {
+        if (!arg || typeof arg !== "object") throw new Error("'manySep' expects { rule, sep }");
+        const atLeastOne = op === "many1Sep";
+        const sepNode = typeof arg.sep === "string" ? { consume: arg.sep } : arg.sep;
+        const trailing = arg.trailing === true;
+        const start = nextId();
+        const beforeSep = nextId();
+        const beforeItem = nextId();
+        const label2 = "L" + nextId();
+        out.push(tickSrc, `let ${result} = [];`, `${label2}: {`, `const ${start} = c.idx;`);
+        const first = gen(arg.rule, out, bindingsVar);
+        out.push(
+          `if (${first} === F) { c.idx = ${start}; ${result} = ${atLeastOne ? "F" : "[]"}; break ${label2}; }`,
+          `${result}.push(${first});`,
+          "for (;;) {",
+          `const ${beforeSep} = c.idx;`
+        );
+        const sep = gen(sepNode, out, bindingsVar);
+        out.push(`if (${sep} === F) { c.idx = ${beforeSep}; break; }`, `const ${beforeItem} = c.idx;`);
+        const item = gen(arg.rule, out, bindingsVar);
+        out.push(
+          `if (${item} === F) { c.idx = ${trailing ? beforeItem : beforeSep}; break; }`,
+          `${result}.push(${item});`,
+          "}",
+          "}"
+        );
+        return result;
+      }
+      case "subrule": {
+        const name = typeof arg === "string" ? arg : arg[0];
+        if (!(name in rules)) {
+          out.push(`const ${result} = ${helper(planner.plan(node), { kind: "unknownRule", name })}(c);`);
+          return result;
+        }
+        const index = indexOfRule(name);
+        const parent = nextId();
+        out.push(tickSrc);
+        if (memo) {
+          const key = nextId();
+          const hit = nextId();
+          const start = nextId();
+          out.push(
+            `let ${result};`,
+            `const ${key} = ${JSON.stringify(name + ":")} + c.idx;`,
+            `const ${hit} = c.memo.get(${key});`,
+            `if (${hit} !== undefined) { c.idx = ${hit}.end; ${result} = ${hit}.value; }`,
+            "else {",
+            `const ${start} = c.idx;`,
+            `const ${parent} = c.ruleDepth;`,
+            `if (c.track) { c.ruleNames[${parent}] = ${JSON.stringify(name)}; c.ruleDepth = ${parent} + 1; }`,
+            `${result} = R[${index}](c);`,
+            `if (c.track) c.ruleDepth = ${parent};`,
+            `if (${result} === F) c.idx = ${start};`,
+            `c.memo.set(${key}, { value: ${result}, end: c.idx });`,
+            "}"
+          );
+        } else {
+          out.push(
+            `const ${parent} = c.ruleDepth;`,
+            `if (c.track) { c.ruleNames[${parent}] = ${JSON.stringify(name)}; c.ruleDepth = ${parent} + 1; }`,
+            `const ${result} = R[${index}](c);`,
+            `if (c.track) c.ruleDepth = ${parent};`
+          );
+        }
+        return result;
+      }
+      default:
+        out.push(`const ${result} = ${helper(planner.plan(node))}(c);`);
+        return result;
+    }
+  }
+  function genSeq(children, out, result) {
+    if (!Array.isArray(children)) throw new Error("'seq' expects an array of parsers");
+    const idiom = recognizeSeqIdiom(children);
+    if (idiom !== null) return gen(idiom, out, null);
+    let hasLabels = false;
+    let hasAction = false;
+    for (const child of children) {
+      const childOp = opOf(child);
+      if (childOp === "label") hasLabels = true;
+      else if (childOp === "action") hasAction = true;
+    }
+    const needsScope = hasLabels || hasAction;
+    const start = nextId();
+    const label2 = "L" + nextId();
+    const bindingsVar = needsScope ? nextId() : null;
+    const saved = nextId();
+    const collected = [];
+    out.push(tickSrc, `let ${result};`, `${label2}: {`, `const ${start} = c.idx;`);
+    if (needsScope) {
+      out.push(`const ${saved} = c.bindings;`, `const ${bindingsVar} = {};`, `c.bindings = ${bindingsVar};`);
+    }
+    let actionResult = null;
+    for (const child of children) {
+      const childOp = opOf(child);
+      if (childOp === "action") {
+        actionResult = gen(child, out, bindingsVar);
+        continue;
+      }
+      const value = gen(child, out, bindingsVar);
+      out.push(
+        `if (${value} === F) { c.idx = ${start};` + (needsScope ? ` c.bindings = ${saved};` : "") + ` ${result} = F; break ${label2}; }`
+      );
+      collected.push(value);
+    }
+    if (needsScope) out.push(`c.bindings = ${saved};`);
+    out.push(`${result} = ${hasAction ? actionResult : "[" + collected.join(", ") + "]"};`, "}");
+    return result;
+  }
+  function genAlt(branches, out, result, bindingsVar) {
+    if (!Array.isArray(branches)) throw new Error("'alt' expects an array of branches");
+    const table = firsts ? buildDispatch(branches, firsts) : null;
+    const label2 = "L" + nextId();
+    if (table !== null) {
+      const expected = [...table.keys()];
+      const token = nextId();
+      out.push(tickSrc, `let ${result};`, `${label2}: {`, `const ${token} = c.tokens[c.idx];`);
+      out.push(`if (${token} === undefined) { ${expected.map((t) => `E(c, ${JSON.stringify(t)});`).join(" ")} ${result} = F; break ${label2}; }`);
+      out.push(`switch (${token}.type) {`);
+      const byBranch = /* @__PURE__ */ new Map();
+      for (const [tokenName, branch] of table) {
+        if (!byBranch.has(branch)) byBranch.set(branch, []);
+        byBranch.get(branch).push(tokenName);
+      }
+      for (const [branch, tokenNames] of byBranch) {
+        out.push(tokenNames.map((t) => `case ${JSON.stringify(t)}:`).join(" ") + " {");
+        const value = gen(branch, out, bindingsVar);
+        out.push(`${result} = ${value}; break ${label2};`, "}");
+      }
+      out.push(
+        `default: { ${expected.map((t) => `E(c, ${JSON.stringify(t)});`).join(" ")} ${result} = F; break ${label2}; }`,
+        "}",
+        "}"
+      );
+      return result;
+    }
+    const start = nextId();
+    out.push(tickSrc, `let ${result};`, `${label2}: {`, `const ${start} = c.idx;`);
+    for (const branch of branches) {
+      out.push("{");
+      const value = gen(branch, out, bindingsVar);
+      out.push(`if (${value} !== F) { ${result} = ${value}; break ${label2}; }`, `c.idx = ${start};`, "}");
+    }
+    out.push(`${result} = F;`, "}");
+    return result;
+  }
+  function buildRule(name) {
+    const out = [];
+    const value = gen(rules[name], out, null);
+    const body = `(c) => {
+${out.join("\n")}
+return ${value};
+}`;
+    SOURCES[ruleIndex.get(name)] = body;
+    const source = `return ${body}`;
+    const factory = new Function("F", "E", "P", "T", "R", "H", source);
+    return factory(FAIL, expect, progressError, stepsError, RULES, HELPERS);
+  }
+  function progressError(op, at) {
+    throw new Error(
+      `'${op}' matched without consuming any input at token index ${at}; this would loop forever. Make the repeated parser consume at least one token.`
+    );
+  }
+  function stepsError() {
+    throw new Error(`Parser exceeded maxSteps (${maxSteps}); the grammar is likely looping.`);
+  }
+  function compile(start) {
+    const index = indexOfRule(start);
+    while (pending.length) {
+      const name = pending.shift();
+      RULES[ruleIndex.get(name)] = buildRule(name);
+    }
+    return RULES[index];
+  }
+  function functionFor(name) {
+    const index = ruleIndex.get(name);
+    return index === void 0 ? null : RULES[index];
+  }
+  function sourceFor(name) {
+    const helperCount = HELPERS.length;
+    const pendingCount = pending.length;
+    try {
+      const out = [];
+      const value = gen(rules[name], out, null);
+      return `(c) => {
+${out.join("\n")}
+return ${value};
+}`;
+    } finally {
+      HELPERS.length = helperCount;
+      ORIGINS.length = helperCount;
+      pending.length = pendingCount;
+    }
+  }
+  return { compile, functionFor, sourceFor, ruleIndex, RULES, SOURCES, ORIGINS, guard };
+}
+
+// src/parser.js
+var EXECUTION_MODES = /* @__PURE__ */ new Set(["generated", "interpreted"]);
+var GrammarError = class extends Error {
+  /** @param {string[]} problems */
+  constructor(problems) {
+    super(`Invalid grammar:
+  - ${problems.join("\n  - ")}`);
+    this.name = "GrammarError";
+    this.problems = problems;
+  }
+};
+function createParser(spec, options = {}) {
+  const { tokens: tokenDefs, rules, start } = spec;
+  const {
+    memo = false,
+    strict = true,
+    validate = true,
+    maxSteps = 0,
+    ll1 = true,
+    execution = "generated",
+    positions = "full",
+    methods: extraMethods
+  } = options;
+  const mode = options.execution !== void 0 ? execution : options.compile === false || options.unsafeEval === false ? "interpreted" : "generated";
+  if (!EXECUTION_MODES.has(mode)) {
+    throw new Error(`createParser: \`execution\` must be one of ${[...EXECUTION_MODES].join(", ")}, got ${JSON.stringify(mode)}`);
+  }
+  const compile = mode === "generated";
+  const unsafeEval = mode === "generated";
+  if (!rules || typeof rules !== "object") throw new Error("createParser: `rules` must be an object of rule name -> logic");
+  if (!start) throw new Error("createParser: `start` is required");
+  if (!(start in rules)) throw new Error(`createParser: start rule '${start}' is not defined in rules`);
+  const lexer = createLexer(tokenDefs, { positions });
+  const analysis = analyze(rules, { tokenNames: lexer.tokenNames });
+  if (validate && analysis.errors.length > 0) throw new GrammarError(analysis.errors);
+  const engine = new LogicEngine();
+  for (const [name, method] of Object.entries(createMethods())) engine.addMethod(name, method);
+  for (const [name, method] of Object.entries(createValueMethods())) engine.addMethod(name, method);
+  for (const [name, method] of Object.entries(extraMethods || {})) engine.addMethod(name, method);
+  const startRule = rules[start];
+  const firsts = ll1 ? analysis.firsts : null;
+  const planner = createPlanner({ engine, rules, firsts, memo, maxSteps, unsafeEval });
+  engine.__jlGrammar = { planner };
+  const codegen = compile && unsafeEval ? createCodegen({ planner, rules, firsts, memo, maxSteps }) : null;
+  const compiledStart = codegen && codegen.compile(start);
+  if (codegen && !engine.disableInterpretedOptimization) {
+    for (const name of Object.keys(rules)) {
+      const generated = codegen.functionFor(name);
+      if (generated) engine.optimizedMap.set(rules[name], generated);
+    }
+  }
+  function parseTokens(tokens, source, track = false) {
+    const state = createState(tokens, rules, { memo, maxSteps, track });
+    state.firsts = firsts;
+    state.source = source;
+    state.positions = lexer.positions;
+    state.ruleNames[0] = start;
+    state.ruleDepth = 1;
+    const result = compiledStart ? compiledStart(state) : engine.run(startRule, state, { above: [] });
+    const trailing = strict && state.idx < tokens.length;
+    if (result !== FAIL && !trailing) return result;
+    if (!track) return parseTokens(tokens, source, true);
+    if (trailing && state.maxIdx < state.idx) {
+      state.maxIdx = state.idx;
+      state.expected = ["end of input"];
+      state.failureStack = state.ruleNames.slice(0, state.ruleDepth);
+    }
+    throw buildParseError(state);
+  }
+  function parse(text) {
+    return parseTokens(lexer.tokenize(text), text);
+  }
+  return {
+    parse,
+    parseTokens,
+    tokenize: lexer.tokenize,
+    lexer,
+    engine,
+    analysis,
+    planner,
+    codegen,
+    execution: mode,
+    compiled: Boolean(compiledStart),
+    /** Rules whose `alt`s resolved to O(1) LL(1) dispatch, for introspection. */
+    get firsts() {
+      return analysis.firsts;
+    }
+  };
+}
+
+// src/methodsblock.js
+var HEADER = /^[ \t]*methods[ \t]*\{/gm;
+var IMPORT = /^[ \t]*import\b[^\n]*?['"][^'"]+['"][ \t]*;?[ \t]*$/gm;
+var DECLARED_EXPORT = /^[ \t]*export[ \t]+(?:const|let|var|function|class|async[ \t]+function)[ \t]+([A-Za-z_$][\w$]*)/gm;
+var EXPORT_LIST = /^[ \t]*export[ \t]*\{([^}]*)\}[ \t]*;?[ \t]*$/gm;
+function splitMethodsBlock(source) {
+  HEADER.lastIndex = 0;
+  let header = null;
+  for (let match = HEADER.exec(source); match; match = HEADER.exec(source)) header = match;
+  if (!header) return { grammar: source, block: null };
+  const open = header.index + header[0].length;
+  const close = source.lastIndexOf("}");
+  if (close < open) throw new Error("methods block is not closed: no `}` after it");
+  const trailing = source.slice(close + 1).trim();
+  if (trailing) throw new Error(`the methods block must be the last thing in the file; found ${JSON.stringify(trailing.slice(0, 40))} after it`);
+  const blanked = source.slice(header.index, source.length).replace(/[^\n]/g, " ");
+  return { grammar: source.slice(0, header.index) + blanked, block: source.slice(open, close) };
+}
+function analyzeMethodsBlock(body) {
+  const names = [];
+  for (const match of body.matchAll(DECLARED_EXPORT)) names.push(match[1]);
+  for (const match of body.matchAll(EXPORT_LIST)) {
+    for (const entry of match[1].split(",")) {
+      const name = entry.trim().split(/\s+as\s+/).pop();
+      if (name) names.push(name);
+    }
+  }
+  return {
+    names,
+    hasDefault: /^[ \t]*export[ \t]+default\b/m.test(body),
+    imports: (body.match(IMPORT) || []).map((line) => line.trim())
+  };
+}
+function asFunctionBody(body, info) {
+  const stripped = body.replace(/^([ \t]*)export[ \t]+default[ \t]+/m, "$1const __default = ").replace(EXPORT_LIST, "").replace(/^([ \t]*)export[ \t]+/gm, "$1");
+  const table = info.hasDefault ? "__default" : `{ ${info.names.join(", ")} }`;
+  return `${stripped}
+return { methods: ${table}, exports: { ${info.names.join(", ")} } }`;
+}
+function evaluateMethodsBlock(body) {
+  const info = analyzeMethodsBlock(body);
+  if (info.imports.length > 0) {
+    throw new Error(
+      `this methods block imports, so it cannot be evaluated in place: ${JSON.stringify(info.imports[0])}. Generate a parser file from it instead (\`grammatik generate\`), or pass \`methods\` explicitly.`
+    );
+  }
+  if (!info.hasDefault && info.names.length === 0) {
+    throw new Error("methods block exports nothing; it needs `export default <table>` or named exports");
+  }
+  return new Function(asFunctionBody(body, info))();
+}
+function dedent(body) {
+  const lines = body.replace(/^\n+|\s+$/g, "").split("\n");
+  let common = Infinity;
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    common = Math.min(common, line.length - line.trimStart().length);
+  }
+  if (!Number.isFinite(common) || common === 0) return lines.join("\n");
+  return lines.map((line) => line.slice(common)).join("\n");
+}
+function toRequire(line) {
+  const namespace = line.match(/^import[ \t]*\*[ \t]*as[ \t]+([\w$]+)[ \t]+from[ \t]*(['"][^'"]+['"])/);
+  if (namespace) return `const ${namespace[1]} = require(${namespace[2]})`;
+  const named = line.match(/^import[ \t]*(\{[^}]*\})[ \t]*from[ \t]*(['"][^'"]+['"])/);
+  if (named) return `const ${named[1].replace(/\bas\b/g, ":")} = require(${named[2]})`;
+  const fallback = line.match(/^import[ \t]+([\w$]+)[ \t]+from[ \t]*(['"][^'"]+['"])/);
+  if (fallback) return `const ${fallback[1]} = require(${fallback[2]}).default ?? require(${fallback[2]})`;
+  const bare = line.match(/^import[ \t]*(['"][^'"]+['"])/);
+  if (bare) return `require(${bare[1]})`;
+  throw new Error(`cannot express this import in CommonJS, move it or emit ES modules: ${JSON.stringify(line)}`);
+}
+function emitMethodsBlock(body, format) {
+  const info = analyzeMethodsBlock(body);
+  if (!info.hasDefault && info.names.length === 0) {
+    throw new Error("methods block exports nothing; it needs `export default <table>` or named exports");
+  }
+  let source = dedent(body).replace(/^export[ \t]+default[ \t]+/m, "const __methods = ").replace(EXPORT_LIST, "").replace(/^export[ \t]+/gm, "");
+  if (format === "cjs") source = source.replace(IMPORT, (line) => toRequire(line.trim()));
+  return {
+    source,
+    table: info.hasDefault ? "__methods" : `{ ${info.names.join(", ")} }`,
+    names: info.names
+  };
+}
+
+// src/definition.js
+var consume = (name) => ({ consume: name });
+var subrule = (name) => ({ subrule: name });
+var label = (name, parser) => ({ label: [name, parser] });
+var seq = (...items) => ({ seq: items });
+var alt = (...items) => ({ alt: items });
+var many = (item) => ({ many: item });
+var action = (logic) => ({ action: logic });
+var call = (name, value) => ({ [`meta.${name}`]: value });
+var keyword = (name, literal2) => ({ name, literal: literal2, longerAlt: "Identifier" });
+var definitionTokens = [
+  { name: "Whitespace", pattern: "[ \\t\\r\\n]+", skip: true },
+  { name: "LineComment", pattern: "//[^\\r\\n]*", skip: true },
+  keyword("GrammarKeyword", "grammar"),
+  keyword("StartKeyword", "start"),
+  keyword("TokenKeyword", "token"),
+  keyword("RuleKeyword", "rule"),
+  keyword("PatternKeyword", "pattern"),
+  keyword("LiteralKeyword", "literal"),
+  keyword("SkipKeyword", "skip"),
+  keyword("IgnoreCaseKeyword", "ignoreCase"),
+  keyword("LongerAltKeyword", "longerAlt"),
+  keyword("ModeKeyword", "mode"),
+  keyword("PushModeKeyword", "pushMode"),
+  keyword("PopModeKeyword", "popMode"),
+  keyword("TrueKeyword", "true"),
+  keyword("FalseKeyword", "false"),
+  keyword("NullKeyword", "null"),
+  { name: "String", pattern: '"(?:\\\\.|[^"\\\\])*"' },
+  { name: "Number", pattern: "-?(?:0|[1-9][0-9]*)(?:\\.[0-9]+)?(?:[eE][+-]?[0-9]+)?" },
+  { name: "Identifier", pattern: "[A-Za-z_][A-Za-z0-9_]*" },
+  { name: "LParen", literal: "(" },
+  { name: "RParen", literal: ")" },
+  { name: "LBrace", literal: "{" },
+  { name: "RBrace", literal: "}" },
+  { name: "LBracket", literal: "[" },
+  { name: "RBracket", literal: "]" },
+  { name: "Comma", literal: "," },
+  { name: "Colon", literal: ":" },
+  { name: "Equals", literal: "=" },
+  { name: "Semicolon", literal: ";" }
+];
+var identifier = seq(label("token", consume("Identifier")), action({ val: ["token", "image"] }));
+var stringValue = seq(label("token", consume("String")), action(call("string", { val: ["token", "image"] })));
+var definitionRules = {
+  Document: seq(
+    consume("GrammarKeyword"),
+    label("name", subrule("IdentifierValue")),
+    consume("Semicolon"),
+    consume("StartKeyword"),
+    label("start", subrule("IdentifierValue")),
+    consume("Semicolon"),
+    label("declarations", many(subrule("Declaration"))),
+    action(call("document", [{ val: "name" }, { val: "start" }, { val: "declarations" }]))
+  ),
+  Declaration: alt(subrule("TokenDeclaration"), subrule("RuleDeclaration")),
+  TokenDeclaration: seq(
+    consume("TokenKeyword"),
+    label("name", subrule("IdentifierValue")),
+    label("kind", subrule("TokenKind")),
+    label("flags", many(subrule("TokenFlag"))),
+    consume("Semicolon"),
+    action(call("token", [{ val: "name" }, { val: "kind" }, { val: "flags" }]))
+  ),
+  TokenKind: alt(
+    seq(consume("PatternKeyword"), label("source", subrule("StringValue")), action(["pattern", { val: "source" }])),
+    seq(consume("LiteralKeyword"), label("source", subrule("StringValue")), action(["literal", { val: "source" }]))
+  ),
+  TokenFlag: alt(
+    seq(consume("SkipKeyword"), action(["skip", true])),
+    seq(consume("IgnoreCaseKeyword"), action(["ignoreCase", true])),
+    seq(consume("LongerAltKeyword"), label("name", subrule("IdentifierValue")), action(["longerAlt", { val: "name" }])),
+    // `mode` may be repeated, for a token that serves several modes.
+    seq(consume("ModeKeyword"), label("name", subrule("IdentifierValue")), action(["mode", { val: "name" }])),
+    seq(consume("PushModeKeyword"), label("name", subrule("IdentifierValue")), action(["pushMode", { val: "name" }])),
+    seq(consume("PopModeKeyword"), action(["popMode", true]))
+  ),
+  RuleDeclaration: seq(
+    consume("RuleKeyword"),
+    label("name", subrule("IdentifierValue")),
+    consume("Equals"),
+    label("parser", subrule("ParserExpression")),
+    consume("Semicolon"),
+    action(call("rule", [{ val: "name" }, { val: "parser" }]))
+  ),
+  ParserExpression: subrule("Call"),
+  Call: seq(
+    label("name", subrule("IdentifierValue")),
+    consume("LParen"),
+    label("args", subrule("CallArguments")),
+    consume("RParen"),
+    action(call("call", [{ val: "name" }, { val: "args" }]))
+  ),
+  CallArguments: alt(
+    seq({ lookahead: consume("RParen") }, action([])),
+    seq(
+      label("head", subrule("CallArgument")),
+      label("tail", many(seq(consume("Comma"), label("value", subrule("CallArgument")), action({ val: "value" })))),
+      action(call("list", [{ val: "head" }, { val: "tail" }]))
+    )
+  ),
+  CallArgument: alt(subrule("Call"), subrule("JsonValue"), subrule("IdentifierValue")),
+  JsonValue: alt(
+    subrule("JsonObject"),
+    subrule("JsonArray"),
+    subrule("StringValue"),
+    subrule("NumberValue"),
+    seq(consume("TrueKeyword"), action(true)),
+    seq(consume("FalseKeyword"), action(false)),
+    seq(consume("NullKeyword"), action(null))
+  ),
+  JsonObject: alt(
+    seq(consume("LBrace"), consume("RBrace"), action(call("object", []))),
+    seq(
+      consume("LBrace"),
+      label("head", subrule("JsonPair")),
+      label("tail", many(seq(consume("Comma"), label("pair", subrule("JsonPair")), action({ val: "pair" })))),
+      consume("RBrace"),
+      action(call("object", [{ val: "head" }, { val: "tail" }]))
+    )
+  ),
+  JsonPair: seq(
+    label("key", subrule("StringValue")),
+    consume("Colon"),
+    label("value", subrule("JsonValue")),
+    action([{ val: "key" }, { val: "value" }])
+  ),
+  JsonArray: alt(
+    seq(consume("LBracket"), consume("RBracket"), action([])),
+    seq(
+      consume("LBracket"),
+      label("head", subrule("JsonValue")),
+      label("tail", many(seq(consume("Comma"), label("value", subrule("JsonValue")), action({ val: "value" })))),
+      consume("RBracket"),
+      action(call("list", [{ val: "head" }, { val: "tail" }]))
+    )
+  ),
+  IdentifierValue: identifier,
+  StringValue: stringValue,
+  NumberValue: seq(label("token", consume("Number")), action(call("number", { val: ["token", "image"] })))
+};
+var definitionGrammar = { tokens: definitionTokens, rules: definitionRules, start: "Document" };
+function createMetaMethods() {
+  const methods = {
+    string: (image) => JSON.parse(image),
+    number: (image) => Number(image),
+    list: ([head, tail]) => {
+      const output = new Array(tail.length + 1);
+      output[0] = head;
+      for (let i = 0; i < tail.length; i++) output[i + 1] = tail[i];
+      return output;
+    },
+    object: (value) => {
+      const output = {};
+      if (value.length === 0) return output;
+      const head = value[0];
+      const tail = value[1];
+      output[head[0]] = head[1];
+      for (let i = 0; i < tail.length; i++) output[tail[i][0]] = tail[i][1];
+      return output;
+    },
+    token: ([name, kind, flags]) => {
+      const value = { name, [kind[0]]: kind[1] };
+      const modes = [];
+      for (let i = 0; i < flags.length; i++) {
+        if (flags[i][0] === "mode") modes.push(flags[i][1]);
+        else value[flags[i][0]] = flags[i][1];
+      }
+      if (modes.length === 1) value.mode = modes[0];
+      else if (modes.length > 1) value.modes = modes;
+      return ["token", value];
+    },
+    rule: ([name, parser]) => ["rule", name, parser],
+    document: ([name, start, declarations]) => {
+      const tokens = [];
+      const rules = {};
+      for (let i = 0; i < declarations.length; i++) {
+        const declaration = declarations[i];
+        if (declaration[0] === "token") tokens.push(declaration[1]);
+        else rules[declaration[1]] = declaration[2];
+      }
+      return { name, tokens, rules, start };
+    },
+    call: ([name, args]) => {
+      const build = CONSTRUCTORS[name];
+      if (!build) throw new Error(`Unknown parser constructor ${name}`);
+      if (args.length < build.arity[0] || args.length > build.arity[1]) {
+        const [min, max] = build.arity;
+        const expected = min === max ? String(min) : `${min}-${max}`;
+        throw new Error(`${name} expects ${expected} argument(s), received ${args.length}`);
+      }
+      return build.of(args);
+    }
+  };
+  const descriptors = {};
+  for (const key of Object.keys(methods)) {
+    descriptors[`meta.${key}`] = { method: methods[key], optimizeUnary: true };
+  }
+  return descriptors;
+}
+var VARIADIC = [0, Infinity];
+var logicOf = (node) => node && node.action !== void 0 ? node.action : node;
+var CONSTRUCTORS = {
+  seq: { arity: VARIADIC, of: (args) => ({ seq: args }) },
+  alt: { arity: VARIADIC, of: (args) => ({ alt: args }) },
+  oneOf: { arity: VARIADIC, of: (args) => ({ oneOf: args }) },
+  consume: { arity: [1, 1], of: ([a]) => ({ consume: a }) },
+  subrule: { arity: [1, 1], of: ([a]) => ({ subrule: a }) },
+  many: { arity: [1, 1], of: ([a]) => ({ many: a }) },
+  many1: { arity: [1, 1], of: ([a]) => ({ many1: a }) },
+  option: { arity: [1, 1], of: ([a]) => ({ option: a }) },
+  action: { arity: [1, 1], of: ([a]) => ({ action: a }) },
+  lookahead: { arity: [1, 1], of: ([a]) => ({ lookahead: a }) },
+  negLookahead: { arity: [1, 1], of: ([a]) => ({ negLookahead: a }) },
+  text: { arity: [1, 1], of: ([a]) => ({ text: a }) },
+  eof: { arity: [0, 0], of: () => ({ eof: null }) },
+  epsilon: { arity: [0, 0], of: () => ({ epsilon: null }) },
+  label: { arity: [2, 2], of: ([a, b]) => ({ label: [a, b] }) },
+  as: { arity: [2, 2], of: ([a, b]) => ({ as: [a, logicOf(b)] }) },
+  manySep: { arity: [2, 2], of: ([a, b]) => ({ manySep: { rule: a, sep: b } }) },
+  many1Sep: { arity: [2, 2], of: ([a, b]) => ({ many1Sep: { rule: a, sep: b } }) },
+  between: { arity: [3, 3], of: ([a, b, c]) => ({ between: { open: a, body: b, close: c } }) },
+  infixLeft: { arity: [3, 3], of: ([a, b, c]) => ({ infixLeft: { operand: a, operator: b, combine: logicOf(c) } }) },
+  infixRight: { arity: [3, 3], of: ([a, b, c]) => ({ infixRight: { operand: a, operator: b, combine: logicOf(c) } }) },
+  prefix: { arity: [3, 3], of: ([a, b, c]) => ({ prefix: { operator: a, operand: b, combine: logicOf(c) } }) },
+  postfix: { arity: [3, 3], of: ([a, b, c]) => ({ postfix: { operand: a, suffix: b, combine: logicOf(c) } }) }
+};
+var CONSTRUCTOR_NAMES = Object.keys(CONSTRUCTORS);
+var createDefinitionParser = (options = {}) => createParser(definitionGrammar, { ...options, methods: createMetaMethods() });
+function parseDefinition(source, options = {}) {
+  const { grammar: text, block } = splitMethodsBlock(source);
+  const grammar = createDefinitionParser(options).parse(text);
+  if (block !== null) grammar.methodsBlock = block;
+  return grammar;
+}
+function createParserFromSource(source, options = {}) {
+  const grammar = parseDefinition(source, { execution: options.execution });
+  if (grammar.methodsBlock === void 0 || options.methods) return createParser(grammar, options);
+  const { methods } = evaluateMethodsBlock(grammar.methodsBlock);
+  return createParser(grammar, { ...options, methods });
+}
+
+// src/emit.js
+import { Compiler, LogicEngine as LogicEngine2 } from "json-logic-engine";
+var UNSUPPORTED = /\b(coerceArray|precoerceNumber|compareCheck|assertAllowedDepth|assertSize|asyncIterators|notTraversed)\b|(?<!engine\.)\bmethods\[|engine\.(?!methods\b)/;
+function inlineAction(logic, engine) {
+  try {
+    const seed = { engine };
+    Compiler.build(logic, seed);
+    const state = {
+      engine,
+      compile: seed.compile,
+      values: [],
+      methods: [],
+      notTraversed: [],
+      processing: [],
+      state: {}
+    };
+    const source = Compiler.buildString(logic, state);
+    if (state.methods.length || state.notTraversed.length || state.processing.length) return null;
+    if (UNSUPPORTED.test(source)) return null;
+    let values = null;
+    if (state.values.length > 0) {
+      values = JSON.stringify(state.values);
+      if (JSON.parse(values) === void 0) return null;
+      if (JSON.stringify(JSON.parse(values)) !== values) return null;
+    }
+    return {
+      source,
+      values,
+      needsMethods: source.includes("engine.methods"),
+      needsAbove: /\babove\b/.test(source)
+    };
+  } catch {
+    return null;
+  }
+}
+function tryEvaluate(body) {
+  try {
+    return evaluateMethodsBlock(body).methods;
+  } catch {
+    return null;
+  }
+}
+var quote = (value) => JSON.stringify(value);
+var literal = (value, indent = 0) => JSON.stringify(value, null, 2).split("\n").join("\n" + " ".repeat(indent));
+function emitModule(spec, options = {}) {
+  const { tokens: tokenDefs, rules, start } = spec;
+  const {
+    memo = false,
+    strict = true,
+    ll1 = true,
+    maxSteps = 0,
+    positions = "full",
+    execution = "generated",
+    format = "esm",
+    validate = true,
+    moduleName = spec.name || "parser",
+    runtimeSpecifier = "grammatik/runtime",
+    engineSpecifier = "json-logic-engine",
+    methods: semanticMethods
+  } = options;
+  if (format !== "esm" && format !== "cjs") throw new Error(`emitModule: format must be 'esm' or 'cjs', got ${quote(format)}`);
+  const methodsBlock = options.methodsBlock !== void 0 ? options.methodsBlock : spec.methodsBlock;
+  const block = methodsBlock ? emitMethodsBlock(methodsBlock, format) : null;
+  if (!start || !(start in rules)) throw new Error(`emitModule: start rule '${start}' is not defined in rules`);
+  const lexer = createLexer(tokenDefs, { positions });
+  const analysis = analyze(rules, { tokenNames: lexer.tokenNames });
+  if (validate && analysis.errors.length > 0) throw new GrammarError(analysis.errors);
+  const firsts = ll1 ? analysis.firsts : null;
+  const engine = { build: () => {
+    throw new Error("not compiled during emit");
+  }, run: () => {
+  } };
+  const planner = createPlanner({ engine, rules, firsts, memo, maxSteps, unsafeEval: false });
+  const codegen = createCodegen({ planner, rules, firsts, memo, maxSteps });
+  codegen.compile(start);
+  const reached = [...codegen.ruleIndex.entries()].sort((a, b) => a[1] - b[1]);
+  const unsupported = codegen.ORIGINS.map((origin, index) => ({ origin, index })).filter(({ origin }) => origin.kind === "unknownRule");
+  if (unsupported.length > 0) {
+    const names = unsupported.map(({ origin }) => origin.name).join(", ");
+    throw new Error(`emitModule: cannot emit a grammar with unknown rules (${names})`);
+  }
+  const blockMethods = block && !semanticMethods ? tryEvaluate(methodsBlock) : null;
+  const compileEngine = new LogicEngine2();
+  for (const [name, method] of Object.entries(createValueMethods())) compileEngine.addMethod(name, method);
+  for (const [name, method] of Object.entries(semanticMethods || blockMethods || {})) compileEngine.addMethod(name, method);
+  let needsEngine = execution === "interpreted";
+  let needsAbove = false;
+  const emitAction = (logic) => {
+    if (usesOuterScope(logic) || execution === "interpreted") {
+      needsEngine = true;
+      return `interpretedAction(${literal(logic, 2)})`;
+    }
+    const inlined = inlineAction(logic, compileEngine);
+    if (!inlined) {
+      needsEngine = true;
+      return `action(${literal(logic, 2)})`;
+    }
+    if (inlined.needsAbove) needsAbove = true;
+    const body = `(context) => { let prev; return ${inlined.source} }`;
+    return inlined.values ? `((values) => ${body})(${inlined.values})` : body;
+  };
+  const helpers = codegen.ORIGINS.map((origin) => {
+    if (origin.kind === "constant") return `constant(${literal(origin.node, 2)})`;
+    if (origin.kind === "action") return emitAction(origin.logic);
+    if (origin.kind === "valueExpression") return `valueExpression(${emitAction(origin.logic)})`;
+    throw new Error(`emitModule: unsupported helper (${origin.kind})`);
+  });
+  const engineFree = !needsEngine;
+  const ruleSources = reached.map(
+    ([name, index]) => `// ${name}
+R[${index}] = ${codegen.SOURCES[index]}`
+  ).join("\n\n");
+  const interpretedActions = execution === "interpreted";
+  const cjs = format === "cjs";
+  const runtimeImports = ["FAIL as F", "expect as E", "createState", "buildParseError", "createLexer"];
+  if (needsEngine) runtimeImports.push("createValueMethods");
+  const importRuntime = cjs ? `const { ${runtimeImports.map((b) => b.replace(" as ", ": ")).join(", ")} } = require(${quote(runtimeSpecifier)})` : `import { ${runtimeImports.join(", ")} } from ${quote(runtimeSpecifier)}`;
+  const importEngine = engineFree ? "" : cjs ? `const { LogicEngine } = require(${quote(engineSpecifier)})
+` : `import { LogicEngine } from ${quote(engineSpecifier)}
+`;
+  const PUBLIC = ["parse", "parseTokens", "tokenize", "tokens", "start", "registerMethods"];
+  for (const name of block ? block.names : []) {
+    if (PUBLIC.includes(name)) throw new Error(`emitModule: the methods block exports '${name}', which the generated parser already exports`);
+  }
+  const exported = block ? [...PUBLIC, ...block.names] : PUBLIC;
+  const exports = cjs ? `module.exports = { ${exported.join(", ")} }
+// Named the same under \`default\`, so an \`import parser from\` interops.
+module.exports.default = module.exports` : `export { ${exported.join(", ")} }
+export default { ${PUBLIC.join(", ")} }`;
+  return `// Generated by grammatik from the ${quote(moduleName)} grammar. Do not edit.
+//
+// The grammar was analyzed when this file was written: FIRST sets, left-recursion
+// checks and rule specialization all happened then. Importing it does no grammar
+// work and generates no code.
+${engineFree ? "// Every semantic action was compiled to source too, so this file has no\n// dependency on json-logic-engine at all." : interpretedActions ? "// Semantic actions are interpreted, so nothing here calls `eval`." : "// Semantic actions that could not be compiled to source are shipped as JSON\n// Logic and built by json-logic-engine when this module loads."}
+
+${importRuntime}
+${importEngine}
+
+const tokens = ${literal(tokenDefs)}
+
+const start = ${quote(start)}
+
+const lexer = createLexer(tokens, { positions: ${quote(positions)} })
+const tokenize = lexer.tokenize
+
+${engineFree ? `// Every semantic action compiled to source, so the engine reduced to a table
+// of the methods below. Nothing here imports json-logic-engine.
+const M = Object.create(null)
+const engine = { methods: M }
+${needsAbove ? "const above = []\n" : ""}
+/**
+ * Semantic methods the grammar refers to. Pass the same object you would give
+ * \`createParser\`; anything the actions call must be registered before use.
+ */
+function registerMethods (methods) {
+  for (const [name, method] of Object.entries(methods || {})) {
+    M[name] = typeof method === 'function' ? { method } : method
+  }
+  return engine
+}` : `const engine = new LogicEngine()
+for (const [name, method] of Object.entries(createValueMethods())) engine.addMethod(name, method)
+${needsAbove ? "const above = []\n" : ""}
+/**
+ * Semantic methods the grammar refers to. Pass the same object you would give
+ * \`createParser\`; anything the actions call must be registered before use.
+ */
+function registerMethods (methods) {
+  for (const [name, method] of Object.entries(methods || {})) engine.addMethod(name, method)
+  return engine
+}`}
+
+${block ? `// ---------------------------------------------------------------------------
+// The grammar's \`methods { ... }\` block, written out as source. It is registered
+// below, so importing this module is enough \u2014 no wiring at the call site.
+// ---------------------------------------------------------------------------
+
+${block.source}
+
+registerMethods(${block.table})
+` : ""}
+${engineFree ? "" : `const interpretedAction = (logic) => (bindings, state) => engine.run(logic, bindings, { above: [state] })
+`}
+${engineFree ? "" : interpretedActions ? "const action = interpretedAction" : `const action = (logic) => {
+  // Compiled on first use, so \`registerMethods\` can run first.
+  let fn
+  return (bindings, state) => {
+    if (fn === undefined) {
+      try {
+        const built = engine.build(logic)
+        fn = typeof built === 'function' ? (b) => built(b) : () => built
+      } catch {
+        fn = (b, s) => engine.run(logic, b, { above: [s] })
+      }
+    }
+    return fn(bindings, state)
+  }
+}`}
+
+/** A JSON Logic value expression sitting in parser position. */
+const valueExpression = (run) => (state) => run(state.bindings || {}, state)
+const constant = (value) => () => value
+
+const P = (op, at) => {
+  throw new Error(\`'\${op}' matched without consuming any input at token index \${at}; this would loop forever.\`)
+}
+const T = () => { throw new Error('Parser exceeded maxSteps (${maxSteps}); the grammar is likely looping.') }
+
+/** Rule functions, indexed. Filled below; recursion resolves through the array. */
+const R = []
+
+/** Values the rules close over: semantic actions and literals. */
+const H = [
+${helpers.map((source, index) => `  /* ${index} */ ${source}`).join(",\n")}
+]
+
+${ruleSources}
+
+const RULES = ${literal(Object.fromEntries(reached.map(([name, index]) => [name, index])))}
+
+/**
+ * Parses a token stream you lexed yourself.
+ * @param {any[]} tokenList
+ * @param {string} [source]
+ */
+function parseTokens (tokenList, source, track = false) {
+  const state = createState(tokenList, {}, { memo: ${memo}, maxSteps: ${maxSteps}, track })
+  state.source = source
+  state.positions = ${quote(positions)}
+  state.ruleNames[0] = start
+  state.ruleDepth = 1
+
+  const result = R[RULES[start]](state)
+  const trailing = ${strict ? "state.idx < tokenList.length" : "false"}
+  if (result !== F && !trailing) return result
+
+  if (!track) return parseTokens(tokenList, source, true)
+  if (trailing && state.maxIdx < state.idx) {
+    state.maxIdx = state.idx
+    state.expected = ['end of input']
+    state.failureStack = state.ruleNames.slice(0, state.ruleDepth)
+  }
+  throw buildParseError(state)
+}
+
+/** Lexes and parses text. @param {string} text */
+function parse (text) {
+  return parseTokens(lexer.tokenize(text), text)
+}
+
+${exports}
+`;
+}
+export {
+  CONSTRUCTOR_NAMES,
+  FAIL,
+  GrammarError,
+  LexError,
+  OPERATORS,
+  PARSER_OPS,
+  ParseError,
+  analyze,
+  analyzeMethodsBlock,
+  buildDispatch,
+  createDefinitionParser,
+  createLexer,
+  createMethods,
+  createParser,
+  createParserFromSource,
+  createState,
+  createValueMethods,
+  definitionGrammar,
+  definitionRules,
+  definitionTokens,
+  emitModule,
+  evaluateMethodsBlock,
+  firstOf,
+  parseDefinition,
+  splitMethodsBlock
+};