emj 0.1.0 → 0.2.0

package/README.md

@@ -25,22 +25,115 @@ _Emoji Object Notation_
 
 ## Use
 
-Call `parse()` to turn Emojion into its original JSON text string, and call
-`generate()` to turn JSON text into Emojion.
+```sh
+npm install emj
+```
+
+`emj` works like the built-in `JSON` object. `parse()` turns Emojion into a
+JavaScript value, and `stringify()` turns a value into Emojion.
+
+```ts
+import { parse, stringify } from 'emj';
+
+const value = parse('🙌😶😠🤑😳👡🐘🐁🦉🦒🐖🦉🦏✋');
+// { name: 'Emojion' }
+
+const emojion = stringify({ created: 2019 });
+// '🙌😖😭😳😠😛😳🤤🕑🕛🕐🕘✋'
+
+parse(stringify({ when: new Date(0), list: [1, undefined] }));
+// { when: '1970-01-01T00:00:00.000Z', list: [1, null] }
+```
+
+It works in Node 10 and later, from CommonJS (`require('emj')`) or ESM.
+
+### `parse(emojion)`
+
+Reads an Emojion document and returns the value it holds: an object, array,
+string, number, boolean or `null`, built the same way `JSON.parse()` would build
+it.
+
+- Objects are plain objects and arrays are plain arrays.
+- A `__proto__` key becomes an ordinary own property; it never sets the
+  prototype. The same goes for any other key that `Object.prototype` has, such
+  as `toString`.
+- When a key repeats, the last value wins.
+- Numbers are converted the way `JSON.parse()` converts them, so `⏰🕛` is `-0`
+  and digits beyond double precision are rounded.
+
+### `stringify(value)`
+
+Writes a value as an Emojion document, following the rules of
+`JSON.stringify()`:
+
+- It calls a value's `toJSON()` method, so a `Date` becomes its ISO string.
+- It unwraps `new Number()`, `new String()` and `new Boolean()`.
+- It writes `NaN`, `Infinity` and `-Infinity` as `null`, and `-0` as `0`.
+- In objects, it skips properties whose value is `undefined`, a function or a
+  symbol. In arrays, it writes them, and holes, as `null`.
+- It writes only own enumerable string keys, so symbol keys are skipped, and a
+  `Map`, `Set` or class instance becomes an object of its own properties.
+
+`stringify()` has no `replacer` or `space` argument, and `parse()` has no
+`reviver`.
+
+### Errors and limits
+
+- `parse()` throws a `SyntaxError` for input that is not valid Emojion. The
+  message names the unexpected emoji and its position.
+- `stringify()` throws a `TypeError` for a `BigInt` (unless `BigInt.prototype`
+  has a `toJSON()`) and for a circular structure.
+- `stringify()` also throws a `TypeError` for a value Emojion cannot hold at
+  all: `undefined`, a function or a symbol on its own, or a `toJSON()` that
+  returns one. `JSON.stringify()` returns `undefined` in those cases, but every
+  Emojion document holds a value.
+- Arrays and objects can be nested up to 512 levels deep. A top-level object
+  doesn't count, because it has no `👉👈`. Past that, `parse()` throws a
+  `SyntaxError` and `stringify()` throws a `RangeError`.
+
+### TypeScript
+
+The package ships type definitions. `parse()` returns the exported `Json` type:
 
 ```ts
-import { generate, parse } from 'emj';
+import type { Json } from 'emj';
+// string | number | boolean | null | Json[] | { [key: string]: Json }
+```
 
-const json = parse('🙌😶😠🤑😳👡🐘🐁🦉🦒🐖🦉🦏✋');
-// '{"name":"Emojion"}'
+`stringify()` accepts `unknown`, as `JSON.stringify()` accepts any value.
 
-const emojion = generate(JSON.stringify({ created: 2019 }));
-// 🙌😖😭😳😠😛😳🤤🕑🕛🕐🕘✋
+### JSON text
+
+To convert between Emojion and JSON text, combine the two with `JSON`:
+
+```ts
+const toJson = (emojion: string) => JSON.stringify(parse(emojion));
+const fromJson = (json: string) => stringify(JSON.parse(json));
 ```
 
-Both functions use JSON text so every valid JSON value can round-trip without
-losing type information. `parse()` throws a `SyntaxError` if its input is not
-valid Emojion.
+### Migrating from 0.1
+
+In 0.1, both functions worked with JSON text. In 0.2 they work with values.
+
+| 0.1                               | 0.2                              |
+| --------------------------------- | -------------------------------- |
+| `JSON.parse(parse(emojion))`      | `parse(emojion)`                 |
+| `parse(emojion)`                  | `JSON.stringify(parse(emojion))` |
+| `generate(json)`                  | `stringify(JSON.parse(json))`    |
+| `generate(JSON.stringify(value))` | `stringify(value)`               |
+
+- `generate()` is gone. Use `stringify()`, which takes a value, not JSON text.
+  Passing JSON text to `stringify()` writes it as a string, so make sure every
+  old `generate(json)` call becomes `stringify(JSON.parse(json))`.
+- `parse()` returns a value, not a string. If you kept the 0.1 JSON text without
+  parsing it, note that a repeated key was in the text twice; now only the last
+  value is kept, as `JSON.parse()` would have done.
+- `stringify()` applies the `JSON.stringify()` rules above itself. A `BigInt`, a
+  circular structure, or a top-level `undefined`, function or symbol throws a
+  `TypeError` from `stringify()` rather than from your own `JSON.stringify()`
+  call (or, for a top-level `undefined`, rather than passing `undefined` on).
+- The `RangeError` for deep nesting now says "Value nesting exceeds 512 levels"
+  instead of "JSON nesting exceeds 512 levels".
 
 ## Syntax
 
@@ -105,5 +198,9 @@ When your coworker tells you YAML is "too hard to read".
 
 ## Tech
 
-Emojion has no runtime dependencies. It reads each document in a single pass
-with a hand-written parser. Run `npm run bench` to measure its speed.
+Emojion has no runtime dependencies. `parse()` reads each document in a single
+pass with a hand-written parser that builds values as it goes, and `stringify()`
+walks the value directly; neither goes through JSON text. Run `npm run bench` to
+measure their speed next to `JSON.parse()` and `JSON.stringify()`, or
+`npm run bench:ab -- <ref> <ref>` to compare two versions. See
+[`bench/RESULTS.md`](./bench/RESULTS.md) for measurements.

package/lib/generator.d.ts

