seroval 0.4.0-alpha.12 → 0.4.0-alpha.13

package/dist/esm/development/index.mjs

@@ -249,25 +249,33 @@ function getIdentifier(index) {
 var DEFAULT_OPTIONS = {
   target: "es2023"
 };
-function createParserContext(options = {}) {
-  const result = Object.assign({}, DEFAULT_OPTIONS, options || {});
-  return {
-    markedRefs: {},
-    refs: /* @__PURE__ */ new Map(),
-    features: parseTargets(result.target)
-  };
-}
-function createSerializationContext(options) {
-  return {
-    stack: [],
-    vars: [],
-    assignments: [],
-    validRefs: [],
-    refSize: 0,
-    features: options.features,
-    markedRefs: options.markedRefs
-  };
-}
+var ParserContext = class {
+  constructor(options = {}) {
+    __publicField(this, "refs", /* @__PURE__ */ new Map());
+    __publicField(this, "markedRefs", {});
+    __publicField(this, "features");
+    const result = Object.assign({}, DEFAULT_OPTIONS, options || {});
+    this.features = parseTargets(result.target);
+  }
+};
+var SerializationContext = class {
+  constructor(options) {
+    __publicField(this, "stack", []);
+    // Map tree refs to actual refs
+    __publicField(this, "validRefs", []);
+    __publicField(this, "refSize", 0);
+    // Variables
+    __publicField(this, "vars", []);
+    // Array of assignments to be done (used for recursion)
+    __publicField(this, "assignments", []);
+    // Supported features
+    __publicField(this, "features");
+    // Refs that are...referenced
+    __publicField(this, "markedRefs");
+    this.features = options.features;
+    this.markedRefs = options.markedRefs;
+  }
+};
 function markRef(ctx, current) {
   ctx.markedRefs[current] = 1;
 }
@@ -351,119 +359,198 @@ function quote(str) {
   return `"${result}"`;
 }
 
+// src/tree/types.ts
+var SerovalObjectRecordNode = class {
+  constructor(k, v, s) {
+    __publicField(this, "k");
+    __publicField(this, "v");
+    __publicField(this, "s");
+    this.k = k;
+    this.v = v;
+    this.s = s;
+  }
+};
+var SerovalMapRecordNode = class {
+  constructor(k, v, s) {
+    __publicField(this, "k");
+    __publicField(this, "v");
+    __publicField(this, "s");
+    this.k = k;
+    this.v = v;
+    this.s = s;
+  }
+};
+var SerovalPrimitiveNode = class {
+  constructor(current) {
+    __publicField(this, "t", 0 /* Primitive */);
+    __publicField(this, "s");
+    this.s = current;
+  }
+};
+var SerovalReferenceNode = class {
+  constructor(id) {
+    __publicField(this, "t", 2 /* Reference */);
+    __publicField(this, "i");
+    this.i = id;
+  }
+};
+var SerovalBigIntNode = class {
+  constructor(current) {
+    __publicField(this, "t", 1 /* BigInt */);
+    __publicField(this, "s");
+    this.s = `${current}n`;
+  }
+};
+var SerovalDateNode = class {
+  constructor(id, current) {
+    __publicField(this, "t", 3 /* Date */);
+    __publicField(this, "i");
+    __publicField(this, "s");
+    this.i = id;
+    this.s = current.toISOString();
+  }
+};
+var SerovalRegExpNode = class {
+  constructor(id, current) {
+    __publicField(this, "t", 4 /* RegExp */);
+    __publicField(this, "i");
+    __publicField(this, "s");
+    this.i = id;
+    this.s = String(current);
+  }
+};
+var SerovalTypedArrayNode = class {
+  constructor(id, current) {
+    __publicField(this, "t", 14 /* TypedArray */);
+    __publicField(this, "i");
+    __publicField(this, "s");
+    __publicField(this, "l");
+    __publicField(this, "c");
+    this.i = id;
+    this.s = current.toString();
+    this.l = current.byteOffset;
+    this.c = current.constructor.name;
+  }
+};
+var SerovalBigIntTypedArrayNode = class {
+  constructor(id, current) {
+    __publicField(this, "t", 15 /* BigIntTypedArray */);
+    __publicField(this, "i");
+    __publicField(this, "s");
+    __publicField(this, "l");
+    __publicField(this, "c");
+    let result = "";
+    const cap = current.length - 1;
+    for (let i = 0; i < cap; i++) {
+      result += `${current[i]}n,`;
+    }
+    result += `"${current[cap]}"`;
+    this.i = id;
+    this.s = result;
+    this.l = current.byteOffset;
+    this.c = current.constructor.name;
+  }
+};
+var SerovalSetNode = class {
+  constructor(id, a) {
+    __publicField(this, "t", 5 /* Set */);
+    __publicField(this, "i");
+    __publicField(this, "a");
+    this.i = id;
+    this.a = a;
+  }
+};
+var SerovalMapNode = class {
+  constructor(id, d) {
+    __publicField(this, "t", 6 /* Map */);
+    __publicField(this, "i");
+    __publicField(this, "d");
+    this.i = id;
+    this.d = d;
+  }
+};
+var SerovalArrayNode = class {
+  constructor(id, a) {
+    __publicField(this, "t", 7 /* Array */);
+    __publicField(this, "i");
+    __publicField(this, "a");
+    this.i = id;
+    this.a = a;
+  }
+};
+var SerovalObjectNode = class {
+  constructor(id, d) {
+    __publicField(this, "t", 8 /* Object */);
+    __publicField(this, "i");
+    __publicField(this, "d");
+    this.i = id;
+    this.d = d;
+  }
+};
+var SerovalNullConstructorNode = class {
+  constructor(id, d) {
+    __publicField(this, "t", 9 /* NullConstructor */);
+    __publicField(this, "i");
+    __publicField(this, "d");
+    this.i = id;
+    this.d = d;
+  }
+};
+var SerovalPromiseNode = class {
+  constructor(id, n) {
+    __publicField(this, "t", 10 /* Promise */);
+    __publicField(this, "i");
+    __publicField(this, "n");
+    this.i = id;
+    this.n = n;
+  }
+};
+var SerovalErrorNode = class {
+  constructor(id, c, m, d) {
+    __publicField(this, "t", 11 /* Error */);
+    __publicField(this, "i");
+    __publicField(this, "c");
+    __publicField(this, "m");
+    __publicField(this, "d");
+    this.i = id;
+    this.c = c;
+    this.m = m;
+    this.d = d;
+  }
+};
+var SerovalAggregateErrorNode = class {
+  constructor(id, m, d, n) {
+    __publicField(this, "t", 12 /* AggregateError */);
+    __publicField(this, "i");
+    __publicField(this, "m");
+    __publicField(this, "d");
+    __publicField(this, "n");
+    this.i = id;
+    this.m = m;
+    this.d = d;
+    this.n = n;
+  }
+};
+var SerovalIterableNode = class {
+  constructor(id, d, a) {
+    __publicField(this, "t", 13 /* Iterable */);
+    __publicField(this, "i");
+    __publicField(this, "d");
+    __publicField(this, "a");
+    this.i = id;
+    this.d = d;
+    this.a = a;
+  }
+};
+
 // 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
-  };
-}
+var TRUE_NODE = new SerovalPrimitiveNode("!0");
+var FALSE_NODE = new SerovalPrimitiveNode("!1");
+var UNDEFINED_NODE = new SerovalPrimitiveNode("void 0");
+var NULL_NODE = new SerovalPrimitiveNode(null);
+var NEG_ZERO_NODE = new SerovalPrimitiveNode("-0");
+var INFINITY_NODE = new SerovalPrimitiveNode("1/0");
+var NEG_INFINITY_NODE = new SerovalPrimitiveNode("-1/0");
 
 // src/tree/shared.ts
 function getErrorConstructor(error) {
@@ -575,17 +662,7 @@ var AsyncParser = class {
     return nodes;
   }
   async generateArrayNode(id, current) {
-    return {
-      t: 7 /* Array */,
-      i: id,
-      a: await this.generateNodeList(current),
-      s: void 0,
-      l: void 0,
-      m: void 0,
-      c: void 0,
-      d: void 0,
-      n: void 0
-    };
+    return new SerovalArrayNode(id, await this.generateNodeList(current));
   }
   async generateMapNode(id, current) {
     assert(this.ctx.features & 16 /* Map */, 'Unsupported type "Map"');
@@ -611,17 +688,7 @@ var AsyncParser = class {
       keyNodes[nodeSize + i] = await this.parse(deferredKey[i]);
       valueNodes[nodeSize + i] = await this.parse(deferredValue[i]);
     }
-    return {
-      t: 6 /* Map */,
-      i: id,
-      a: void 0,
-      s: void 0,
-      l: void 0,
-      m: void 0,
-      c: void 0,
-      d: { k: keyNodes, v: valueNodes, s: len },
-      n: void 0
-    };
+    return new SerovalMapNode(id, new SerovalMapRecordNode(keyNodes, valueNodes, len));
   }
   async generateSetNode(id, current) {
     assert(this.ctx.features & 256 /* Set */, 'Unsupported type "Set"');
@@ -640,17 +707,7 @@ var AsyncParser = class {
     for (let i = 0; i < deferredSize; i++) {
       nodes[nodeSize + i] = await this.parse(deferred[i]);
     }
-    return {
-      t: 5 /* Set */,
-      i: id,
-      a: nodes,
-      s: void 0,
-      l: void 0,
-      m: void 0,
-      c: void 0,
-      d: void 0,
-      n: void 0
-    };
+    return new SerovalSetNode(id, nodes);
   }
   async generateProperties(properties) {
     const keys = Object.keys(properties);
@@ -678,42 +735,21 @@ var AsyncParser = class {
       keyNodes[nodesSize + i] = deferredKeys[i];
       valueNodes[nodesSize + i] = await this.parse(deferredValues[i]);
     }
-    return {
-      k: keyNodes,
-      v: valueNodes,
-      s: size
-    };
+    return new SerovalObjectRecordNode(keyNodes, valueNodes, size);
   }
   async generateIterableNode(id, current) {
     assert(this.ctx.features & 512 /* SymbolIterator */, 'Unsupported type "Iterable"');
     const options = getIterableOptions(current);
-    return {
-      t: 13 /* Iterable */,
-      i: id,
-      s: void 0,
-      l: void 0,
-      m: void 0,
-      c: void 0,
+    return new SerovalIterableNode(
+      id,
       // Parse options first before the items
-      d: options ? await this.generateProperties(options) : void 0,
-      a: await this.generateNodeList(Array.from(current)),
-      n: void 0
-    };
+      options ? await this.generateProperties(options) : void 0,
+      await this.generateNodeList(Array.from(current))
+    );
   }
   async generatePromiseNode(id, current) {
     assert(this.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 this.parse(value)
-    }));
+    return current.then(async (value) => new SerovalPromiseNode(id, await this.parse(value)));
   }
   async generateObjectNode(id, current, empty) {
     if (Symbol.iterator in current) {
@@ -722,47 +758,26 @@ var AsyncParser = class {
     if ("then" in current && typeof current.then === "function") {
       return this.generatePromiseNode(id, current);
     }
-    return {
-      t: empty ? 9 /* NullConstructor */ : 8 /* Object */,
-      i: id,
-      s: void 0,
-      l: void 0,
-      m: void 0,
-      c: void 0,
-      d: await this.generateProperties(current),
-      a: void 0,
-      n: void 0
-    };
+    const properties = await this.generateProperties(current);
+    if (empty) {
+      return new SerovalNullConstructorNode(id, properties);
+    }
+    return new SerovalObjectNode(id, properties);
   }
   async generateAggregateErrorNode(id, current) {
     const options = getErrorOptions(current);
     const optionsNode = options ? await this.generateProperties(options) : void 0;
-    return {
-      t: 12 /* AggregateError */,
-      i: id,
-      a: void 0,
-      s: void 0,
-      l: void 0,
-      m: current.message,
-      c: void 0,
-      d: optionsNode,
-      n: await this.parse(current.errors)
-    };
+    return new SerovalAggregateErrorNode(
+      id,
+      current.message,
+      optionsNode,
+      await this.parse(current.errors)
+    );
   }
   async generateErrorNode(id, current) {
     const options = getErrorOptions(current);
     const optionsNode = options ? await this.generateProperties(options) : void 0;
-    return {
-      t: 11 /* Error */,
-      i: id,
-      a: void 0,
-      s: void 0,
-      l: void 0,
-      m: current.message,
-      c: getErrorConstructor(current),
-      d: optionsNode,
-      n: void 0
-    };
+    return new SerovalErrorNode(id, getErrorConstructor(current), current.message, optionsNode);
   }
   async parse(current) {
     switch (typeof current) {
@@ -771,36 +786,37 @@ var AsyncParser = class {
       case "undefined":
         return UNDEFINED_NODE;
       case "string":
-        return createPrimitiveNode(quote(current));
+        return new SerovalPrimitiveNode(quote(current));
       case "number":
         if (Object.is(current, -0)) {
           return NEG_ZERO_NODE;
         }
         if (Object.is(current, Infinity)) {
-          return createPrimitiveNode("1/0");
+          return INFINITY_NODE;
         }
         if (Object.is(current, -Infinity)) {
-          return createPrimitiveNode("-1/0");
+          return NEG_INFINITY_NODE;
         }
-        return createPrimitiveNode(current);
+        return new SerovalPrimitiveNode(current);
       case "bigint":
-        return createBigIntNode(this.ctx, current);
+        assert(this.ctx.features & 8 /* BigInt */, 'Unsupported type "BigInt"');
+        return new SerovalBigIntNode(current);
       case "object": {
         if (!current) {
           return NULL_NODE;
         }
         const id = createRef(this.ctx, current, true);
         if (this.ctx.markedRefs[id]) {
-          return createReferenceNode(id);
+          return new SerovalReferenceNode(id);
         }
         if (Array.isArray(current)) {
           return this.generateArrayNode(id, current);
         }
         switch (current.constructor) {
           case Date:
-            return createDateNode(id, current);
+            return new SerovalDateNode(id, current);
           case RegExp:
-            return createRegExpNode(id, current);
+            return new SerovalRegExpNode(id, current);
           case Promise:
             return this.generatePromiseNode(id, current);
           case Int8Array:
@@ -812,10 +828,15 @@ var AsyncParser = class {
           case Uint8ClampedArray:
           case Float32Array:
           case Float64Array:
-            return createTypedArrayNode(this.ctx, id, current);
+            assert(this.ctx.features & 1024 /* TypedArray */, `Unsupported value type "${current.constructor.name}"`);
+            return new SerovalTypedArrayNode(id, current);
           case BigInt64Array:
           case BigUint64Array:
-            return createBigIntTypedArrayNode(this.ctx, id, current);
+            assert(
+              this.ctx.features & 2048 /* BigIntTypedArray */,
+              `Unsupported value type "${current.constructor.name}"`
+            );
+            return new SerovalBigIntTypedArrayNode(id, current);
           case Map:
             return this.generateMapNode(id, current);
           case Set:
@@ -1278,17 +1299,7 @@ var SyncParser = class {
     return nodes;
   }
   generateArrayNode(id, current) {
-    return {
-      t: 7 /* Array */,
-      i: id,
-      a: this.generateNodeList(current),
-      s: void 0,
-      l: void 0,
-      m: void 0,
-      c: void 0,
-      d: void 0,
-      n: void 0
-    };
+    return new SerovalArrayNode(id, this.generateNodeList(current));
   }
   generateMapNode(id, current) {
     assert(this.ctx.features & 16 /* Map */, 'Unsupported type "Map"');
@@ -1314,17 +1325,7 @@ var SyncParser = class {
       keyNodes[nodeSize + i] = this.parse(deferredKey[i]);
       valueNodes[nodeSize + i] = this.parse(deferredValue[i]);
     }
-    return {
-      t: 6 /* Map */,
-      i: id,
-      a: void 0,
-      s: void 0,
-      l: void 0,
-      m: void 0,
-      c: void 0,
-      d: { k: keyNodes, v: valueNodes, s: len },
-      n: void 0
-    };
+    return new SerovalMapNode(id, new SerovalMapRecordNode(keyNodes, valueNodes, len));
   }
   generateSetNode(id, current) {
     assert(this.ctx.features & 256 /* Set */, 'Unsupported type "Set"');
@@ -1343,17 +1344,7 @@ var SyncParser = class {
     for (let i = 0; i < deferredSize; i++) {
       nodes[nodeSize + i] = this.parse(deferred[i]);
     }
-    return {
-      t: 5 /* Set */,
-      i: id,
-      a: nodes,
-      s: void 0,
-      l: void 0,
-      m: void 0,
-      c: void 0,
-      d: void 0,
-      n: void 0
-    };
+    return new SerovalSetNode(id, nodes);
   }
   generateProperties(properties) {
     const keys = Object.keys(properties);
@@ -1390,64 +1381,36 @@ var SyncParser = class {
   generateIterableNode(id, current) {
     assert(this.ctx.features & 512 /* SymbolIterator */, 'Unsupported type "Iterable"');
     const options = getIterableOptions(current);
-    return {
-      t: 13 /* Iterable */,
-      i: id,
-      s: void 0,
-      l: void 0,
-      m: void 0,
-      c: void 0,
+    return new SerovalIterableNode(
+      id,
       // Parse options first before the items
-      d: options ? this.generateProperties(options) : void 0,
-      a: this.generateNodeList(Array.from(current)),
-      n: void 0
-    };
+      options ? this.generateProperties(options) : void 0,
+      this.generateNodeList(Array.from(current))
+    );
   }
   generateObjectNode(id, current, empty) {
     if (Symbol.iterator in current) {
       return this.generateIterableNode(id, current);
     }
-    return {
-      t: empty ? 9 /* NullConstructor */ : 8 /* Object */,
-      i: id,
-      s: void 0,
-      l: void 0,
-      m: void 0,
-      c: void 0,
-      d: this.generateProperties(current),
-      a: void 0,
-      n: void 0
-    };
+    if (empty) {
+      return new SerovalNullConstructorNode(id, this.generateProperties(current));
+    }
+    return new SerovalObjectNode(id, this.generateProperties(current));
   }
   generateAggregateErrorNode(id, current) {
     const options = getErrorOptions(current);
     const optionsNode = options ? this.generateProperties(options) : void 0;
-    return {
-      t: 12 /* AggregateError */,
-      i: id,
-      a: void 0,
-      s: void 0,
-      l: void 0,
-      m: current.message,
-      c: void 0,
-      d: optionsNode,
-      n: this.parse(current.errors)
-    };
+    return new SerovalAggregateErrorNode(
+      id,
+      current.message,
+      optionsNode,
+      this.parse(current.errors)
+    );
   }
   generateErrorNode(id, current) {
     const options = getErrorOptions(current);
     const optionsNode = options ? this.generateProperties(options) : void 0;
-    return {
-      t: 11 /* Error */,
-      i: id,
-      a: void 0,
-      s: void 0,
-      l: void 0,
-      m: current.message,
-      c: getErrorConstructor(current),
-      d: optionsNode,
-      n: void 0
-    };
+    return new SerovalErrorNode(id, getErrorConstructor(current), current.message, optionsNode);
   }
   parse(current) {
     switch (typeof current) {
@@ -1456,36 +1419,37 @@ var SyncParser = class {
       case "undefined":
         return UNDEFINED_NODE;
       case "string":
-        return createPrimitiveNode(quote(current));
+        return new SerovalPrimitiveNode(quote(current));
       case "number":
         if (Object.is(current, -0)) {
           return NEG_ZERO_NODE;
         }
         if (Object.is(current, Infinity)) {
-          return createPrimitiveNode("1/0");
+          return INFINITY_NODE;
         }
         if (Object.is(current, -Infinity)) {
-          return createPrimitiveNode("-1/0");
+          return NEG_INFINITY_NODE;
         }
-        return createPrimitiveNode(current);
+        return new SerovalPrimitiveNode(current);
       case "bigint":
-        return createBigIntNode(this.ctx, current);
+        assert(this.ctx.features & 8 /* BigInt */, 'Unsupported type "BigInt"');
+        return new SerovalBigIntNode(current);
       case "object": {
         if (!current) {
           return NULL_NODE;
         }
         const id = createRef(this.ctx, current, true);
         if (this.ctx.markedRefs[id]) {
-          return createReferenceNode(id);
+          return new SerovalReferenceNode(id);
         }
         if (Array.isArray(current)) {
           return this.generateArrayNode(id, current);
         }
         switch (current.constructor) {
           case Date:
-            return createDateNode(id, current);
+            return new SerovalDateNode(id, current);
           case RegExp:
-            return createRegExpNode(id, current);
+            return new SerovalRegExpNode(id, current);
           case Int8Array:
           case Int16Array:
           case Int32Array:
@@ -1495,10 +1459,15 @@ var SyncParser = class {
           case Uint8ClampedArray:
           case Float32Array:
           case Float64Array:
-            return createTypedArrayNode(this.ctx, id, current);
+            assert(this.ctx.features & 1024 /* TypedArray */, `Unsupported value type "${current.constructor.name}"`);
+            return new SerovalTypedArrayNode(id, current);
           case BigInt64Array:
           case BigUint64Array:
-            return createBigIntTypedArrayNode(this.ctx, id, current);
+            assert(
+              this.ctx.features & 2048 /* BigIntTypedArray */,
+              `Unsupported value type "${current.constructor.name}"`
+            );
+            return new SerovalBigIntTypedArrayNode(id, current);
           case Map:
             return this.generateMapNode(id, current);
           case Set:
@@ -1571,16 +1540,16 @@ function finalize(ctx, rootID, isObject, result) {
   return result;
 }
 function serialize(source, options) {
-  const ctx = createParserContext(options);
+  const ctx = new ParserContext(options);
   const [tree, rootID, isObject] = parseSync(ctx, source);
-  const serial = createSerializationContext(ctx);
+  const serial = new SerializationContext(ctx);
   const result = serializeTree(serial, tree);
   return finalize(serial, rootID, isObject, result);
 }
 async function serializeAsync(source, options) {
-  const ctx = createParserContext(options);
+  const ctx = new ParserContext(options);
   const [tree, rootID, isObject] = await parseAsync(ctx, source);
-  const serial = createSerializationContext(ctx);
+  const serial = new SerializationContext(ctx);
   const result = serializeTree(serial, tree);
   return finalize(serial, rootID, isObject, result);
 }
@@ -1588,7 +1557,7 @@ function deserialize(source) {
   return (0, eval)(source);
 }
 function toJSON(source, options) {
-  const ctx = createParserContext(options);
+  const ctx = new ParserContext(options);
   const [tree, root, isObject] = parseSync(ctx, source);
   return JSON.stringify([
     tree,
@@ -1599,7 +1568,7 @@ function toJSON(source, options) {
   ]);
 }
 async function toJSONAsync(source, options) {
-  const ctx = createParserContext(options);
+  const ctx = new ParserContext(options);
   const [tree, root, isObject] = await parseAsync(ctx, source);
   return JSON.stringify([
     tree,
@@ -1611,7 +1580,7 @@ async function toJSONAsync(source, options) {
 }
 function compileJSON(source) {
   const parsed = JSON.parse(source);
-  const serial = createSerializationContext({
+  const serial = new SerializationContext({
     features: parsed[3],
     markedRefs: parsed[4]
   });