seroval 1.0.4 → 1.0.6

package/dist/esm/development/index.mjs

@@ -9,13 +9,6 @@ var Feature = /* @__PURE__ */ ((Feature2) => {
 })(Feature || {});
 var ALL_ENABLED = 31;
 
-// src/core/utils/assert.ts
-function assert(cond, error) {
-  if (!cond) {
-    throw error;
-  }
-}
-
 // src/core/string.ts
 function serializeChar(str) {
   switch (str) {
@@ -107,6 +100,13 @@ function getCrossReferenceHeader(id) {
   )}"]=[]`;
 }
 
+// src/core/utils/assert.ts
+function assert(cond, error) {
+  if (!cond) {
+    throw error;
+  }
+}
+
 // src/core/reference.ts
 var REFERENCE = /* @__PURE__ */ new Map();
 var INV_REFERENCE = /* @__PURE__ */ new Map();
@@ -234,20 +234,20 @@ var CONSTANT_STRING = {
   [3 /* False */]: "!1",
   [1 /* Undefined */]: "void 0",
   [0 /* Null */]: "null",
-  [4 /* NegativeZero */]: "-0",
-  [5 /* Infinity */]: "1/0",
-  [6 /* NegativeInfinity */]: "-1/0",
-  [7 /* NaN */]: "0/0"
+  [4 /* NegZero */]: "-0",
+  [5 /* Inf */]: "1/0",
+  [6 /* NegInf */]: "-1/0",
+  [7 /* Nan */]: "0/0"
 };
 var CONSTANT_VAL = {
   [2 /* True */]: true,
   [3 /* False */]: false,
   [1 /* Undefined */]: void 0,
   [0 /* Null */]: null,
-  [4 /* NegativeZero */]: -0,
-  [5 /* Infinity */]: Infinity,
-  [6 /* NegativeInfinity */]: -Infinity,
-  [7 /* NaN */]: NaN
+  [4 /* NegZero */]: -0,
+  [5 /* Inf */]: Number.POSITIVE_INFINITY,
+  [6 /* NegInf */]: Number.NEGATIVE_INFINITY,
+  [7 /* Nan */]: Number.NaN
 };
 var ERROR_CONSTRUCTOR_STRING = {
   [0 /* Error */]: "Error",
@@ -298,15 +298,15 @@ var NULL_NODE = /* @__PURE__ */ createConstantNode(
   0 /* Null */
 );
 var NEG_ZERO_NODE = /* @__PURE__ */ createConstantNode(
-  4 /* NegativeZero */
+  4 /* NegZero */
 );
 var INFINITY_NODE = /* @__PURE__ */ createConstantNode(
-  5 /* Infinity */
+  5 /* Inf */
 );
 var NEG_INFINITY_NODE = /* @__PURE__ */ createConstantNode(
-  6 /* NegativeInfinity */
+  6 /* NegInf */
 );
-var NAN_NODE = /* @__PURE__ */ createConstantNode(7 /* NaN */);
+var NAN_NODE = /* @__PURE__ */ createConstantNode(7 /* Nan */);
 
 // src/core/utils/error.ts
 function getErrorConstructor(error) {
@@ -377,9 +377,9 @@ function getObjectFlag(obj) {
 // src/core/base-primitives.ts
 function createNumberNode(value) {
   switch (value) {
-    case Infinity:
+    case Number.POSITIVE_INFINITY:
       return INFINITY_NODE;
-    case -Infinity:
+    case Number.NEGATIVE_INFINITY:
       return NEG_INFINITY_NODE;
   }
   if (value !== value) {
@@ -778,70 +778,6 @@ function createStreamReturnNode(id, parsed) {
   };
 }
 
-// src/core/utils/iterator-to-sequence.ts
-function iteratorToSequence(source) {
-  const values = [];
-  let throwsAt = -1;
-  let doneAt = -1;
-  const iterator = source[Symbol.iterator]();
-  while (true) {
-    try {
-      const value = iterator.next();
-      values.push(value.value);
-      if (value.done) {
-        doneAt = values.length - 1;
-        break;
-      }
-    } catch (error) {
-      throwsAt = values.length;
-      values.push(error);
-    }
-  }
-  return {
-    v: values,
-    t: throwsAt,
-    d: doneAt
-  };
-}
-function sequenceToIterator(sequence) {
-  return () => {
-    let index = 0;
-    return {
-      [Symbol.iterator]() {
-        return this;
-      },
-      next() {
-        if (index > sequence.d) {
-          return {
-            done: true,
-            value: void 0
-          };
-        }
-        const currentIndex = index++;
-        const currentItem = sequence.v[currentIndex];
-        if (currentIndex === sequence.t) {
-          throw currentItem;
-        }
-        return {
-          done: currentIndex === sequence.d,
-          value: currentItem
-        };
-      }
-    };
-  };
-}
-
-// src/core/special-reference.ts
-var ITERATOR = {};
-var ASYNC_ITERATOR = {};
-var SPECIAL_REFS = {
-  [0 /* MapSentinel */]: {},
-  [1 /* PromiseConstructor */]: {},
-  [2 /* PromiseResolve */]: {},
-  [3 /* PromiseReject */]: {},
-  [4 /* StreamConstructor */]: {}
-};
-
 // src/core/errors.ts
 var { toString: objectToString } = Object.prototype;
 function getErrorMessage(type, cause) {
@@ -927,190 +863,17 @@ var SerovalUnknownTypedArrayError = class extends Error {
   }
 };
 
-// src/core/context/parser.ts
-var BaseParserContext = class {
-  constructor(options) {
-    this.marked = /* @__PURE__ */ new Set();
-    this.plugins = options.plugins;
-    this.features = ALL_ENABLED ^ (options.disabledFeatures || 0);
-    this.refs = options.refs || /* @__PURE__ */ new Map();
-  }
-  markRef(id) {
-    this.marked.add(id);
-  }
-  isMarked(id) {
-    return this.marked.has(id);
-  }
-  getIndexedValue(current) {
-    const registeredId = this.refs.get(current);
-    if (registeredId != null) {
-      this.markRef(registeredId);
-      return {
-        type: 1 /* Indexed */,
-        value: createIndexedValueNode(registeredId)
-      };
-    }
-    const id = this.refs.size;
-    this.refs.set(current, id);
-    return {
-      type: 0 /* Fresh */,
-      value: id
-    };
-  }
-  getReference(current) {
-    const indexed = this.getIndexedValue(current);
-    if (indexed.type === 1 /* Indexed */) {
-      return indexed;
-    }
-    if (hasReferenceID(current)) {
-      return {
-        type: 2 /* Referenced */,
-        value: createReferenceNode(indexed.value, current)
-      };
-    }
-    return indexed;
-  }
-  getStrictReference(current) {
-    assert(hasReferenceID(current), new SerovalUnsupportedTypeError(current));
-    const result = this.getIndexedValue(current);
-    if (result.type === 1 /* Indexed */) {
-      return result.value;
-    }
-    return createReferenceNode(result.value, current);
-  }
-  parseFunction(current) {
-    return this.getStrictReference(current);
-  }
-  parseWellKnownSymbol(current) {
-    const ref = this.getReference(current);
-    if (ref.type !== 0 /* Fresh */) {
-      return ref.value;
-    }
-    assert(current in INV_SYMBOL_REF, new SerovalUnsupportedTypeError(current));
-    return createWKSymbolNode(ref.value, current);
-  }
-  parseSpecialReference(ref) {
-    const result = this.getIndexedValue(SPECIAL_REFS[ref]);
-    if (result.type === 1 /* Indexed */) {
-      return result.value;
-    }
-    return {
-      t: 26 /* SpecialReference */,
-      i: result.value,
-      s: ref,
-      l: void 0,
-      c: void 0,
-      m: void 0,
-      p: void 0,
-      e: void 0,
-      a: void 0,
-      f: void 0,
-      b: void 0,
-      o: void 0
-    };
-  }
-  parseIteratorFactory() {
-    const result = this.getIndexedValue(ITERATOR);
-    if (result.type === 1 /* Indexed */) {
-      return result.value;
-    }
-    return {
-      t: 27 /* IteratorFactory */,
-      i: result.value,
-      s: void 0,
-      l: void 0,
-      c: void 0,
-      m: void 0,
-      p: void 0,
-      e: void 0,
-      a: void 0,
-      f: this.parseWellKnownSymbol(Symbol.iterator),
-      b: void 0,
-      o: void 0
-    };
-  }
-  parseAsyncIteratorFactory() {
-    const result = this.getIndexedValue(ASYNC_ITERATOR);
-    if (result.type === 1 /* Indexed */) {
-      return result.value;
-    }
-    return {
-      t: 29 /* AsyncIteratorFactory */,
-      i: result.value,
-      s: void 0,
-      l: void 0,
-      c: void 0,
-      m: void 0,
-      p: void 0,
-      e: void 0,
-      a: [
-        this.parseSpecialReference(1 /* PromiseConstructor */),
-        this.parseWellKnownSymbol(Symbol.asyncIterator)
-      ],
-      f: void 0,
-      b: void 0,
-      o: void 0
-    };
-  }
-  createObjectNode(id, current, empty, record) {
-    return {
-      t: empty ? 11 /* NullConstructor */ : 10 /* Object */,
-      i: id,
-      s: void 0,
-      l: void 0,
-      c: void 0,
-      m: void 0,
-      p: record,
-      e: void 0,
-      a: void 0,
-      f: void 0,
-      b: void 0,
-      o: getObjectFlag(current)
-    };
-  }
-  createMapNode(id, k, v, s) {
-    return {
-      t: 8 /* Map */,
-      i: id,
-      s: void 0,
-      l: void 0,
-      c: void 0,
-      m: void 0,
-      p: void 0,
-      e: { k, v, s },
-      a: void 0,
-      f: this.parseSpecialReference(0 /* MapSentinel */),
-      b: void 0,
-      o: void 0
-    };
-  }
-  createPromiseConstructorNode(id) {
-    return {
-      t: 22 /* PromiseConstructor */,
-      i: id,
-      s: void 0,
-      l: void 0,
-      c: void 0,
-      m: void 0,
-      p: void 0,
-      e: void 0,
-      a: void 0,
-      f: this.parseSpecialReference(1 /* PromiseConstructor */),
-      b: void 0,
-      o: void 0
-    };
-  }
+// src/core/special-reference.ts
+var ITERATOR = {};
+var ASYNC_ITERATOR = {};
+var SPECIAL_REFS = {
+  [0 /* MapSentinel */]: {},
+  [1 /* PromiseConstructor */]: {},
+  [2 /* PromiseResolve */]: {},
+  [3 /* PromiseReject */]: {},
+  [4 /* StreamConstructor */]: {}
 };
 
-// src/core/utils/promise-to-result.ts
-async function promiseToResult(current) {
-  try {
-    return [1, await current];
-  } catch (e) {
-    return [0, e];
-  }
-}
-
 // src/core/utils/deferred.ts
 function createDeferred() {
   let resolve;
@@ -1137,7 +900,7 @@ function createStream() {
   const listeners = /* @__PURE__ */ new Set();
   const buffer = [];
   let alive = true;
-  let success = false;
+  let success = true;
   function flushNext(value) {
     for (const listener of listeners.keys()) {
       listener.next(value);
@@ -1161,7 +924,7 @@ function createStream() {
       }
       for (let i = 0, len = buffer.length; i < len; i++) {
         const value = buffer[i];
-        if (i === len - 1) {
+        if (i === len - 1 && !alive) {
           if (success) {
             listener.return(value);
           } else {
@@ -1297,6 +1060,243 @@ function streamToAsyncIterable(stream) {
   };
 }
 
+// src/core/utils/iterator-to-sequence.ts
+function iteratorToSequence(source) {
+  const values = [];
+  let throwsAt = -1;
+  let doneAt = -1;
+  const iterator = source[Symbol.iterator]();
+  while (true) {
+    try {
+      const value = iterator.next();
+      values.push(value.value);
+      if (value.done) {
+        doneAt = values.length - 1;
+        break;
+      }
+    } catch (error) {
+      throwsAt = values.length;
+      values.push(error);
+    }
+  }
+  return {
+    v: values,
+    t: throwsAt,
+    d: doneAt
+  };
+}
+function sequenceToIterator(sequence) {
+  return () => {
+    let index = 0;
+    return {
+      [Symbol.iterator]() {
+        return this;
+      },
+      next() {
+        if (index > sequence.d) {
+          return {
+            done: true,
+            value: void 0
+          };
+        }
+        const currentIndex = index++;
+        const currentItem = sequence.v[currentIndex];
+        if (currentIndex === sequence.t) {
+          throw currentItem;
+        }
+        return {
+          done: currentIndex === sequence.d,
+          value: currentItem
+        };
+      }
+    };
+  };
+}
+
+// src/core/utils/promise-to-result.ts
+async function promiseToResult(current) {
+  try {
+    return [1, await current];
+  } catch (e) {
+    return [0, e];
+  }
+}
+
+// src/core/context/parser.ts
+var BaseParserContext = class {
+  constructor(options) {
+    this.marked = /* @__PURE__ */ new Set();
+    this.plugins = options.plugins;
+    this.features = ALL_ENABLED ^ (options.disabledFeatures || 0);
+    this.refs = options.refs || /* @__PURE__ */ new Map();
+  }
+  markRef(id) {
+    this.marked.add(id);
+  }
+  isMarked(id) {
+    return this.marked.has(id);
+  }
+  getIndexedValue(current) {
+    const registeredId = this.refs.get(current);
+    if (registeredId != null) {
+      this.markRef(registeredId);
+      return {
+        type: 1 /* Indexed */,
+        value: createIndexedValueNode(registeredId)
+      };
+    }
+    const id = this.refs.size;
+    this.refs.set(current, id);
+    return {
+      type: 0 /* Fresh */,
+      value: id
+    };
+  }
+  getReference(current) {
+    const indexed = this.getIndexedValue(current);
+    if (indexed.type === 1 /* Indexed */) {
+      return indexed;
+    }
+    if (hasReferenceID(current)) {
+      return {
+        type: 2 /* Referenced */,
+        value: createReferenceNode(indexed.value, current)
+      };
+    }
+    return indexed;
+  }
+  getStrictReference(current) {
+    assert(hasReferenceID(current), new SerovalUnsupportedTypeError(current));
+    const result = this.getIndexedValue(current);
+    if (result.type === 1 /* Indexed */) {
+      return result.value;
+    }
+    return createReferenceNode(result.value, current);
+  }
+  parseFunction(current) {
+    return this.getStrictReference(current);
+  }
+  parseWellKnownSymbol(current) {
+    const ref = this.getReference(current);
+    if (ref.type !== 0 /* Fresh */) {
+      return ref.value;
+    }
+    assert(current in INV_SYMBOL_REF, new SerovalUnsupportedTypeError(current));
+    return createWKSymbolNode(ref.value, current);
+  }
+  parseSpecialReference(ref) {
+    const result = this.getIndexedValue(SPECIAL_REFS[ref]);
+    if (result.type === 1 /* Indexed */) {
+      return result.value;
+    }
+    return {
+      t: 26 /* SpecialReference */,
+      i: result.value,
+      s: ref,
+      l: void 0,
+      c: void 0,
+      m: void 0,
+      p: void 0,
+      e: void 0,
+      a: void 0,
+      f: void 0,
+      b: void 0,
+      o: void 0
+    };
+  }
+  parseIteratorFactory() {
+    const result = this.getIndexedValue(ITERATOR);
+    if (result.type === 1 /* Indexed */) {
+      return result.value;
+    }
+    return {
+      t: 27 /* IteratorFactory */,
+      i: result.value,
+      s: void 0,
+      l: void 0,
+      c: void 0,
+      m: void 0,
+      p: void 0,
+      e: void 0,
+      a: void 0,
+      f: this.parseWellKnownSymbol(Symbol.iterator),
+      b: void 0,
+      o: void 0
+    };
+  }
+  parseAsyncIteratorFactory() {
+    const result = this.getIndexedValue(ASYNC_ITERATOR);
+    if (result.type === 1 /* Indexed */) {
+      return result.value;
+    }
+    return {
+      t: 29 /* AsyncIteratorFactory */,
+      i: result.value,
+      s: void 0,
+      l: void 0,
+      c: void 0,
+      m: void 0,
+      p: void 0,
+      e: void 0,
+      a: [
+        this.parseSpecialReference(1 /* PromiseConstructor */),
+        this.parseWellKnownSymbol(Symbol.asyncIterator)
+      ],
+      f: void 0,
+      b: void 0,
+      o: void 0
+    };
+  }
+  createObjectNode(id, current, empty, record) {
+    return {
+      t: empty ? 11 /* NullConstructor */ : 10 /* Object */,
+      i: id,
+      s: void 0,
+      l: void 0,
+      c: void 0,
+      m: void 0,
+      p: record,
+      e: void 0,
+      a: void 0,
+      f: void 0,
+      b: void 0,
+      o: getObjectFlag(current)
+    };
+  }
+  createMapNode(id, k, v, s) {
+    return {
+      t: 8 /* Map */,
+      i: id,
+      s: void 0,
+      l: void 0,
+      c: void 0,
+      m: void 0,
+      p: void 0,
+      e: { k, v, s },
+      a: void 0,
+      f: this.parseSpecialReference(0 /* MapSentinel */),
+      b: void 0,
+      o: void 0
+    };
+  }
+  createPromiseConstructorNode(id) {
+    return {
+      t: 22 /* PromiseConstructor */,
+      i: id,
+      s: void 0,
+      l: void 0,
+      c: void 0,
+      m: void 0,
+      p: void 0,
+      e: void 0,
+      a: void 0,
+      f: this.parseSpecialReference(1 /* PromiseConstructor */),
+      b: void 0,
+      o: void 0
+    };
+  }
+};
+
 // src/core/context/parser/async.ts
 var BaseAsyncParserContext = class extends BaseParserContext {
   async parseItems(current) {
@@ -2606,7 +2606,7 @@ var BaseSerializerContext = class {
             "for(x=0;x<p;x++)l[x]&&l[x][m](v)"
           ) + ",n=" + this.createEffectfulFunction(
             ["o", "x", "z", "c"],
-            'for(x=0,z=b.length;x<z;x++)(c=b[x],x===z-1?o[s?"return":"throw"](c):o.next(c))'
+            'for(x=0,z=b.length;x<z;x++)(c=b[x],(!a&&x===z-1)?o[s?"return":"throw"](c):o.next(c))'
           ) + ",e=" + this.createFunction(
             ["o", "t"],
             "(a&&(l[t=p++]=o),n(o)," + this.createEffectfulFunction([], "a&&(l[t]=void 0)") + ")"