emj 0.0.11 → 0.2.0

package/lib/parser.js

@@ -0,0 +1,364 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = void 0;
+const characters_1 = require("./characters");
+const limits_1 = require("./limits");
+const Kind = {
+    EOF: 0,
+    Invalid: 1,
+    Space: 2,
+    Start: 3,
+    End: 4,
+    Indent: 5,
+    Outdent: 6,
+    Open: 7,
+    Close: 8,
+    Delimit: 9,
+    KeyChar: 10,
+    KeyUpper: 11,
+    KeyUnicode: 12,
+    KeyNibble: 13,
+    KeyEmpty: 14,
+    ValueChar: 15,
+    ValueUpper: 16,
+    ValueUnicode: 17,
+    ValueNibble: 18,
+    ValueEmpty: 19,
+    Digit: 20,
+    Decimal: 21,
+    Exponent: 22,
+    Negative: 23,
+    True: 24,
+    False: 25,
+    Null: 26,
+};
+// Each token is `kind | code << 8`, looked up by code point in a typed array:
+// one for the BMP (where spaces and a few emoji live) and one for the block
+// of astral emoji, U+1F300–U+1FAFF. Unlisted code points stay Invalid.
+// This makes parse() 19–31% faster than a Map did (see bench/RESULTS.md).
+const ASTRAL_START = 0x1f300;
+const ASTRAL_SIZE = 0x800;
+const BMP_TOKENS = new Uint16Array(0x10000).fill(Kind.Invalid);
+const ASTRAL_TOKENS = new Uint16Array(ASTRAL_SIZE).fill(Kind.Invalid);
+function lookup(point) {
+    if (point < 0x10000)
+        return BMP_TOKENS[point];
+    const offset = point - ASTRAL_START;
+    return offset >= 0 && offset < ASTRAL_SIZE
+        ? ASTRAL_TOKENS[offset]
+        : Kind.Invalid;
+}
+function setToken(point, token) {
+    const offset = point - ASTRAL_START;
+    if (point < 0x10000)
+        BMP_TOKENS[point] = token;
+    else if (offset >= 0 && offset < ASTRAL_SIZE)
+        ASTRAL_TOKENS[offset] = token;
+    else
+        throw new Error(`U+${point.toString(16)} is outside the token table`);
+}
+const define = (emoji, kind, code = 0) => {
+    setToken(emoji.codePointAt(0), kind | (code << 8));
+};
+define(characters_1.characters.document.start, Kind.Start);
+define(characters_1.characters.document.end, Kind.End);
+define(characters_1.characters.document.indent, Kind.Indent);
+define(characters_1.characters.document.outdent, Kind.Outdent);
+define(characters_1.characters.document.arrayOpen, Kind.Open);
+define(characters_1.characters.document.arrayClose, Kind.Close);
+define(characters_1.characters.document.arrayDelimit, Kind.Delimit);
+define(characters_1.characters.keys.modifiers.upperCase, Kind.KeyUpper);
+define(characters_1.characters.keys.modifiers.unicode, Kind.KeyUnicode);
+define(characters_1.characters.keys.other.empty, Kind.KeyEmpty);
+define(characters_1.characters.values.modifiers.upperCase, Kind.ValueUpper);
+define(characters_1.characters.values.modifiers.unicode, Kind.ValueUnicode);
+define(characters_1.characters.values.modifiers.negative, Kind.Negative);
+define(characters_1.characters.values.other.emptyString, Kind.ValueEmpty);
+define(characters_1.characters.values.other.null, Kind.Null);
+define(characters_1.characters.values.booleans.true, Kind.True);
+define(characters_1.characters.values.booleans.false, Kind.False);
+for (const [char, emoji] of Object.entries(characters_1.characters.keys.letters)) {
+    define(emoji, Kind.KeyChar, char.charCodeAt(0));
+}
+for (const [char, emoji] of Object.entries(characters_1.characters.keys.numerals)) {
+    define(emoji, Kind.KeyChar, char.charCodeAt(0));
+}
+for (const [hex, emoji] of Object.entries(characters_1.characters.keys.unicode)) {
+    define(emoji, Kind.KeyNibble, parseInt(hex, 16));
+}
+for (const [char, emoji] of Object.entries(characters_1.characters.values.letters)) {
+    define(emoji, Kind.ValueChar, char.charCodeAt(0));
+}
+for (const [char, emoji] of Object.entries(characters_1.characters.values.numerals)) {
+    define(emoji, Kind.ValueChar, char.charCodeAt(0));
+}
+for (const [hex, emoji] of Object.entries(characters_1.characters.values.unicode)) {
+    define(emoji, Kind.ValueNibble, parseInt(hex, 16));
+}
+for (const [char, emoji] of Object.entries(characters_1.characters.values.numbers)) {
+    const kind = char === '.' ? Kind.Decimal : char === 'e' ? Kind.Exponent : Kind.Digit;
+    define(emoji, kind, char.charCodeAt(0));
+}
+// every /\s/ character, plus the variation selector some emoji carry
+for (const space of [
+    0x9, 0xa, 0xb, 0xc, 0xd, 0x20, 0xa0, 0x1680, 0x2000, 0x2001, 0x2002, 0x2003,
+    0x2004, 0x2005, 0x2006, 0x2007, 0x2008, 0x2009, 0x200a, 0x2028, 0x2029,
+    0x202f, 0x205f, 0x3000, 0xfeff, 0xfe0f,
+]) {
+    setToken(space, Kind.Space);
+}
+const OBJECT_PROTOTYPE = Object.prototype;
+let source = '';
+let index = 0;
+let at = 0;
+let point = 0;
+let kind = Kind.EOF;
+let code = 0;
+let depth = 0;
+function next() {
+    while (index < source.length) {
+        at = index;
+        point = source.codePointAt(index);
+        index += point > 0xffff ? 2 : 1;
+        const token = lookup(point);
+        if (token === Kind.Space)
+            continue;
+        kind = token & 0xff;
+        code = token >> 8;
+        return kind;
+    }
+    at = index;
+    kind = Kind.EOF;
+    return kind;
+}
+function fail() {
+    if (kind === Kind.EOF) {
+        throw new SyntaxError('Unexpected end of Emojion input');
+    }
+    throw new SyntaxError(`Unexpected "${String.fromCodePoint(point)}" in Emojion at position ${at}`);
+}
+function nest() {
+    if (++depth > limits_1.MAX_DEPTH) {
+        throw new SyntaxError(`Emojion nesting exceeds ${limits_1.MAX_DEPTH} levels at position ${at}`);
+    }
+}
+function expect(expected) {
+    if (kind !== expected)
+        fail();
+    next();
+}
+function text(char, upper, unicode, nibble) {
+    let out = '';
+    for (;;) {
+        if (kind === char) {
+            out += String.fromCharCode(code);
+            next();
+        }
+        else if (kind === upper) {
+            next();
+            if (kind !== char || code < 97)
+                fail();
+            out += String.fromCharCode(code - 32);
+            next();
+        }
+        else if (kind === unicode) {
+            next();
+            if (kind !== nibble)
+                fail();
+            // U+10FFFF, the highest code point, needs six nibbles.
+            let value = 0;
+            let nibbles = 0;
+            do {
+                if (++nibbles > 6)
+                    fail();
+                value = value * 16 + code;
+                if (value > 0x10ffff)
+                    fail();
+                next();
+            } while (kind === nibble);
+            out += String.fromCodePoint(value);
+        }
+        else {
+            return out;
+        }
+    }
+}
+function digits() {
+    if (kind !== Kind.Digit)
+        fail();
+    let out = '';
+    do {
+        out += String.fromCharCode(code);
+        next();
+    } while (kind === Kind.Digit);
+    return out;
+}
+function number() {
+    let out = '';
+    if (kind === Kind.Negative) {
+        out = '-';
+        next();
+    }
+    if (kind === Kind.Digit && code === 48) {
+        out += '0';
+        next();
+        if (kind === Kind.Digit)
+            fail();
+    }
+    else {
+        out += digits();
+    }
+    if (kind === Kind.Decimal) {
+        next();
+        out += '.' + digits();
+    }
+    if (kind === Kind.Exponent) {
+        if (next() === Kind.Negative) {
+            out += 'e-';
+            next();
+        }
+        else {
+            out += 'e';
+        }
+        out += digits();
+    }
+    return Number(out);
+}
+function members(close) {
+    const out = {};
+    while (kind !== close) {
+        let key = '';
+        if (kind === Kind.KeyEmpty) {
+            next();
+        }
+        else if (kind === Kind.KeyChar ||
+            kind === Kind.KeyUpper ||
+            kind === Kind.KeyUnicode) {
+            key = text(Kind.KeyChar, Kind.KeyUpper, Kind.KeyUnicode, Kind.KeyNibble);
+        }
+        else {
+            fail();
+        }
+        const item = value();
+        if (key in OBJECT_PROTOTYPE) {
+            // Assigning a key that out inherits would run its setter (__proto__
+            // would set the prototype) or fail if it is read-only. Define it as
+            // an own property instead, as JSON.parse() does.
+            Object.defineProperty(out, key, {
+                value: item,
+                writable: true,
+                enumerable: true,
+                configurable: true,
+            });
+        }
+        else {
+            // A repeated key overwrites the earlier one: the last wins.
+            out[key] = item;
+        }
+    }
+    return out;
+}
+function array() {
+    const out = [];
+    if (next() === Kind.Close) {
+        next();
+        return out;
+    }
+    out.push(value());
+    while (kind === Kind.Delimit) {
+        next();
+        out.push(value());
+    }
+    expect(Kind.Close);
+    return out;
+}
+function value() {
+    switch (kind) {
+        case Kind.Indent: {
+            nest();
+            next();
+            const out = members(Kind.Outdent);
+            next();
+            depth--;
+            return out;
+        }
+        case Kind.Open: {
+            nest();
+            const out = array();
+            depth--;
+            return out;
+        }
+        case Kind.True:
+            next();
+            return true;
+        case Kind.False:
+            next();
+            return false;
+        case Kind.Null:
+            next();
+            return null;
+        case Kind.ValueEmpty:
+            next();
+            return '';
+        case Kind.Negative:
+        case Kind.Digit:
+            return number();
+        case Kind.ValueChar:
+        case Kind.ValueUpper:
+        case Kind.ValueUnicode:
+            return text(Kind.ValueChar, Kind.ValueUpper, Kind.ValueUnicode, Kind.ValueNibble);
+    }
+    return fail();
+}
+/**
+ * Parse an Emojion document into the value it holds, as `JSON.parse()` parses
+ * JSON text.
+ *
+ * Objects come back as plain objects and arrays as plain arrays. A key that
+ * `Object.prototype` has, such as `__proto__`, becomes an ordinary own
+ * property and never changes the prototype. When a key repeats, the last
+ * value wins.
+ *
+ * @param emojion - The document, from `🙌` to `✋`. Whitespace and U+FE0F
+ * variation selectors anywhere in it are ignored.
+ * @returns The object, array, string, number, boolean or `null` it holds.
+ * @throws {SyntaxError} If the document is not valid Emojion, naming the
+ * unexpected emoji and its position, or if it nests arrays and objects more
+ * than 512 levels deep.
+ *
+ * @example
+ * parse('🙌😶😠🤑😳👡🐘🐁🦉🦒🐖🦉🦏✋');
+ * //=> { name: 'Emojion' }
+ *
+ * @example
+ * parse('🙌🤜🕐🤝💚🤝🕳🤛✋');
+ * //=> [1, true, null]
+ */
+const parse = (emojion) => {
+    source = emojion;
+    index = 0;
+    depth = 0;
+    try {
+        next();
+        expect(Kind.Start);
+        // A top-level object is written without 👉👈.
+        if (kind === Kind.Indent)
+            fail();
+        const out = kind === Kind.End ||
+            kind === Kind.KeyEmpty ||
+            kind === Kind.KeyChar ||
+            kind === Kind.KeyUpper ||
+            kind === Kind.KeyUnicode
+            ? members(Kind.End)
+            : value();
+        expect(Kind.End);
+        if (kind !== Kind.EOF)
+            fail();
+        return out;
+    }
+    finally {
+        source = '';
+    }
+};
+exports.parse = parse;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"parser.js","sourceRoot":"","sources":["../src/parser.ts"],"names":[],"mappings":"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","sourcesContent":["import { characters } from './characters';\nimport type { Json } from './json';\nimport { MAX_DEPTH } from './limits';\n\nconst Kind = {\n  EOF: 0,\n  Invalid: 1,\n  Space: 2,\n  Start: 3,\n  End: 4,\n  Indent: 5,\n  Outdent: 6,\n  Open: 7,\n  Close: 8,\n  Delimit: 9,\n  KeyChar: 10,\n  KeyUpper: 11,\n  KeyUnicode: 12,\n  KeyNibble: 13,\n  KeyEmpty: 14,\n  ValueChar: 15,\n  ValueUpper: 16,\n  ValueUnicode: 17,\n  ValueNibble: 18,\n  ValueEmpty: 19,\n  Digit: 20,\n  Decimal: 21,\n  Exponent: 22,\n  Negative: 23,\n  True: 24,\n  False: 25,\n  Null: 26,\n} as const;\n\n// Each token is `kind | code << 8`, looked up by code point in a typed array:\n// one for the BMP (where spaces and a few emoji live) and one for the block\n// of astral emoji, U+1F300–U+1FAFF. Unlisted code points stay Invalid.\n// This makes parse() 19–31% faster than a Map did (see bench/RESULTS.md).\nconst ASTRAL_START = 0x1f300;\nconst ASTRAL_SIZE = 0x800;\nconst BMP_TOKENS = new Uint16Array(0x10000).fill(Kind.Invalid);\nconst ASTRAL_TOKENS = new Uint16Array(ASTRAL_SIZE).fill(Kind.Invalid);\n\nfunction lookup(point: number): number {\n  if (point < 0x10000) return BMP_TOKENS[point];\n  const offset = point - ASTRAL_START;\n  return offset >= 0 && offset < ASTRAL_SIZE\n    ? ASTRAL_TOKENS[offset]\n    : Kind.Invalid;\n}\n\nfunction setToken(point: number, token: number) {\n  const offset = point - ASTRAL_START;\n  if (point < 0x10000) BMP_TOKENS[point] = token;\n  else if (offset >= 0 && offset < ASTRAL_SIZE) ASTRAL_TOKENS[offset] = token;\n  else throw new Error(`U+${point.toString(16)} is outside the token table`);\n}\n\nconst define = (emoji: string, kind: number, code = 0) => {\n  setToken(emoji.codePointAt(0)!, kind | (code << 8));\n};\n\ndefine(characters.document.start, Kind.Start);\ndefine(characters.document.end, Kind.End);\ndefine(characters.document.indent, Kind.Indent);\ndefine(characters.document.outdent, Kind.Outdent);\ndefine(characters.document.arrayOpen, Kind.Open);\ndefine(characters.document.arrayClose, Kind.Close);\ndefine(characters.document.arrayDelimit, Kind.Delimit);\ndefine(characters.keys.modifiers.upperCase, Kind.KeyUpper);\ndefine(characters.keys.modifiers.unicode, Kind.KeyUnicode);\ndefine(characters.keys.other.empty, Kind.KeyEmpty);\ndefine(characters.values.modifiers.upperCase, Kind.ValueUpper);\ndefine(characters.values.modifiers.unicode, Kind.ValueUnicode);\ndefine(characters.values.modifiers.negative, Kind.Negative);\ndefine(characters.values.other.emptyString, Kind.ValueEmpty);\ndefine(characters.values.other.null, Kind.Null);\ndefine(characters.values.booleans.true, Kind.True);\ndefine(characters.values.booleans.false, Kind.False);\n\nfor (const [char, emoji] of Object.entries(characters.keys.letters)) {\n  define(emoji, Kind.KeyChar, char.charCodeAt(0));\n}\nfor (const [char, emoji] of Object.entries(characters.keys.numerals)) {\n  define(emoji, Kind.KeyChar, char.charCodeAt(0));\n}\nfor (const [hex, emoji] of Object.entries(characters.keys.unicode)) {\n  define(emoji, Kind.KeyNibble, parseInt(hex, 16));\n}\nfor (const [char, emoji] of Object.entries(characters.values.letters)) {\n  define(emoji, Kind.ValueChar, char.charCodeAt(0));\n}\nfor (const [char, emoji] of Object.entries(characters.values.numerals)) {\n  define(emoji, Kind.ValueChar, char.charCodeAt(0));\n}\nfor (const [hex, emoji] of Object.entries(characters.values.unicode)) {\n  define(emoji, Kind.ValueNibble, parseInt(hex, 16));\n}\nfor (const [char, emoji] of Object.entries(characters.values.numbers)) {\n  const kind =\n    char === '.' ? Kind.Decimal : char === 'e' ? Kind.Exponent : Kind.Digit;\n  define(emoji, kind, char.charCodeAt(0));\n}\n\n// every /\\s/ character, plus the variation selector some emoji carry\nfor (const space of [\n  0x9, 0xa, 0xb, 0xc, 0xd, 0x20, 0xa0, 0x1680, 0x2000, 0x2001, 0x2002, 0x2003,\n  0x2004, 0x2005, 0x2006, 0x2007, 0x2008, 0x2009, 0x200a, 0x2028, 0x2029,\n  0x202f, 0x205f, 0x3000, 0xfeff, 0xfe0f,\n]) {\n  setToken(space, Kind.Space);\n}\n\nconst OBJECT_PROTOTYPE = Object.prototype;\n\nlet source = '';\nlet index = 0;\nlet at = 0;\nlet point = 0;\nlet kind: number = Kind.EOF;\nlet code = 0;\nlet depth = 0;\n\nfunction next(): number {\n  while (index < source.length) {\n    at = index;\n    point = source.codePointAt(index)!;\n    index += point > 0xffff ? 2 : 1;\n    const token = lookup(point);\n    if (token === Kind.Space) continue;\n    kind = token & 0xff;\n    code = token >> 8;\n    return kind;\n  }\n  at = index;\n  kind = Kind.EOF;\n  return kind;\n}\n\nfunction fail(): never {\n  if (kind === Kind.EOF) {\n    throw new SyntaxError('Unexpected end of Emojion input');\n  }\n  throw new SyntaxError(\n    `Unexpected \"${String.fromCodePoint(point)}\" in Emojion at position ${at}`\n  );\n}\n\nfunction nest() {\n  if (++depth > MAX_DEPTH) {\n    throw new SyntaxError(\n      `Emojion nesting exceeds ${MAX_DEPTH} levels at position ${at}`\n    );\n  }\n}\n\nfunction expect(expected: number) {\n  if (kind !== expected) fail();\n  next();\n}\n\nfunction text(\n  char: number,\n  upper: number,\n  unicode: number,\n  nibble: number\n): string {\n  let out = '';\n  for (;;) {\n    if (kind === char) {\n      out += String.fromCharCode(code);\n      next();\n    } else if (kind === upper) {\n      next();\n      if (kind !== char || code < 97) fail();\n      out += String.fromCharCode(code - 32);\n      next();\n    } else if (kind === unicode) {\n      next();\n      if (kind !== nibble) fail();\n      // U+10FFFF, the highest code point, needs six nibbles.\n      let value = 0;\n      let nibbles = 0;\n      do {\n        if (++nibbles > 6) fail();\n        value = value * 16 + code;\n        if (value > 0x10ffff) fail();\n        next();\n      } while (kind === nibble);\n      out += String.fromCodePoint(value);\n    } else {\n      return out;\n    }\n  }\n}\n\nfunction digits(): string {\n  if (kind !== Kind.Digit) fail();\n  let out = '';\n  do {\n    out += String.fromCharCode(code);\n    next();\n  } while (kind === Kind.Digit);\n  return out;\n}\n\nfunction number(): number {\n  let out = '';\n  if (kind === Kind.Negative) {\n    out = '-';\n    next();\n  }\n  if (kind === Kind.Digit && code === 48) {\n    out += '0';\n    next();\n    if (kind === Kind.Digit) fail();\n  } else {\n    out += digits();\n  }\n  if (kind === Kind.Decimal) {\n    next();\n    out += '.' + digits();\n  }\n  if (kind === Kind.Exponent) {\n    if (next() === Kind.Negative) {\n      out += 'e-';\n      next();\n    } else {\n      out += 'e';\n    }\n    out += digits();\n  }\n  return Number(out);\n}\n\nfunction members(close: number): { [key: string]: Json } {\n  const out: { [key: string]: Json } = {};\n  while (kind !== close) {\n    let key = '';\n    if (kind === Kind.KeyEmpty) {\n      next();\n    } else if (\n      kind === Kind.KeyChar ||\n      kind === Kind.KeyUpper ||\n      kind === Kind.KeyUnicode\n    ) {\n      key = text(Kind.KeyChar, Kind.KeyUpper, Kind.KeyUnicode, Kind.KeyNibble);\n    } else {\n      fail();\n    }\n    const item = value();\n    if (key in OBJECT_PROTOTYPE) {\n      // Assigning a key that out inherits would run its setter (__proto__\n      // would set the prototype) or fail if it is read-only. Define it as\n      // an own property instead, as JSON.parse() does.\n      Object.defineProperty(out, key, {\n        value: item,\n        writable: true,\n        enumerable: true,\n        configurable: true,\n      });\n    } else {\n      // A repeated key overwrites the earlier one: the last wins.\n      out[key] = item;\n    }\n  }\n  return out;\n}\n\nfunction array(): Json[] {\n  const out: Json[] = [];\n  if (next() === Kind.Close) {\n    next();\n    return out;\n  }\n  out.push(value());\n  while (kind === Kind.Delimit) {\n    next();\n    out.push(value());\n  }\n  expect(Kind.Close);\n  return out;\n}\n\nfunction value(): Json {\n  switch (kind) {\n    case Kind.Indent: {\n      nest();\n      next();\n      const out = members(Kind.Outdent);\n      next();\n      depth--;\n      return out;\n    }\n    case Kind.Open: {\n      nest();\n      const out = array();\n      depth--;\n      return out;\n    }\n    case Kind.True:\n      next();\n      return true;\n    case Kind.False:\n      next();\n      return false;\n    case Kind.Null:\n      next();\n      return null;\n    case Kind.ValueEmpty:\n      next();\n      return '';\n    case Kind.Negative:\n    case Kind.Digit:\n      return number();\n    case Kind.ValueChar:\n    case Kind.ValueUpper:\n    case Kind.ValueUnicode:\n      return text(\n        Kind.ValueChar,\n        Kind.ValueUpper,\n        Kind.ValueUnicode,\n        Kind.ValueNibble\n      );\n  }\n  return fail();\n}\n\n/**\n * Parse an Emojion document into the value it holds, as `JSON.parse()` parses\n * JSON text.\n *\n * Objects come back as plain objects and arrays as plain arrays. A key that\n * `Object.prototype` has, such as `__proto__`, becomes an ordinary own\n * property and never changes the prototype. When a key repeats, the last\n * value wins.\n *\n * @param emojion - The document, from `🙌` to `✋`. Whitespace and U+FE0F\n * variation selectors anywhere in it are ignored.\n * @returns The object, array, string, number, boolean or `null` it holds.\n * @throws {SyntaxError} If the document is not valid Emojion, naming the\n * unexpected emoji and its position, or if it nests arrays and objects more\n * than 512 levels deep.\n *\n * @example\n * parse('🙌😶😠🤑😳👡🐘🐁🦉🦒🐖🦉🦏✋');\n * //=> { name: 'Emojion' }\n *\n * @example\n * parse('🙌🤜🕐🤝💚🤝🕳🤛✋');\n * //=> [1, true, null]\n */\nexport const parse = (emojion: string): Json => {\n  source = emojion;\n  index = 0;\n  depth = 0;\n  try {\n    next();\n    expect(Kind.Start);\n    // A top-level object is written without 👉👈.\n    if (kind === Kind.Indent) fail();\n    const out =\n      kind === Kind.End ||\n      kind === Kind.KeyEmpty ||\n      kind === Kind.KeyChar ||\n      kind === Kind.KeyUpper ||\n      kind === Kind.KeyUnicode\n        ? members(Kind.End)\n        : value();\n    expect(Kind.End);\n    if (kind !== Kind.EOF) fail();\n    return out;\n  } finally {\n    source = '';\n  }\n};\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "emj",
-  "version": "0.0.11",
+  "version": "0.2.0",
   "description": "Emoji Object Notation",
   "license": "MIT",
   "repository": {
@@ -18,59 +18,54 @@
   "files": [
     "lib"
   ],
-  "main": "lib/src/index.js",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
   "scripts": {
     "clean": "rimraf lib && rimraf coverage",
     "format": "prettier --write \"src/**/*.ts\" \"test/**/*.{ts,cjs}\" README.md",
     "format:check": "prettier --check \"src/**/*.ts\" \"test/**/*.{ts,cjs}\" README.md",
     "lint": "eslint src/**/*.ts",
     "prebuild": "npm run clean && npm run format:check && npm run lint && echo Using TypeScript && tsc --version",
-    "build": "npm run build:grammar && npm run build:lib && npm run build:bundle",
-    "build:grammar": "mkdir -p gen && nearleyc src/grammar.ne -o gen/grammar.ts && replace-in-file \"Lexer: lexer,\" \"// @ts-ignore\nLexer: lexer,\" gen/grammar.ts",
+    "build": "npm run build:lib && npm run build:bundle",
     "build:bundle": "npm run rollup",
     "build:lib": "tsc --pretty",
     "start": "npm run build && npm run test",
-    "test": "npm run build:grammar && vitest run --allowOnly=false",
+    "test": "vitest run --allowOnly=false",
     "test:consumer": "node test/consumer-smoke.cjs .",
-    "coverage": "npm run build:grammar && vitest run --coverage",
+    "coverage": "vitest run --coverage",
     "update": "ncu -u && npm i && npm test",
     "rollup": "rollup --config rollup.config.mjs",
     "watch": "npm run build -- --watch",
-    "watch:test": "vitest"
-  },
-  "dependencies": {
-    "lodash": "^4.18.1",
-    "moo": "^0.5.3",
-    "nearley": "^2.20.1"
+    "watch:test": "vitest",
+    "bench": "npm run build:lib && node --expose-gc bench/index.mjs",
+    "bench:ab": "node bench/ab.mjs"
   },
   "devDependencies": {
-    "@emnapi/core": "^1.10.0",
-    "@emnapi/runtime": "^1.10.0",
+    "@emnapi/core": "^1.11.3",
+    "@emnapi/runtime": "^1.11.3",
     "@eslint/js": "^10.0.1",
-    "@rollup/plugin-commonjs": "^29.0.2",
-    "@rollup/plugin-node-resolve": "^16.0.3",
-    "@rollup/plugin-typescript": "^12.3.0",
-    "@types/lodash": "^4.17.24",
-    "@types/moo": "^0.5.10",
-    "@types/nearley": "^2.11.5",
-    "@types/node": "^26.1.1",
-    "@typescript-eslint/eslint-plugin": "^8.59.2",
-    "@typescript-eslint/parser": "^8.59.2",
-    "@vitest/coverage-v8": "^4.1.8",
-    "eslint": "^10.3.0",
+    "@rollup/plugin-typescript": "^12.3.1",
+    "@types/node": "^26.6.6",
+    "@typescript-eslint/eslint-plugin": "^8.72.2",
+    "@typescript-eslint/parser": "^8.72.2",
+    "@vitest/coverage-v8": "^5.1.0",
+    "eslint": "^10.14.0",
     "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-prettier": "^5.5.5",
-    "globals": "^17.6.0",
-    "npm-check-updates": "^23.0.0",
-    "prettier": "^3.9.6",
-    "replace-in-file": "^9.0.0",
-    "rimraf": "^6.1.3",
-    "rollup": "^4.60.3",
-    "tslib": "^2.8.1",
+    "eslint-plugin-prettier": "^5.5.7",
+    "globals": "^17.14.0",
+    "mitata": "^1.0.34",
+    "npm-check-updates": "^23.1.1",
+    "prettier": "^3.10.0",
+    "rimraf": "^6.1.4",
+    "rollup": "^4.68.2",
+    "tslib": "^2.9.1",
     "typescript": "^6.0.3",
-    "vitest": "^4.1.8"
+    "vitest": "^5.1.0"
   },
   "engines": {
     "node": ">=10.0.0"
+  },
+  "overrides": {
+    "minimatch": "^11.0.1"
   }
 }