emj 0.0.11 → 0.2.0

package/lib/generator.js

@@ -0,0 +1,270 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringify = void 0;
+const characters_1 = require("./characters");
+const limits_1 = require("./limits");
+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;
+}
+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;
+}
+/** 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;
+}
+function encode(text, alphabet) {
+    const { ascii, pairs } = alphabet;
+    let out = '';
+    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);
+        i += point > 0xffff ? 2 : 1;
+        out += escapeSequence(point, alphabet);
+    }
+    return out;
+}
+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(`Value nesting exceeds ${limits_1.MAX_DEPTH} levels, the most Emojion supports`);
+    }
+    ancestors.push(value);
+    return depth + 1;
+}
+function is(check) {
+    try {
+        check();
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+/**
+ * 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));
+    }
+    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;
+    }
+    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;
+    }
+    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 undefined;
+}
+/**
+ * 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.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

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

package/lib/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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, "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

@@ -0,0 +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

@@ -0,0 +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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGltaXRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2xpbWl0cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQTs7OztHQUlHO0FBQ1UsUUFBQSxTQUFTLEdBQUcsR0FBRyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBUaGUgZGVlcGVzdCBhbiBhcnJheSBvciBvYmplY3QgbWF5IGJlIG5lc3RlZC4gQm90aCBgcGFyc2UoKWAgYW5kXG4gKiBgc3RyaW5naWZ5KClgIGVuZm9yY2UgaXQsIHNvIGFueXRoaW5nIG9uZSBwcm9kdWNlcyB0aGUgb3RoZXIgYWNjZXB0cy5cbiAqIEl0IGtlZXBzIHZlcnkgZGVlcCBpbnB1dCBmcm9tIG92ZXJmbG93aW5nIHRoZSBjYWxsIHN0YWNrLlxuICovXG5leHBvcnQgY29uc3QgTUFYX0RFUFRIID0gNTEyO1xuIl19

package/lib/parser.d.ts

@@ -0,0 +1,26 @@
+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;