@@ -1 +1,29 @@
-export declare const generate: (input: string) => string;
+/**
+ * Write a value as an Emojion document, as `JSON.stringify()` writes JSON
+ * text, following the same rules:
+ *
+ * - It calls a value's `toJSON(key)` method, so a `Date` becomes its ISO
+ *   string.
+ * - It unwraps `new Number()`, `new String()` and `new Boolean()`.
+ * - It writes `NaN`, `Infinity` and `-Infinity` as `null`, and `-0` as `0`.
+ * - It skips `undefined`, functions and symbols in objects, and writes them
+ *   (and array holes) as `null` in arrays.
+ * - It writes only own enumerable string keys.
+ *
+ * @param value - The value to write.
+ * @returns The Emojion document, from `🙌` to `✋`.
+ * @throws {TypeError} For a BigInt (unless `BigInt.prototype.toJSON` is
+ * defined), for a circular structure, and for a value Emojion cannot hold at
+ * all: `undefined`, a function or a symbol on its own. (`JSON.stringify()`
+ * returns `undefined` for those; every Emojion document holds a value.)
+ * @throws {RangeError} If arrays and objects nest more than 512 levels deep.
+ *
+ * @example
+ * stringify({ created: 2019 });
+ * //=> '🙌😖😭😳😠😛😳🤤🕑🕛🕐🕘✋'
+ *
+ * @example
+ * stringify([1, undefined, new Date(0)]);
+ * //=> the same document as stringify([1, null, '1970-01-01T00:00:00.000Z'])
+ */
+export declare const stringify: (value: unknown) => string;

package/lib/generator.js

@@ -1,101 +1,270 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generate = void 0;
+exports.stringify = void 0;
 const characters_1 = require("./characters");
 const limits_1 = require("./limits");
