flatted

Index: package/esm/index.js
===================================================================
--- package/esm/index.js
+++ package/esm/index.js
@@ -1,6 +1,8 @@
-/*! (c) 2020 Andrea Giammarchi */
+/// <reference types="../types/index.d.ts" />
 
+// (c) 2020-present Andrea Giammarchi
+
 const {parse: $parse, stringify: $stringify} = JSON;
 const {keys} = Object;
 
 const Primitive = String;   // it could be Number
@@ -18,30 +20,25 @@
 const Primitives = (_, value) => (
   typeof value === primitive ? new Primitive(value) : value
 );
 
-const revive = (input, parsed, output, $) => {
-  const lazy = [];
+const resolver = (input, lazy, parsed, $) => output => {
   for (let ke = keys(output), {length} = ke, y = 0; y < length; y++) {
     const k = ke[y];
     const value = output[k];
     if (value instanceof Primitive) {
-      const tmp = input[value];
+      const tmp = input[+value];
       if (typeof tmp === object && !parsed.has(tmp)) {
         parsed.add(tmp);
         output[k] = ignore;
-        lazy.push({k, a: [input, parsed, tmp, $]});
+        lazy.push({ o: output, k, r: tmp });
       }
       else
         output[k] = $.call(output, k, tmp);
     }
     else if (output[k] !== ignore)
       output[k] = $.call(output, k, value);
   }
-  for (let {length} = lazy, i = 0; i < length; i++) {
-    const {k, a} = lazy[i];
-    output[k] = $.call(output, k, revive.apply(null, a));
-  }
   return output;
 };
 
 const set = (known, input, value) => {
@@ -49,18 +46,43 @@
   known.set(value, index);
   return index;
 };
 
+/**
+ * Converts a specialized flatted string into a JS value.
+ * @param {string} text
+ * @param {(this: any, key: string, value: any) => any} [reviver]
+ * @returns {any}
+ */
 export const parse = (text, reviver) => {
   const input = $parse(text, Primitives).map(primitives);
-  const value = input[0];
   const $ = reviver || noop;
-  const tmp = typeof value === object && value ?
-              revive(input, new Set, value, $) :
-              value;
-  return $.call({'': tmp}, '', tmp);
+
+  let value = input[0];
+
+  if (typeof value === object && value) {
+    const lazy = [];
+    const revive = resolver(input, lazy, new Set, $);
+    value = revive(value);
+
+    let i = 0;
+    while (i < lazy.length) {
+      // it could be a lazy.shift() but that's costly
+      const {o, k, r} = lazy[i++];
+      o[k] = $.call(o, k, revive(r));
+    }
+  }
+
+  return $.call({'': value}, '', value);
 };
 
+/**
+ * Converts a JS value into a specialized flatted string.
+ * @param {any} value
+ * @param {((this: any, key: string, value: any) => any) | (string | number)[] | null | undefined} [replacer]
+ * @param {string | number | undefined} [space]
+ * @returns {string}
+ */
 export const stringify = (value, replacer, space) => {
   const $ = replacer && typeof replacer === object ?
             (k, v) => (k === '' || -1 < replacer.indexOf(k) ? v : void 0) :
             (replacer || noop);
@@ -89,6 +111,17 @@
     return after;
   }
 };
 
-export const toJSON = any => $parse(stringify(any));
-export const fromJSON = any => parse($stringify(any));
+/**
+ * Converts a generic value into a JSON serializable object without losing recursion.
+ * @param {any} value
+ * @returns {any}
+ */
+export const toJSON = value => $parse(stringify(value));
+
+/**
+ * Converts a previously serialized object with recursion into a recursive one.
+ * @param {any} value
+ * @returns {any}
+ */
+export const fromJSON = value => parse($stringify(value));