grammatik 0.1.0

package/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/dist/esm/runtime.js

@@ -0,0 +1,605 @@
+// 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/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 alt = def.longerAltDef;
+    if (alt.literal !== void 0) return text.startsWith(alt.literal, offset) ? offset + alt.literal.length : -1;
+    alt.regex.lastIndex = offset;
+    return alt.regex.test(text) ? alt.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/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 }
+});
+export {
+  FAIL,
+  LexError,
+  ParseError,
+  buildParseError,
+  createLexer,
+  createState,
+  createValueMethods,
+  expect
+};