-const KEYS = Array.from({ length: 128 }, () => '');
-const VALUES = Array.from({ length: 128 }, () => '');
-for (const [char, emoji] of Object.entries(characters_1.characters.keys.letters)) {
-    KEYS[char.charCodeAt(0)] = emoji;
-    KEYS[char.toUpperCase().charCodeAt(0)] =
-        characters_1.characters.keys.modifiers.upperCase + emoji;
-}
-for (const [char, emoji] of Object.entries(characters_1.characters.keys.numerals)) {
-    KEYS[char.charCodeAt(0)] = emoji;
+function makeAlphabet(letters, numerals, modifiers, hex) {
+    const result = {
+        ascii: [],
+        pairs: new Array(128 * 128),
+        unicode: modifiers.unicode,
+        nibbles: Array.from({ length: 16 }, (_, i) => hex[i.toString(16)]),
+    };
+    for (let c = 0; c < 128; c++)
+        result.ascii[c] = escapeSequence(c, result);
+    for (const [char, emoji] of Object.entries(letters)) {
+        result.ascii[char.charCodeAt(0)] = emoji;
+        result.ascii[char.toUpperCase().charCodeAt(0)] =
+            modifiers.upperCase + emoji;
+    }
+    for (const [char, emoji] of Object.entries(numerals)) {
+        result.ascii[char.charCodeAt(0)] = emoji;
+    }
+    return result;
 }
-for (const [char, emoji] of Object.entries(characters_1.characters.values.letters)) {
-    VALUES[char.charCodeAt(0)] = emoji;
-    VALUES[char.toUpperCase().charCodeAt(0)] =
-        characters_1.characters.values.modifiers.upperCase + emoji;
+const KEYS = makeAlphabet(characters_1.characters.keys.letters, characters_1.characters.keys.numerals, characters_1.characters.keys.modifiers, characters_1.characters.keys.unicode);
+const VALUES = makeAlphabet(characters_1.characters.values.letters, characters_1.characters.values.numerals, characters_1.characters.values.modifiers, characters_1.characters.values.unicode);
+// Indexed by the char codes of String(number).
+const NUMBERS = [];
+for (const [char, emoji] of Object.entries(Object.assign(Object.assign({}, characters_1.characters.values.numbers), { '-': characters_1.characters.values.modifiers.negative, '+': '' }))) {
+    NUMBERS[char.charCodeAt(0)] = emoji;
 }
-for (const [char, emoji] of Object.entries(characters_1.characters.values.numerals)) {
-    VALUES[char.charCodeAt(0)] = emoji;
+/** The escape for a code point: the unicode modifier, then its hex digits. */
+function escapeSequence(point, alphabet) {
+    let shift = 20;
+    while (shift > 0 && point >> shift === 0)
+        shift -= 4;
+    let out = alphabet.unicode;
+    for (; shift >= 0; shift -= 4)
+        out += alphabet.nibbles[(point >> shift) & 15];
+    return out;
 }
-const KEY_NIBBLES = characters_1.characters.keys.unicode;
-const VALUE_NIBBLES = characters_1.characters.values.unicode;
-const NUMBERS = Object.assign(Object.assign({}, characters_1.characters.values.numbers), { '-': characters_1.characters.values.modifiers.negative, '+': '' });
-function encode(text, table, unicode, nibbles) {
+function encode(text, alphabet) {
+    const { ascii, pairs } = alphabet;
     let out = '';
-    for (let i = 0; i < text.length; i++) {
-        const emoji = table[text.charCodeAt(i)];
-        if (emoji) {
-            out += emoji;
+    let i = 0;
+    while (i < text.length) {
+        const c = text.charCodeAt(i);
+        if (c < 128) {
+            const d = i + 1 < text.length ? text.charCodeAt(i + 1) : 128;
+            if (d < 128) {
+                const pair = (c << 7) | d;
+                let emoji = pairs[pair];
+                if (emoji === undefined)
+                    emoji = pairs[pair] = ascii[c] + ascii[d];
+                out += emoji;
+                i += 2;
+            }
+            else {
+                out += ascii[c];
+                i++;
+            }
             continue;
         }
         const point = text.codePointAt(i);
-        if (point > 0xffff)
-            i++;
-        out += unicode;
-        for (const hex of point.toString(16))
-            out += nibbles[hex];
+        i += point > 0xffff ? 2 : 1;
+        out += escapeSequence(point, alphabet);
     }
     return out;
 }
-function nest(depth) {
+const NULL = characters_1.characters.values.other.null;
+const TRUE = characters_1.characters.values.booleans.true;
+const FALSE = characters_1.characters.values.booleans.false;
+const EMPTY_STRING = characters_1.characters.values.other.emptyString;
+const EMPTY_KEY = characters_1.characters.keys.other.empty;
+const INDENT = characters_1.characters.document.indent;
+const OUTDENT = characters_1.characters.document.outdent;
+const OPEN = characters_1.characters.document.arrayOpen;
+const CLOSE = characters_1.characters.document.arrayClose;
+const DELIMIT = characters_1.characters.document.arrayDelimit;
+// The objects being written, outermost first, to catch circular structures.
+let ancestors = [];
+const toTag = Object.prototype.toString;
+function nest(value, depth) {
+    if (ancestors.indexOf(value) !== -1) {
+        throw new TypeError('Converting circular structure to Emojion');
+    }
     if (depth >= limits_1.MAX_DEPTH) {
-        throw new RangeError(`JSON nesting exceeds ${limits_1.MAX_DEPTH} levels, the most Emojion supports`);
+        throw new RangeError(`Value nesting exceeds ${limits_1.MAX_DEPTH} levels, the most Emojion supports`);
     }
+    ancestors.push(value);
     return depth + 1;
 }
-function encodeObject(object, depth) {
-    let out = '';
-    for (const key of Object.keys(object)) {
-        out += key
-            ? encode(key, KEYS, characters_1.characters.keys.modifiers.unicode, KEY_NIBBLES)
-            : characters_1.characters.keys.other.empty;
-        out += encodeValue(object[key], depth);
+function is(check) {
+    try {
+        check();
+        return true;
+    }
+    catch (_a) {
+        return false;
     }
-    return out;
 }
-function encodeValue(value, depth) {
-    if (typeof value === 'string') {
-        return value
-            ? encode(value, VALUES, characters_1.characters.values.modifiers.unicode, VALUE_NIBBLES)
-            : characters_1.characters.values.other.emptyString;
+/**
+ * Turn a boxed primitive back into its primitive, as JSON.stringify() does.
+ * The tag check is cheap; the valueOf() brand check confirms it.
+ */
+function unbox(value) {
+    switch (toTag.call(value)) {
+        case '[object Number]':
+            return is(() => Number.prototype.valueOf.call(value))
+                ? Number(value)
+                : value;
+        case '[object String]':
+            return is(() => String.prototype.valueOf.call(value))
+                ? String(value)
+                : value;
+        case '[object Boolean]':
+            return is(() => Boolean.prototype.valueOf.call(value))
+                ? Boolean.prototype.valueOf.call(value)
+                : value;
+        case '[object BigInt]':
+            return typeof BigInt === 'function' &&
+                is(() => BigInt.prototype.valueOf.call(value))
+                ? BigInt.prototype.valueOf.call(value)
+                : value;
+    }
+    return value;
+}
+/**
+ * Apply toJSON() and unwrap boxed primitives, the steps JSON.stringify()
+ * takes before it looks at a value's type.
+ */
+function resolve(value, key) {
+    if (typeof value === 'object') {
+        if (value === null)
+            return value;
+        const toJSON = value.toJSON;
+        if (typeof toJSON === 'function') {
+            value = toJSON.call(value, String(key));
+            if (typeof value !== 'object' || value === null)
+                return value;
+        }
+        if (Array.isArray(value))
+            return value;
+        const proto = Object.getPrototypeOf(value);
+        return proto === Object.prototype || proto === null
+            ? value
+            : unbox(value);
+    }
+    if (typeof value === 'bigint') {
+        const toJSON = value.toJSON;
+        if (typeof toJSON === 'function')
+            return toJSON.call(value, String(key));
     }
-    if (typeof value === 'number') {
-        let out = '';
-        for (const char of String(value))
-            out += NUMBERS[char];
-        return out;
+    return value;
+}
+function encodeMembers(object, depth) {
+    let out = '';
+    const keys = Object.keys(object);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const value = encodeValue(resolve(object[key], key), depth);
+        if (value === undefined)
+            continue;
+        out += key ? encode(key, KEYS) : EMPTY_KEY;
+        out += value;
     }
-    if (typeof value === 'boolean') {
-        return value
-            ? characters_1.characters.values.booleans.true
-            : characters_1.characters.values.booleans.false;
+    return out;
+}
+function encodeArray(array, depth) {
+    let out = OPEN;
+    for (let i = 0; i < array.length; i++) {
+        if (i)
+            out += DELIMIT;
+        const value = encodeValue(resolve(array[i], i), depth);
+        out += value === undefined ? NULL : value;
     }
-    if (value === null)
-        return characters_1.characters.values.other.null;
-    const inner = nest(depth);
-    if (Array.isArray(value)) {
-        let out = characters_1.characters.document.arrayOpen;
-        for (let i = 0; i < value.length; i++) {
-            if (i)
-                out += characters_1.characters.document.arrayDelimit;
-            out += encodeValue(value[i], inner);
+    return out + CLOSE;
+}
+/**
+ * Write a resolved value. Returns undefined for the values JSON.stringify()
+ * skips: undefined, functions and symbols.
+ */
+function encodeValue(value, depth) {
+    switch (typeof value) {
+        case 'string':
+            return value ? encode(value, VALUES) : EMPTY_STRING;
+        case 'number': {
+            // NaN and ±Infinity become null; String(-0) is already '0'.
+            if (!isFinite(value))
+                return NULL;
+            let out = '';
+            const digits = String(value);
+            for (let i = 0; i < digits.length; i++) {
+                out += NUMBERS[digits.charCodeAt(i)];
+            }
+            return out;
+        }
+        case 'boolean':
+            return value ? TRUE : FALSE;
+        case 'bigint':
+            throw new TypeError('Do not know how to serialize a BigInt');
+        case 'object': {
+            if (value === null)
+                return NULL;
+            const inner = nest(value, depth);
+            const out = Array.isArray(value)
+                ? encodeArray(value, inner)
+                : INDENT + encodeMembers(value, inner) + OUTDENT;
+            ancestors.pop();
+            return out;
         }
-        return out + characters_1.characters.document.arrayClose;
     }
-    return (characters_1.characters.document.indent +
-        encodeObject(value, inner) +
-        characters_1.characters.document.outdent);
+    return undefined;
 }
-const generate = (input) => {
-    const value = JSON.parse(input);
-    const body = value && typeof value === 'object' && !Array.isArray(value)
-        ? encodeObject(value, 0)
-        : encodeValue(value, 0);
-    return characters_1.characters.document.start + body + characters_1.characters.document.end;
+/**
+ * Write a value as an Emojion document, as `JSON.stringify()` writes JSON
+ * text, following the same rules:
+ *
+ * - It calls a value's `toJSON(key)` method, so a `Date` becomes its ISO
+ *   string.
+ * - It unwraps `new Number()`, `new String()` and `new Boolean()`.
+ * - It writes `NaN`, `Infinity` and `-Infinity` as `null`, and `-0` as `0`.
+ * - It skips `undefined`, functions and symbols in objects, and writes them
+ *   (and array holes) as `null` in arrays.
+ * - It writes only own enumerable string keys.
+ *
+ * @param value - The value to write.
+ * @returns The Emojion document, from `🙌` to `✋`.
+ * @throws {TypeError} For a BigInt (unless `BigInt.prototype.toJSON` is
+ * defined), for a circular structure, and for a value Emojion cannot hold at
+ * all: `undefined`, a function or a symbol on its own. (`JSON.stringify()`
+ * returns `undefined` for those; every Emojion document holds a value.)
+ * @throws {RangeError} If arrays and objects nest more than 512 levels deep.
+ *
+ * @example
+ * stringify({ created: 2019 });
+ * //=> '🙌😖😭😳😠😛😳🤤🕑🕛🕐🕘✋'
+ *
+ * @example
+ * stringify([1, undefined, new Date(0)]);
+ * //=> the same document as stringify([1, null, '1970-01-01T00:00:00.000Z'])
+ */
+const stringify = (value) => {
+    // A toJSON() method may call stringify() itself, so keep the outer stack.
+    const outer = ancestors;
+    ancestors = [];
+    try {
+        const resolved = resolve(value, '');
+        let body;
+        if (typeof resolved === 'object' &&
+            resolved !== null &&
+            !Array.isArray(resolved)) {
+            // A top-level object is written without 👉👈.
+            ancestors.push(resolved);
+            body = encodeMembers(resolved, 0);
+        }
+        else {
+            body = encodeValue(resolved, 0);
+        }
+        if (body === undefined) {
+            throw new TypeError(`Emojion cannot hold ${String(typeof resolved)}`);
+        }
+        return characters_1.characters.document.start + body + characters_1.characters.document.end;
+    }
+    finally {
+        ancestors = outer;
+    }
 };
-exports.generate = generate;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"generator.js","sourceRoot":"","sources":["../src/generator.ts"],"names":[],"mappings":";;;AAAA,6CAA0C;AAC1C,qCAAqC;AAIrC,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC;AACnD,MAAM,MAAM,GAAG,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC;AAErD,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,uBAAU,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;IACpE,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC;IACjC,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;QACpC,uBAAU,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,GAAG,KAAK,CAAC;AAChD,CAAC;AACD,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,uBAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;IACrE,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC;AACnC,CAAC;AACD,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,uBAAU,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC;IACtE,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC;IACnC,MAAM,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;QACtC,uBAAU,CAAC,MAAM,CAAC,SAAS,CAAC,SAAS,GAAG,KAAK,CAAC;AAClD,CAAC;AACD,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,uBAAU,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC;IACvE,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC;AACrC,CAAC;AAED,MAAM,WAAW,GAA2B,uBAAU,CAAC,IAAI,CAAC,OAAO,CAAC;AACpE,MAAM,aAAa,GAA2B,uBAAU,CAAC,MAAM,CAAC,OAAO,CAAC;AAExE,MAAM,OAAO,mCACR,uBAAU,CAAC,MAAM,CAAC,OAAO,KAC5B,GAAG,EAAE,uBAAU,CAAC,MAAM,CAAC,SAAS,CAAC,QAAQ,EACzC,GAAG,EAAE,EAAE,GACR,CAAC;AAEF,SAAS,MAAM,CACb,IAAY,EACZ,KAAe,EACf,OAAe,EACf,OAA+B;IAE/B,IAAI,GAAG,GAAG,EAAE,CAAC;IACb,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACrC,MAAM,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;QACxC,IAAI,KAAK,EAAE,CAAC;YACV,GAAG,IAAI,KAAK,CAAC;YACb,SAAS;QACX,CAAC;QACD,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC,CAAE,CAAC;QACnC,IAAI,KAAK,GAAG,MAAM;YAAE,CAAC,EAAE,CAAC;QACxB,GAAG,IAAI,OAAO,CAAC;QACf,KAAK,MAAM,GAAG,IAAI,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC;YAAE,GAAG,IAAI,OAAO,CAAC,GAAG,CAAC,CAAC;IAC5D,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,SAAS,IAAI,CAAC,KAAa;IACzB,IAAI,KAAK,IAAI,kBAAS,EAAE,CAAC;QACvB,MAAM,IAAI,UAAU,CAClB,wBAAwB,kBAAS,oCAAoC,CACtE,CAAC;IACJ,CAAC;IACD,OAAO,KAAK,GAAG,CAAC,CAAC;AACnB,CAAC;AAED,SAAS,YAAY,CAAC,MAA+B,EAAE,KAAa;IAClE,IAAI,GAAG,GAAG,EAAE,CAAC;IACb,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;QACtC,GAAG,IAAI,GAAG;YACR,CAAC,CAAC,MAAM,CAAC,GAAG,EAAE,IAAI,EAAE,uBAAU,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,WAAW,CAAC;YACnE,CAAC,CAAC,uBAAU,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC;QAChC,GAAG,IAAI,WAAW,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,KAAK,CAAC,CAAC;IACzC,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,SAAS,WAAW,CAAC,KAAW,EAAE,KAAa;IAC7C,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,OAAO,KAAK;YACV,CAAC,CAAC,MAAM,CACJ,KAAK,EACL,MAAM,EACN,uBAAU,CAAC,MAAM,CAAC,SAAS,CAAC,OAAO,EACnC,aAAa,CACd;YACH,CAAC,CAAC,uBAAU,CAAC,MAAM,CAAC,KAAK,CAAC,WAAW,CAAC;IAC1C,CAAC;IACD,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,IAAI,GAAG,GAAG,EAAE,CAAC;QACb,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,KAAK,CAAC;YAAE,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;QACvD,OAAO,GAAG,CAAC;IACb,CAAC;IACD,IAAI,OAAO,KAAK,KAAK,SAAS,EAAE,CAAC;QAC/B,OAAO,KAAK;YACV,CAAC,CAAC,uBAAU,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI;YACjC,CAAC,CAAC,uBAAU,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC;IACvC,CAAC;IACD,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,uBAAU,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC;IACxD,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC;IAC1B,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACzB,IAAI,GAAG,GAAG,uBAAU,CAAC,QAAQ,CAAC,SAAS,CAAC;QACxC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACtC,IAAI,CAAC;gBAAE,GAAG,IAAI,uBAAU,CAAC,QAAQ,CAAC,YAAY,CAAC;YAC/C,GAAG,IAAI,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;QACtC,CAAC;QACD,OAAO,GAAG,GAAG,uBAAU,CAAC,QAAQ,CAAC,UAAU,CAAC;IAC9C,CAAC;IACD,OAAO,CACL,uBAAU,CAAC,QAAQ,CAAC,MAAM;QAC1B,YAAY,CAAC,KAAK,EAAE,KAAK,CAAC;QAC1B,uBAAU,CAAC,QAAQ,CAAC,OAAO,CAC5B,CAAC;AACJ,CAAC;AASM,MAAM,QAAQ,GAAG,CAAC,KAAa,EAAU,EAAE;IAChD,MAAM,KAAK,GAAS,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IACtC,MAAM,IAAI,GACR,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QACzD,CAAC,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC,CAAC;QACxB,CAAC,CAAC,WAAW,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;IAC5B,OAAO,uBAAU,CAAC,QAAQ,CAAC,KAAK,GAAG,IAAI,GAAG,uBAAU,CAAC,QAAQ,CAAC,GAAG,CAAC;AACpE,CAAC,CAAC;AAPW,QAAA,QAAQ,YAOnB","sourcesContent":["import { characters } from './characters';\nimport { MAX_DEPTH } from './limits';\n\ntype Json = string | number | boolean | null | Json[] | { [key: string]: Json };\n\nconst KEYS = Array.from({ length: 128 }, () => '');\nconst VALUES = Array.from({ length: 128 }, () => '');\n\nfor (const [char, emoji] of Object.entries(characters.keys.letters)) {\n  KEYS[char.charCodeAt(0)] = emoji;\n  KEYS[char.toUpperCase().charCodeAt(0)] =\n    characters.keys.modifiers.upperCase + emoji;\n}\nfor (const [char, emoji] of Object.entries(characters.keys.numerals)) {\n  KEYS[char.charCodeAt(0)] = emoji;\n}\nfor (const [char, emoji] of Object.entries(characters.values.letters)) {\n  VALUES[char.charCodeAt(0)] = emoji;\n  VALUES[char.toUpperCase().charCodeAt(0)] =\n    characters.values.modifiers.upperCase + emoji;\n}\nfor (const [char, emoji] of Object.entries(characters.values.numerals)) {\n  VALUES[char.charCodeAt(0)] = emoji;\n}\n\nconst KEY_NIBBLES: Record<string, string> = characters.keys.unicode;\nconst VALUE_NIBBLES: Record<string, string> = characters.values.unicode;\n\nconst NUMBERS: Record<string, string> = {\n  ...characters.values.numbers,\n  '-': characters.values.modifiers.negative,\n  '+': '',\n};\n\nfunction encode(\n  text: string,\n  table: string[],\n  unicode: string,\n  nibbles: Record<string, string>\n): string {\n  let out = '';\n  for (let i = 0; i < text.length; i++) {\n    const emoji = table[text.charCodeAt(i)];\n    if (emoji) {\n      out += emoji;\n      continue;\n    }\n    const point = text.codePointAt(i)!;\n    if (point > 0xffff) i++;\n    out += unicode;\n    for (const hex of point.toString(16)) out += nibbles[hex];\n  }\n  return out;\n}\n\nfunction nest(depth: number): number {\n  if (depth >= MAX_DEPTH) {\n    throw new RangeError(\n      `JSON nesting exceeds ${MAX_DEPTH} levels, the most Emojion supports`\n    );\n  }\n  return depth + 1;\n}\n\nfunction encodeObject(object: { [key: string]: Json }, depth: number): string {\n  let out = '';\n  for (const key of Object.keys(object)) {\n    out += key\n      ? encode(key, KEYS, characters.keys.modifiers.unicode, KEY_NIBBLES)\n      : characters.keys.other.empty;\n    out += encodeValue(object[key], depth);\n  }\n  return out;\n}\n\nfunction encodeValue(value: Json, depth: number): string {\n  if (typeof value === 'string') {\n    return value\n      ? encode(\n          value,\n          VALUES,\n          characters.values.modifiers.unicode,\n          VALUE_NIBBLES\n        )\n      : characters.values.other.emptyString;\n  }\n  if (typeof value === 'number') {\n    let out = '';\n    for (const char of String(value)) out += NUMBERS[char];\n    return out;\n  }\n  if (typeof value === 'boolean') {\n    return value\n      ? characters.values.booleans.true\n      : characters.values.booleans.false;\n  }\n  if (value === null) return characters.values.other.null;\n  const inner = nest(depth);\n  if (Array.isArray(value)) {\n    let out = characters.document.arrayOpen;\n    for (let i = 0; i < value.length; i++) {\n      if (i) out += characters.document.arrayDelimit;\n      out += encodeValue(value[i], inner);\n    }\n    return out + characters.document.arrayClose;\n  }\n  return (\n    characters.document.indent +\n    encodeObject(value, inner) +\n    characters.document.outdent\n  );\n}\n\n/**\n * Convert JSON text into an Emojion document.\n *\n * @example\n * generate('{\"created\":2019}');\n * //=> '🙌😖😭😳😠😛😳🤤🕑🕛🕐🕘✋'\n */\nexport const generate = (input: string): string => {\n  const value: Json = JSON.parse(input);\n  const body =\n    value && typeof value === 'object' && !Array.isArray(value)\n      ? encodeObject(value, 0)\n      : encodeValue(value, 0);\n  return characters.document.start + body + characters.document.end;\n};\n"]}
+exports.stringify = stringify;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"generator.js","sourceRoot":"","sources":["../src/generator.ts"],"names":[],"mappings":"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","sourcesContent":["import { characters } from './characters';\nimport { MAX_DEPTH } from './limits';\n\n/**\n * How to write text as either keys or values. `ascii` holds the emoji for\n * every ASCII character, including the escape sequence for those without\n * their own emoji, so ASCII text never takes the slower escape path.\n * `pairs` caches two ASCII characters at once; it is filled in as pairs are\n * first seen and holds at most 128 × 128 entries.\n */\ninterface Alphabet {\n  ascii: string[];\n  pairs: string[];\n  unicode: string;\n  nibbles: string[];\n}\n\nfunction makeAlphabet(\n  letters: Record<string, string>,\n  numerals: Record<string, string>,\n  modifiers: { upperCase: string; unicode: string },\n  hex: Record<string, string>\n): Alphabet {\n  const result: Alphabet = {\n    ascii: [],\n    pairs: new Array(128 * 128),\n    unicode: modifiers.unicode,\n    nibbles: Array.from({ length: 16 }, (_, i) => hex[i.toString(16)]),\n  };\n  for (let c = 0; c < 128; c++) result.ascii[c] = escapeSequence(c, result);\n  for (const [char, emoji] of Object.entries(letters)) {\n    result.ascii[char.charCodeAt(0)] = emoji;\n    result.ascii[char.toUpperCase().charCodeAt(0)] =\n      modifiers.upperCase + emoji;\n  }\n  for (const [char, emoji] of Object.entries(numerals)) {\n    result.ascii[char.charCodeAt(0)] = emoji;\n  }\n  return result;\n}\n\nconst KEYS = makeAlphabet(\n  characters.keys.letters,\n  characters.keys.numerals,\n  characters.keys.modifiers,\n  characters.keys.unicode\n);\nconst VALUES = makeAlphabet(\n  characters.values.letters,\n  characters.values.numerals,\n  characters.values.modifiers,\n  characters.values.unicode\n);\n\n// Indexed by the char codes of String(number).\nconst NUMBERS: string[] = [];\nfor (const [char, emoji] of Object.entries({\n  ...characters.values.numbers,\n  '-': characters.values.modifiers.negative,\n  '+': '',\n})) {\n  NUMBERS[char.charCodeAt(0)] = emoji;\n}\n\n/** The escape for a code point: the unicode modifier, then its hex digits. */\nfunction escapeSequence(point: number, alphabet: Alphabet): string {\n  let shift = 20;\n  while (shift > 0 && point >> shift === 0) shift -= 4;\n  let out = alphabet.unicode;\n  for (; shift >= 0; shift -= 4) out += alphabet.nibbles[(point >> shift) & 15];\n  return out;\n}\n\nfunction encode(text: string, alphabet: Alphabet): string {\n  const { ascii, pairs } = alphabet;\n  let out = '';\n  let i = 0;\n  while (i < text.length) {\n    const c = text.charCodeAt(i);\n    if (c < 128) {\n      const d = i + 1 < text.length ? text.charCodeAt(i + 1) : 128;\n      if (d < 128) {\n        const pair = (c << 7) | d;\n        let emoji = pairs[pair];\n        if (emoji === undefined) emoji = pairs[pair] = ascii[c] + ascii[d];\n        out += emoji;\n        i += 2;\n      } else {\n        out += ascii[c];\n        i++;\n      }\n      continue;\n    }\n    const point = text.codePointAt(i)!;\n    i += point > 0xffff ? 2 : 1;\n    out += escapeSequence(point, alphabet);\n  }\n  return out;\n}\n\nconst NULL = characters.values.other.null;\nconst TRUE = characters.values.booleans.true;\nconst FALSE = characters.values.booleans.false;\nconst EMPTY_STRING = characters.values.other.emptyString;\nconst EMPTY_KEY = characters.keys.other.empty;\nconst INDENT = characters.document.indent;\nconst OUTDENT = characters.document.outdent;\nconst OPEN = characters.document.arrayOpen;\nconst CLOSE = characters.document.arrayClose;\nconst DELIMIT = characters.document.arrayDelimit;\n\ntype Holder = { [key: string]: unknown };\n\n// The objects being written, outermost first, to catch circular structures.\nlet ancestors: object[] = [];\n\nconst toTag = Object.prototype.toString;\n\nfunction nest(value: object, depth: number): number {\n  if (ancestors.indexOf(value) !== -1) {\n    throw new TypeError('Converting circular structure to Emojion');\n  }\n  if (depth >= MAX_DEPTH) {\n    throw new RangeError(\n      `Value nesting exceeds ${MAX_DEPTH} levels, the most Emojion supports`\n    );\n  }\n  ancestors.push(value);\n  return depth + 1;\n}\n\nfunction is(check: () => unknown): boolean {\n  try {\n    check();\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Turn a boxed primitive back into its primitive, as JSON.stringify() does.\n * The tag check is cheap; the valueOf() brand check confirms it.\n */\nfunction unbox(value: object): unknown {\n  switch (toTag.call(value)) {\n    case '[object Number]':\n      return is(() => Number.prototype.valueOf.call(value))\n        ? Number(value)\n        : value;\n    case '[object String]':\n      return is(() => String.prototype.valueOf.call(value))\n        ? String(value)\n        : value;\n    case '[object Boolean]':\n      return is(() => Boolean.prototype.valueOf.call(value))\n        ? Boolean.prototype.valueOf.call(value)\n        : value;\n    case '[object BigInt]':\n      return typeof BigInt === 'function' &&\n        is(() => BigInt.prototype.valueOf.call(value))\n        ? BigInt.prototype.valueOf.call(value)\n        : value;\n  }\n  return value;\n}\n\n/**\n * Apply toJSON() and unwrap boxed primitives, the steps JSON.stringify()\n * takes before it looks at a value's type.\n */\nfunction resolve(value: unknown, key: string | number): unknown {\n  if (typeof value === 'object') {\n    if (value === null) return value;\n    const toJSON = (value as { toJSON?: unknown }).toJSON;\n    if (typeof toJSON === 'function') {\n      value = toJSON.call(value, String(key));\n      if (typeof value !== 'object' || value === null) return value;\n    }\n    if (Array.isArray(value)) return value;\n    const proto = Object.getPrototypeOf(value);\n    return proto === Object.prototype || proto === null\n      ? value\n      : unbox(value as object);\n  }\n  if (typeof value === 'bigint') {\n    const toJSON = (value as unknown as { toJSON?: unknown }).toJSON;\n    if (typeof toJSON === 'function') return toJSON.call(value, String(key));\n  }\n  return value;\n}\n\nfunction encodeMembers(object: Holder, depth: number): string {\n  let out = '';\n  const keys = Object.keys(object);\n  for (let i = 0; i < keys.length; i++) {\n    const key = keys[i];\n    const value = encodeValue(resolve(object[key], key), depth);\n    if (value === undefined) continue;\n    out += key ? encode(key, KEYS) : EMPTY_KEY;\n    out += value;\n  }\n  return out;\n}\n\nfunction encodeArray(array: unknown[], depth: number): string {\n  let out = OPEN;\n  for (let i = 0; i < array.length; i++) {\n    if (i) out += DELIMIT;\n    const value = encodeValue(resolve(array[i], i), depth);\n    out += value === undefined ? NULL : value;\n  }\n  return out + CLOSE;\n}\n\n/**\n * Write a resolved value. Returns undefined for the values JSON.stringify()\n * skips: undefined, functions and symbols.\n */\nfunction encodeValue(value: unknown, depth: number): string | undefined {\n  switch (typeof value) {\n    case 'string':\n      return value ? encode(value, VALUES) : EMPTY_STRING;\n    case 'number': {\n      // NaN and ±Infinity become null; String(-0) is already '0'.\n      if (!isFinite(value)) return NULL;\n      let out = '';\n      const digits = String(value);\n      for (let i = 0; i < digits.length; i++) {\n        out += NUMBERS[digits.charCodeAt(i)];\n      }\n      return out;\n    }\n    case 'boolean':\n      return value ? TRUE : FALSE;\n    case 'bigint':\n      throw new TypeError('Do not know how to serialize a BigInt');\n    case 'object': {\n      if (value === null) return NULL;\n      const inner = nest(value, depth);\n      const out = Array.isArray(value)\n        ? encodeArray(value, inner)\n        : INDENT + encodeMembers(value as Holder, inner) + OUTDENT;\n      ancestors.pop();\n      return out;\n    }\n  }\n  return undefined;\n}\n\n/**\n * Write a value as an Emojion document, as `JSON.stringify()` writes JSON\n * text, following the same rules:\n *\n * - It calls a value's `toJSON(key)` method, so a `Date` becomes its ISO\n *   string.\n * - It unwraps `new Number()`, `new String()` and `new Boolean()`.\n * - It writes `NaN`, `Infinity` and `-Infinity` as `null`, and `-0` as `0`.\n * - It skips `undefined`, functions and symbols in objects, and writes them\n *   (and array holes) as `null` in arrays.\n * - It writes only own enumerable string keys.\n *\n * @param value - The value to write.\n * @returns The Emojion document, from `🙌` to `✋`.\n * @throws {TypeError} For a BigInt (unless `BigInt.prototype.toJSON` is\n * defined), for a circular structure, and for a value Emojion cannot hold at\n * all: `undefined`, a function or a symbol on its own. (`JSON.stringify()`\n * returns `undefined` for those; every Emojion document holds a value.)\n * @throws {RangeError} If arrays and objects nest more than 512 levels deep.\n *\n * @example\n * stringify({ created: 2019 });\n * //=> '🙌😖😭😳😠😛😳🤤🕑🕛🕐🕘✋'\n *\n * @example\n * stringify([1, undefined, new Date(0)]);\n * //=> the same document as stringify([1, null, '1970-01-01T00:00:00.000Z'])\n */\nexport const stringify = (value: unknown): string => {\n  // A toJSON() method may call stringify() itself, so keep the outer stack.\n  const outer = ancestors;\n  ancestors = [];\n  try {\n    const resolved = resolve(value, '');\n    let body: string | undefined;\n    if (\n      typeof resolved === 'object' &&\n      resolved !== null &&\n      !Array.isArray(resolved)\n    ) {\n      // A top-level object is written without 👉👈.\n      ancestors.push(resolved);\n      body = encodeMembers(resolved as Holder, 0);\n    } else {\n      body = encodeValue(resolved, 0);\n    }\n    if (body === undefined) {\n      throw new TypeError(`Emojion cannot hold ${String(typeof resolved)}`);\n    }\n    return characters.document.start + body + characters.document.end;\n  } finally {\n    ancestors = outer;\n  }\n};\n"]}

package/lib/index.d.ts

@@ -1,2 +1,3 @@
 export { parse } from './parser';
-export { generate } from './generator';
+export { stringify } from './generator';
+export type { Json } from './json';

package/lib/index.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generate = exports.parse = void 0;
+exports.stringify = exports.parse = void 0;
 var parser_1 = require("./parser");
 Object.defineProperty(exports, "parse", { enumerable: true, get: function () { return parser_1.parse; } });
 var generator_1 = require("./generator");
-Object.defineProperty(exports, "generate", { enumerable: true, get: function () { return generator_1.generate; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsbUNBQWlDO0FBQXhCLCtGQUFBLEtBQUssT0FBQTtBQUNkLHlDQUF1QztBQUE5QixxR0FBQSxRQUFRLE9BQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBwYXJzZSB9IGZyb20gJy4vcGFyc2VyJztcbmV4cG9ydCB7IGdlbmVyYXRlIH0gZnJvbSAnLi9nZW5lcmF0b3InO1xuIl19
+Object.defineProperty(exports, "stringify", { enumerable: true, get: function () { return generator_1.stringify; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsbUNBQWlDO0FBQXhCLCtGQUFBLEtBQUssT0FBQTtBQUNkLHlDQUF3QztBQUEvQixzR0FBQSxTQUFTLE9BQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBwYXJzZSB9IGZyb20gJy4vcGFyc2VyJztcbmV4cG9ydCB7IHN0cmluZ2lmeSB9IGZyb20gJy4vZ2VuZXJhdG9yJztcbmV4cG9ydCB0eXBlIHsgSnNvbiB9IGZyb20gJy4vanNvbic7XG4iXX0=

package/lib/json.d.ts

@@ -0,0 +1,13 @@
+/**
+ * A value that Emojion can hold: the same values JSON can hold. `parse()`
+ * returns one.
+ *
+ * @example
+ * import { parse } from 'emj';
+ * import type { Json } from 'emj';
+ *
+ * const value: Json = parse('🙌😠🕐✋'); // { a: 1 }
+ */
+export type Json = string | number | boolean | null | Json[] | {
+    [key: string]: Json;
+};

package/lib/json.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoianNvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9qc29uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEEgdmFsdWUgdGhhdCBFbW9qaW9uIGNhbiBob2xkOiB0aGUgc2FtZSB2YWx1ZXMgSlNPTiBjYW4gaG9sZC4gYHBhcnNlKClgXG4gKiByZXR1cm5zIG9uZS5cbiAqXG4gKiBAZXhhbXBsZVxuICogaW1wb3J0IHsgcGFyc2UgfSBmcm9tICdlbWonO1xuICogaW1wb3J0IHR5cGUgeyBKc29uIH0gZnJvbSAnZW1qJztcbiAqXG4gKiBjb25zdCB2YWx1ZTogSnNvbiA9IHBhcnNlKCfwn5mM8J+YoPCflZDinIsnKTsgLy8geyBhOiAxIH1cbiAqL1xuZXhwb3J0IHR5cGUgSnNvbiA9XG4gIHN0cmluZyB8IG51bWJlciB8IGJvb2xlYW4gfCBudWxsIHwgSnNvbltdIHwgeyBba2V5OiBzdHJpbmddOiBKc29uIH07XG4iXX0=

package/lib/limits.d.ts

@@ -1 +1,6 @@
+/**
+ * The deepest an array or object may be nested. Both `parse()` and
+ * `stringify()` enforce it, so anything one produces the other accepts.
+ * It keeps very deep input from overflowing the call stack.
+ */
 export declare const MAX_DEPTH = 512;

package/lib/limits.js

@@ -1,5 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MAX_DEPTH = void 0;
+/**
+ * The deepest an array or object may be nested. Both `parse()` and
+ * `stringify()` enforce it, so anything one produces the other accepts.
+ * It keeps very deep input from overflowing the call stack.
+ */
 exports.MAX_DEPTH = 512;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGltaXRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2xpbWl0cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFLYSxRQUFBLFNBQVMsR0FBRyxHQUFHLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFRoZSBkZWVwZXN0IGFuIGFycmF5IG9yIG9iamVjdCBtYXkgYmUgbmVzdGVkLiBCb3RoIGBwYXJzZSgpYCBhbmRcbiAqIGBnZW5lcmF0ZSgpYCBlbmZvcmNlIGl0LCBzbyBhbnl0aGluZyBvbmUgcHJvZHVjZXMgdGhlIG90aGVyIGFjY2VwdHMuXG4gKiBJdCBrZWVwcyB2ZXJ5IGRlZXAgaW5wdXQgZnJvbSBvdmVyZmxvd2luZyB0aGUgY2FsbCBzdGFjay5cbiAqL1xuZXhwb3J0IGNvbnN0IE1BWF9ERVBUSCA9IDUxMjtcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGltaXRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2xpbWl0cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQTs7OztHQUlHO0FBQ1UsUUFBQSxTQUFTLEdBQUcsR0FBRyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBUaGUgZGVlcGVzdCBhbiBhcnJheSBvciBvYmplY3QgbWF5IGJlIG5lc3RlZC4gQm90aCBgcGFyc2UoKWAgYW5kXG4gKiBgc3RyaW5naWZ5KClgIGVuZm9yY2UgaXQsIHNvIGFueXRoaW5nIG9uZSBwcm9kdWNlcyB0aGUgb3RoZXIgYWNjZXB0cy5cbiAqIEl0IGtlZXBzIHZlcnkgZGVlcCBpbnB1dCBmcm9tIG92ZXJmbG93aW5nIHRoZSBjYWxsIHN0YWNrLlxuICovXG5leHBvcnQgY29uc3QgTUFYX0RFUFRIID0gNTEyO1xuIl19

package/lib/parser.d.ts

@@ -1 +1,26 @@
-export declare const parse: (input: string) => string;
+import type { Json } from './json';
+/**
+ * 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]
+ */
+export declare const parse: (emojion: string) => Json;

package/lib/parser.js

@@ -32,9 +32,33 @@ const Kind = {
     False: 25,
     Null: 26,
 };
-const TOKENS = new Map();
+// 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) => {
-    TOKENS.set(emoji.codePointAt(0), kind | (code << 8));
+    setToken(emoji.codePointAt(0), kind | (code << 8));
 };
 define(characters_1.characters.document.start, Kind.Start);
 define(characters_1.characters.document.end, Kind.End);
@@ -75,13 +99,15 @@ for (const [char, emoji] of Object.entries(characters_1.characters.values.number
     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,
 ]) {
-    TOKENS.set(space, Kind.Space);
+    setToken(space, Kind.Space);
 }
+const OBJECT_PROTOTYPE = Object.prototype;
 let source = '';
 let index = 0;
 let at = 0;
@@ -90,12 +116,11 @@ let kind = Kind.EOF;
 let code = 0;
 let depth = 0;
 function next() {
-    var _a;
     while (index < source.length) {
         at = index;
         point = source.codePointAt(index);
         index += point > 0xffff ? 2 : 1;
-        const token = (_a = TOKENS.get(point)) !== null && _a !== void 0 ? _a : Kind.Invalid;
+        const token = lookup(point);
         if (token === Kind.Space)
             continue;
         kind = token & 0xff;
@@ -124,7 +149,6 @@ function expect(expected) {
 }
 function text(char, upper, unicode, nibble) {
     let out = '';
-    let encoded = false;
     for (;;) {
         if (kind === char) {
             out += String.fromCharCode(code);
@@ -141,6 +165,7 @@ function text(char, upper, unicode, nibble) {
             next();
             if (kind !== nibble)
                 fail();
+            // U+10FFFF, the highest code point, needs six nibbles.
             let value = 0;
             let nibbles = 0;
             do {
@@ -152,10 +177,9 @@ function text(char, upper, unicode, nibble) {
                 next();
             } while (kind === nibble);
             out += String.fromCodePoint(value);
-            encoded = true;
         }
         else {
-            return encoded ? JSON.stringify(out) : '"' + out + '"';
+            return out;
         }
     }
 }
@@ -194,45 +218,59 @@ function number() {
             next();
         }
         else {
-            out += 'e+';
+            out += 'e';
         }
         out += digits();
     }
-    return out;
+    return Number(out);
 }
 function members(close) {
-    let out = '{';
+    const out = {};
     while (kind !== close) {
-        if (out !== '{')
-            out += ',';
+        let key = '';
         if (kind === Kind.KeyEmpty) {
-            out += '""';
             next();
         }
         else if (kind === Kind.KeyChar ||
             kind === Kind.KeyUpper ||
             kind === Kind.KeyUnicode) {
-            out += text(Kind.KeyChar, Kind.KeyUpper, Kind.KeyUnicode, Kind.KeyNibble);
+            key = text(Kind.KeyChar, Kind.KeyUpper, Kind.KeyUnicode, Kind.KeyNibble);
         }
         else {
             fail();
         }
-        out += ':' + value();
+        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 + '}';
+    return out;
 }
 function array() {
+    const out = [];
     if (next() === Kind.Close) {
         next();
-        return '[]';
+        return out;
     }
-    let out = '[' + value();
+    out.push(value());
     while (kind === Kind.Delimit) {
         next();
-        out += ',' + value();
+        out.push(value());
     }
     expect(Kind.Close);
-    return out + ']';
+    return out;
 }
 function value() {
     switch (kind) {
@@ -252,16 +290,16 @@ function value() {
         }
         case Kind.True:
             next();
-            return 'true';
+            return true;
         case Kind.False:
             next();
-            return 'false';
+            return false;
         case Kind.Null:
             next();
-            return 'null';
+            return null;
         case Kind.ValueEmpty:
             next();
-            return '""';
+            return '';
         case Kind.Negative:
         case Kind.Digit:
             return number();
@@ -272,13 +310,38 @@ function value() {
     }
     return fail();
 }
-const parse = (input) => {
-    source = input;
+/**
+ * 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 ||
@@ -298,4 +361,4 @@ const parse = (input) => {
     }
 };
 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 { 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\nconst TOKENS = new Map<number, number>();\n\nconst define = (emoji: string, kind: number, code = 0) => {\n  TOKENS.set(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  TOKENS.set(space, Kind.Space);\n}\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 = TOKENS.get(point) ?? Kind.Invalid;\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  let encoded = false;\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      encoded = true;\n    } else {\n      return encoded ? JSON.stringify(out) : '\"' + 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(): string {\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 out;\n}\n\nfunction members(close: number): string {\n  let out = '{';\n  while (kind !== close) {\n    if (out !== '{') out += ',';\n    if (kind === Kind.KeyEmpty) {\n      out += '\"\"';\n      next();\n    } else if (\n      kind === Kind.KeyChar ||\n      kind === Kind.KeyUpper ||\n      kind === Kind.KeyUnicode\n    ) {\n      out += text(Kind.KeyChar, Kind.KeyUpper, Kind.KeyUnicode, Kind.KeyNibble);\n    } else {\n      fail();\n    }\n    out += ':' + value();\n  }\n  return out + '}';\n}\n\nfunction array(): string {\n  if (next() === Kind.Close) {\n    next();\n    return '[]';\n  }\n  let out = '[' + value();\n  while (kind === Kind.Delimit) {\n    next();\n    out += ',' + value();\n  }\n  expect(Kind.Close);\n  return out + ']';\n}\n\nfunction value(): string {\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 * Convert an Emojion document into JSON text.\n * Throws a `SyntaxError` if the document is not valid Emojion.\n *\n * @example\n * parse('🙌😶😠🤑😳👡🐘🐁🦉🦒🐖🦉🦏✋');\n * //=> '{\"name\":\"Emojion\"}'\n */\nexport const parse = (input: string): string => {\n  source = input;\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"]}
+//# 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.1.0",
+  "version": "0.2.0",
   "description": "Emoji Object Notation",
   "license": "MIT",
   "repository": {
@@ -37,7 +37,8 @@
     "rollup": "rollup --config rollup.config.mjs",
     "watch": "npm run build -- --watch",
     "watch:test": "vitest",
-    "bench": "npm run build:lib && node --expose-gc bench/index.mjs"
+    "bench": "npm run build:lib && node --expose-gc bench/index.mjs",
+    "bench:ab": "node bench/ab.mjs"
   },
   "devDependencies": {
     "@emnapi/core": "^1.11.3",