seroval 0.4.0-alpha.10 → 0.4.0-alpha.11

package/dist/cjs/development/index.cjs

@@ -31,28 +31,6 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/checks.ts
-function isPrimitive(current) {
-  if (!current || current === true) {
-    return true;
-  }
-  const type = typeof current;
-  return type === "number" || type === "string";
-}
-function isPromise(obj) {
-  return !!obj && (typeof obj === "object" || typeof obj === "function") && "then" in obj && typeof obj.then === "function";
-}
-function isIterableBuiltin(obj) {
-  if (!!obj && typeof obj === "object") {
-    const cons = obj.constructor;
-    return Array.isArray(obj) || cons === Set || cons === Map;
-  }
-  return false;
-}
-function isIterable(obj) {
-  return !!obj && typeof obj === "object" && !isIterableBuiltin(obj) && Symbol.iterator in obj && typeof obj[Symbol.iterator] === "function";
-}
-
 // src/compat.ts
 function compareVersion(left, right) {
   let diff = left[0] - right[0];
@@ -399,6 +377,120 @@ function quote(str) {
   return `"${result}"`;
 }
 
+// src/tree/primitives.ts
+function createPrimitiveNode(value) {
+  return {
+    t: 0 /* Primitive */,
+    i: void 0,
+    s: value,
+    l: void 0,
+    m: void 0,
+    c: void 0,
+    d: void 0,
+    a: void 0,
+    n: void 0
+  };
+}
+var TRUE_NODE = createPrimitiveNode("!0");
+var FALSE_NODE = createPrimitiveNode("!1");
+var UNDEFINED_NODE = createPrimitiveNode("void 0");
+var NULL_NODE = createPrimitiveNode(null);
+var NEG_ZERO_NODE = createPrimitiveNode("-0");
+var INFINITY_NODE = createPrimitiveNode("1/0");
+var NEG_INFINITY_NODE = createPrimitiveNode("-1/0");
+function createBigIntNode(ctx, current) {
+  assert(ctx.features & 8 /* BigInt */, 'Unsupported type "BigInt"');
+  return {
+    t: 1 /* BigInt */,
+    i: void 0,
+    a: void 0,
+    s: `${current}n`,
+    l: void 0,
+    m: void 0,
+    c: void 0,
+    d: void 0,
+    n: void 0
+  };
+}
+function createReferenceNode(id) {
+  return {
+    t: 2 /* Reference */,
+    i: id,
+    a: void 0,
+    s: void 0,
+    l: void 0,
+    m: void 0,
+    c: void 0,
+    d: void 0,
+    n: void 0
+  };
+}
+function createDateNode(id, current) {
+  return {
+    t: 3 /* Date */,
+    i: id,
+    a: void 0,
+    s: current.toISOString(),
+    l: void 0,
+    m: void 0,
+    c: void 0,
+    d: void 0,
+    n: void 0
+  };
+}
+function createRegExpNode(id, current) {
+  return {
+    t: 4 /* RegExp */,
+    i: id,
+    a: void 0,
+    s: String(current),
+    l: void 0,
+    m: void 0,
+    c: void 0,
+    d: void 0,
+    n: void 0
+  };
+}
+function createTypedArrayNode(ctx, id, current) {
+  const constructor = current.constructor.name;
+  assert(ctx.features & 1024 /* TypedArray */, `Unsupported value type "${constructor}"`);
+  return {
+    t: 14 /* TypedArray */,
+    i: id,
+    a: void 0,
+    s: current.toString(),
+    l: current.byteOffset,
+    m: void 0,
+    c: constructor,
+    d: void 0,
+    n: void 0
+  };
+}
+function createBigIntTypedArrayNode(ctx, id, current) {
+  const constructor = current.constructor.name;
+  assert(
+    ctx.features & 2048 /* BigIntTypedArray */,
+    `Unsupported value type "${constructor}"`
+  );
+  let result = "";
+  const cap = current.length - 1;
+  for (let i = 0; i < cap; i++) {
+    result += `${current[i]}n,`;
+  }
+  result += `"${current[cap]}"`;
+  return {
+    t: 15 /* BigIntTypedArray */,
+    i: id,
+    a: void 0,
+    s: result,
+    l: current.byteOffset,
+    m: void 0,
+    c: constructor,
+    d: void 0,
+    n: void 0
+  };
+}
+
 // src/tree/shared.ts
 function getErrorConstructor(error) {
   if (error instanceof EvalError) {
@@ -452,33 +544,16 @@ function getIterableOptions(obj) {
 function isReferenceInStack(ctx, node) {
   return node.t === 2 /* Reference */ && ctx.stack.includes(node.i);
 }
-function generateSemiPrimitiveValue(ctx, current, id) {
-  const cs = current.constructor;
-  switch (cs) {
-    case Date:
-      return {
-        t: 3 /* Date */,
-        i: id,
-        a: void 0,
-        s: current.toISOString(),
-        l: void 0,
-        m: void 0,
-        c: void 0,
-        d: void 0,
-        n: void 0
-      };
-    case RegExp:
-      return {
-        t: 4 /* RegExp */,
-        i: id,
-        a: void 0,
-        s: String(current),
-        l: void 0,
-        m: void 0,
-        c: void 0,
-        d: void 0,
-        n: void 0
-      };
+function isIterable(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  if (Array.isArray(value)) {
+    return false;
+  }
+  switch (value.constructor) {
+    case Map:
+    case Set:
     case Int8Array:
     case Int16Array:
     case Int32Array:
@@ -487,76 +562,14 @@ function generateSemiPrimitiveValue(ctx, current, id) {
     case Uint32Array:
     case Uint8ClampedArray:
     case Float32Array:
-    case Float64Array: {
-      const constructor = cs.name;
-      assert(ctx.features & 1024 /* TypedArray */, `Unsupported value type "${constructor}"`);
-      return {
-        t: 14 /* TypedArray */,
-        i: id,
-        a: void 0,
-        s: current.toString(),
-        l: current.byteOffset,
-        m: void 0,
-        c: constructor,
-        d: void 0,
-        n: void 0
-      };
-    }
+    case Float64Array:
     case BigInt64Array:
-    case BigUint64Array: {
-      const constructor = cs.name;
-      assert(
-        ctx.features & 2048 /* BigIntTypedArray */,
-        `Unsupported value type "${constructor}"`
-      );
-      let result = "";
-      const cap = current.length - 1;
-      for (let i = 0; i < cap; i++) {
-        result += `${current[i]}n,`;
-      }
-      result += `"${current[cap]}"`;
-      return {
-        t: 14 /* TypedArray */,
-        i: id,
-        a: void 0,
-        s: result,
-        l: current.byteOffset,
-        m: void 0,
-        c: constructor,
-        d: void 0,
-        n: void 0
-      };
-    }
+    case BigUint64Array:
+      return false;
     default:
-      return void 0;
-  }
-}
-function serializePrimitive(value) {
-  if (value === true) {
-    return "!0";
+      break;
   }
-  if (value === false) {
-    return "!1";
-  }
-  if (value === void 0) {
-    return "void 0";
-  }
-  if (value === null) {
-    return null;
-  }
-  if (typeof value === "string") {
-    return quote(value);
-  }
-  if (Object.is(value, -0)) {
-    return "-0";
-  }
-  if (Object.is(value, Infinity)) {
-    return "1/0";
-  }
-  if (Object.is(value, -Infinity)) {
-    return "-1/0";
-  }
-  return value;
+  return Symbol.iterator in value;
 }
 
 // src/tree/async.ts
@@ -569,14 +582,16 @@ async function serializePropertiesAsync(ctx, properties) {
   const deferredValues = new Array(size);
   let deferredSize = 0;
   let nodesSize = 0;
+  let item;
   for (const key of keys) {
-    if (isIterable(properties[key])) {
+    item = properties[key];
+    if (isIterable(item)) {
       deferredKeys[deferredSize] = key;
-      deferredValues[deferredSize] = properties[key];
+      deferredValues[deferredSize] = item;
       deferredSize++;
     } else {
       keyNodes[nodesSize] = key;
-      valueNodes[nodesSize] = await generateTreeAsync(ctx, properties[key]);
+      valueNodes[nodesSize] = await generateTreeAsync(ctx, item);
       nodesSize++;
     }
   }
@@ -659,12 +674,14 @@ async function generateNodeList(ctx, current) {
   const size = current.length;
   const nodes = new Array(size);
   const deferred = new Array(size);
+  let item;
   for (let i = 0; i < size; i++) {
     if (i in current) {
-      if (isIterable(current[i])) {
-        deferred[i] = current[i];
+      item = current[i];
+      if (isIterable(item)) {
+        deferred[i] = item;
       } else {
-        nodes[i] = await generateTreeAsync(ctx, current[i]);
+        nodes[i] = await generateTreeAsync(ctx, item);
       }
     }
   }
@@ -734,110 +751,141 @@ async function generateIterableNode(ctx, current, id) {
     n: void 0
   };
 }
-async function generateTreeAsync(ctx, current) {
-  if (isPrimitive(current)) {
-    return {
-      t: 0 /* Primitive */,
-      i: void 0,
-      s: serializePrimitive(current),
-      l: void 0,
-      m: void 0,
-      c: void 0,
-      // Parse options first before the items
-      d: void 0,
-      a: void 0,
-      n: void 0
-    };
-  }
-  if (typeof current === "bigint") {
-    assert(ctx.features & 8 /* BigInt */, 'Unsupported type "BigInt"');
-    return {
-      t: 1 /* BigInt */,
-      i: void 0,
-      a: void 0,
-      s: `${current}n`,
-      l: void 0,
-      m: void 0,
-      c: void 0,
-      d: void 0,
-      n: void 0
-    };
-  }
-  const id = createRef(ctx, current, true);
-  if (ctx.markedRefs[id]) {
-    return {
-      t: 2 /* Reference */,
-      i: id,
-      a: void 0,
-      s: void 0,
-      l: void 0,
-      m: void 0,
-      c: void 0,
-      d: void 0,
-      n: void 0
-    };
-  }
-  if (Array.isArray(current)) {
-    return generateArrayNode(ctx, current, id);
-  }
-  const cs = current.constructor;
-  const empty = cs == null;
-  if (cs === Object || empty) {
-    if (Symbol.iterator in current) {
-      return generateIterableNode(ctx, current, id);
-    }
-    return {
-      t: empty ? 9 /* NullConstructor */ : 8 /* Object */,
-      i: id,
-      s: void 0,
-      l: void 0,
-      m: void 0,
-      c: void 0,
-      // Parse options first before the items
-      d: await serializePropertiesAsync(ctx, current),
-      a: void 0,
-      n: void 0
-    };
-  }
-  if (cs === Set) {
-    return generateSetNode(ctx, current, id);
-  }
-  if (cs === Map) {
-    return generateMapNode(ctx, current, id);
-  }
-  const semiPrimitive = generateSemiPrimitiveValue(ctx, current, id);
-  if (semiPrimitive) {
-    return semiPrimitive;
-  }
+async function generateObjectNode(ctx, current, id, empty) {
   if (Symbol.iterator in current) {
     return generateIterableNode(ctx, current, id);
   }
-  if (isPromise(current)) {
-    assert(ctx.features & 128 /* Promise */, 'Unsupported type "Promise"');
-    return current.then(async (value) => ({
-      t: 10 /* Promise */,
-      i: id,
-      s: void 0,
-      l: void 0,
-      m: void 0,
-      c: void 0,
-      // Parse options first before the items
-      d: void 0,
-      a: void 0,
-      n: await generateTreeAsync(ctx, value)
-    }));
-  }
-  if (current instanceof AggregateError && ctx.features & 1 /* AggregateError */) {
-    return generateAggregateErrorNode(ctx, current, id);
-  }
-  if (current instanceof Error) {
-    return generateErrorNode(ctx, current, id);
-  }
-  throw new Error("Unsupported value");
+  if ("then" in current && typeof current.then === "function") {
+    return generatePromiseNode(ctx, current, id);
+  }
+  return {
+    t: empty ? 9 /* NullConstructor */ : 8 /* Object */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    m: void 0,
+    c: void 0,
+    d: await serializePropertiesAsync(ctx, current),
+    a: void 0,
+    n: void 0
+  };
+}
+async function generatePromiseNode(ctx, current, id) {
+  assert(ctx.features & 128 /* Promise */, 'Unsupported type "Promise"');
+  return current.then(async (value) => ({
+    t: 10 /* Promise */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    m: void 0,
+    c: void 0,
+    // Parse options first before the items
+    d: void 0,
+    a: void 0,
+    n: await generateTreeAsync(ctx, value)
+  }));
+}
+async function generateTreeAsync(ctx, current) {
+  switch (typeof current) {
+    case "boolean":
+      return current ? TRUE_NODE : FALSE_NODE;
+    case "undefined":
+      return UNDEFINED_NODE;
+    case "string":
+      return createPrimitiveNode(quote(current));
+    case "number":
+      if (Object.is(current, -0)) {
+        return NEG_ZERO_NODE;
+      }
+      if (Object.is(current, Infinity)) {
+        return createPrimitiveNode("1/0");
+      }
+      if (Object.is(current, -Infinity)) {
+        return createPrimitiveNode("-1/0");
+      }
+      return createPrimitiveNode(current);
+    case "bigint":
+      return createBigIntNode(ctx, current);
+    case "object": {
+      if (!current) {
+        return NULL_NODE;
+      }
+      const id = createRef(ctx, current, true);
+      if (ctx.markedRefs[id]) {
+        return createReferenceNode(id);
+      }
+      if (Array.isArray(current)) {
+        return generateArrayNode(ctx, current, id);
+      }
+      switch (current.constructor) {
+        case Date:
+          return createDateNode(id, current);
+        case RegExp:
+          return createRegExpNode(id, current);
+        case Promise:
+          return generatePromiseNode(ctx, current, id);
+        case Map:
+          return generateMapNode(ctx, current, id);
+        case Set:
+          return generateSetNode(ctx, current, id);
+        case Object:
+          return generateObjectNode(ctx, current, id, false);
+        case void 0:
+          return generateObjectNode(ctx, current, id, true);
+        case Int8Array:
+        case Int16Array:
+        case Int32Array:
+        case Uint8Array:
+        case Uint16Array:
+        case Uint32Array:
+        case Uint8ClampedArray:
+        case Float32Array:
+        case Float64Array:
+          return createTypedArrayNode(ctx, id, current);
+        case BigInt64Array:
+        case BigUint64Array:
+          return createBigIntTypedArrayNode(ctx, id, current);
+        case AggregateError:
+          if (ctx.features & 1 /* AggregateError */) {
+            return generateAggregateErrorNode(ctx, current, id);
+          }
+          return generateErrorNode(ctx, current, id);
+        case Error:
+        case EvalError:
+        case RangeError:
+        case ReferenceError:
+        case SyntaxError:
+        case TypeError:
+        case URIError:
+          return generateErrorNode(ctx, current, id);
+        default:
+          break;
+      }
+      if (current instanceof AggregateError && ctx.features & 1 /* AggregateError */) {
+        return generateAggregateErrorNode(ctx, current, id);
+      }
+      if (current instanceof Error) {
+        return generateErrorNode(ctx, current, id);
+      }
+      if (current instanceof Promise) {
+        return generatePromiseNode(ctx, current, id);
+      }
+      if (Symbol.iterator in current) {
+        return generateIterableNode(ctx, current, id);
+      }
+      if ("then" in current && typeof current.then === "function") {
+        return generatePromiseNode(ctx, current, id);
+      }
+      throw new Error("Unsupported type");
+    }
+    default:
+      throw new Error("Unsupported type");
+  }
 }
 async function parseAsync(ctx, current) {
   const result = await generateTreeAsync(ctx, current);
-  return [result, createRef(ctx, current, false), result.t === 8 /* Object */];
+  const isObject = result.t === 8 /* Object */ || result.t === 13 /* Iterable */;
+  return [result, createRef(ctx, current, false), isObject];
 }
 
 // src/tree/serialize.ts
@@ -1231,14 +1279,16 @@ function serializePropertiesSync(ctx, properties) {
   const deferredValues = new Array(size);
   let deferredSize = 0;
   let nodesSize = 0;
+  let item;
   for (const key of keys) {
-    if (isIterable(properties[key])) {
+    item = properties[key];
+    if (isIterable(item)) {
       deferredKeys[deferredSize] = key;
-      deferredValues[deferredSize] = properties[key];
+      deferredValues[deferredSize] = item;
       deferredSize++;
     } else {
       keyNodes[nodesSize] = key;
-      valueNodes[nodesSize] = generateTreeSync(ctx, properties[key]);
+      valueNodes[nodesSize] = generateTreeSync(ctx, item);
       nodesSize++;
     }
   }
@@ -1321,12 +1371,14 @@ function generateNodeList2(ctx, current) {
   const size = current.length;
   const nodes = new Array(size);
   const deferred = new Array(size);
+  let item;
   for (let i = 0; i < size; i++) {
     if (i in current) {
-      if (isIterable(current[i])) {
-        deferred[i] = current[i];
+      item = current[i];
+      if (isIterable(item)) {
+        deferred[i] = item;
       } else {
-        nodes[i] = generateTreeSync(ctx, current[i]);
+        nodes[i] = generateTreeSync(ctx, item);
       }
     }
   }
@@ -1396,95 +1448,115 @@ function generateIterableNode2(ctx, current, id) {
     n: void 0
   };
 }
-function generateTreeSync(ctx, current) {
-  if (isPrimitive(current)) {
-    return {
-      t: 0 /* Primitive */,
-      i: void 0,
-      s: serializePrimitive(current),
-      l: void 0,
-      m: void 0,
-      c: void 0,
-      // Parse options first before the items
-      d: void 0,
-      a: void 0,
-      n: void 0
-    };
-  }
-  if (typeof current === "bigint") {
-    assert(ctx.features & 8 /* BigInt */, 'Unsupported type "BigInt"');
-    return {
-      t: 1 /* BigInt */,
-      i: void 0,
-      a: void 0,
-      s: `${current}n`,
-      l: void 0,
-      m: void 0,
-      c: void 0,
-      d: void 0,
-      n: void 0
-    };
-  }
-  const id = createRef(ctx, current, true);
-  if (ctx.markedRefs[id]) {
-    return {
-      t: 2 /* Reference */,
-      i: id,
-      a: void 0,
-      s: void 0,
-      l: void 0,
-      m: void 0,
-      c: void 0,
-      d: void 0,
-      n: void 0
-    };
-  }
-  if (Array.isArray(current)) {
-    return generateArrayNode2(ctx, current, id);
-  }
-  const cs = current.constructor;
-  const empty = cs == null;
-  if (cs === Object || empty) {
-    if (Symbol.iterator in current) {
-      return generateIterableNode2(ctx, current, id);
-    }
-    return {
-      t: empty ? 9 /* NullConstructor */ : 8 /* Object */,
-      i: id,
-      s: void 0,
-      l: void 0,
-      m: void 0,
-      c: void 0,
-      // Parse options first before the items
-      d: serializePropertiesSync(ctx, current),
-      a: void 0,
-      n: void 0
-    };
-  }
-  if (cs === Set) {
-    return generateSetNode2(ctx, current, id);
-  }
-  if (cs === Map) {
-    return generateMapNode2(ctx, current, id);
-  }
-  const semiPrimitive = generateSemiPrimitiveValue(ctx, current, id);
-  if (semiPrimitive) {
-    return semiPrimitive;
-  }
+function generateObjectNode2(ctx, current, id, empty) {
   if (Symbol.iterator in current) {
     return generateIterableNode2(ctx, current, id);
   }
-  if (current instanceof AggregateError && ctx.features & 1 /* AggregateError */) {
-    return generateAggregateErrorNode2(ctx, current, id);
-  }
-  if (current instanceof Error) {
-    return generateErrorNode2(ctx, current, id);
+  return {
+    t: empty ? 9 /* NullConstructor */ : 8 /* Object */,
+    i: id,
+    s: void 0,
+    l: void 0,
+    m: void 0,
+    c: void 0,
+    d: serializePropertiesSync(ctx, current),
+    a: void 0,
+    n: void 0
+  };
+}
+function generateTreeSync(ctx, current) {
+  switch (typeof current) {
+    case "boolean":
+      return current ? TRUE_NODE : FALSE_NODE;
+    case "undefined":
+      return UNDEFINED_NODE;
+    case "string":
+      return createPrimitiveNode(quote(current));
+    case "number":
+      if (Object.is(current, -0)) {
+        return NEG_ZERO_NODE;
+      }
+      if (Object.is(current, Infinity)) {
+        return createPrimitiveNode("1/0");
+      }
+      if (Object.is(current, -Infinity)) {
+        return createPrimitiveNode("-1/0");
+      }
+      return createPrimitiveNode(current);
+    case "bigint":
+      return createBigIntNode(ctx, current);
+    case "object": {
+      if (!current) {
+        return NULL_NODE;
+      }
+      const id = createRef(ctx, current, true);
+      if (ctx.markedRefs[id]) {
+        return createReferenceNode(id);
+      }
+      if (Array.isArray(current)) {
+        return generateArrayNode2(ctx, current, id);
+      }
+      switch (current.constructor) {
+        case Date:
+          return createDateNode(id, current);
+        case RegExp:
+          return createRegExpNode(id, current);
+        case Map:
+          return generateMapNode2(ctx, current, id);
+        case Set:
+          return generateSetNode2(ctx, current, id);
+        case Object:
+          return generateObjectNode2(ctx, current, id, false);
+        case void 0:
+          return generateObjectNode2(ctx, current, id, true);
+        case Int8Array:
+        case Int16Array:
+        case Int32Array:
+        case Uint8Array:
+        case Uint16Array:
+        case Uint32Array:
+        case Uint8ClampedArray:
+        case Float32Array:
+        case Float64Array:
+          return createTypedArrayNode(ctx, id, current);
+        case BigInt64Array:
+        case BigUint64Array:
+          return createBigIntTypedArrayNode(ctx, id, current);
+        case AggregateError:
+          if (ctx.features & 1 /* AggregateError */) {
+            return generateAggregateErrorNode2(ctx, current, id);
+          }
+          return generateErrorNode2(ctx, current, id);
+        case Error:
+        case EvalError:
+        case RangeError:
+        case ReferenceError:
+        case SyntaxError:
+        case TypeError:
+        case URIError:
+          return generateErrorNode2(ctx, current, id);
+        default:
+          break;
+      }
+      if (current instanceof AggregateError && ctx.features & 1 /* AggregateError */) {
+        return generateAggregateErrorNode2(ctx, current, id);
+      }
+      if (current instanceof Error) {
+        return generateErrorNode2(ctx, current, id);
+      }
+      if (Symbol.iterator in current) {
+        return generateIterableNode2(ctx, current, id);
+      }
+      throw new Error("Unsupported type");
+    }
+    default:
+      throw new Error("Unsupported type");
   }
-  throw new Error("Unsupported value");
 }
 function parseSync(ctx, current) {
   const result = generateTreeSync(ctx, current);
-  return [result, createRef(ctx, current, false), result.t === 8 /* Object */];
+  const isObject = result.t === 8 /* Object */ || result.t === 13 /* Iterable */;
+  return [result, createRef(ctx, current, false), isObject];
 }
 
 // src/index.ts
@@ -1514,9 +1586,6 @@ function finalize(ctx, rootID, isObject, result) {
 }
 function serialize(source, options) {
   const ctx = createParserContext(options);
-  if (isPrimitive(source)) {
-    return String(serializePrimitive(source));
-  }
   const [tree, rootID, isObject] = parseSync(ctx, source);
   const serial = createSerializationContext(ctx);
   const result = serializeTree(serial, tree);
@@ -1524,9 +1593,6 @@ function serialize(source, options) {
 }
 async function serializeAsync(source, options) {
   const ctx = createParserContext(options);
-  if (isPrimitive(source)) {
-    return String(serializePrimitive(source));
-  }
   const [tree, rootID, isObject] = await parseAsync(ctx, source);
   const serial = createSerializationContext(ctx);
   const result = serializeTree(serial, tree);