resurrect-esm 2.0.4 → 2.0.6

package/.vscode/settings.json

@@ -1,6 +1,7 @@
 {
     "cSpell.words": [
         "kybernetikos",
+        "minifiers",
         "registrator",
         "skeeto"
     ]

package/README.md

@@ -5,11 +5,11 @@ An ES6 module port of ResurrectTS.
 > [!CAUTION]
 > This is *not* just a naive `exports.foo` => `export {foo}` rewrite. Some API changes have been made:
 >
-> * All of the "irrelevant" methods of Resurrect have been renamed using private names (that are then mangled further by esbuild).
-> * ResurrectError is now a top-level export, instead of living inside a Resurrect object.
-> * NamespaceResolver is now a top-level export, instead of living inside the Resurrect static constructor namespace.
-> * NamespaceResolver now has a new method, `getConstructor(name: string)`, which should return the constructor function to generate the object (it will not be called directly, so the parameters are irrelevant).
-> * The bug found in skeeto/resurrect-js#11 has been fixed.
+> * All of the "irrelevant" methods of Resurrect have been renamed using private `#names`.
+> * `ResurrectError` is now a top-level export, instead of living inside a `Resurrect` object.
+> * `NamespaceResolver` is now a top-level export, instead of living inside the `Resurrect` static constructor namespace.
+> * `NamespaceResolver` now has a new method, `getConstructor(name: string)`, which should return the constructor function to generate the object (the constructor itself will not be called directly, so the parameters are irrelevant).
+> * The bug found in [skeeto/resurrect-js#11][issue11] has been fixed.
 
 ResurrectJS preserves object behavior (prototypes) and reference
 circularity with a special JSON encoding. Unlike flat JSON, it can
@@ -62,30 +62,13 @@ const date = necromancer.resurrect(json);
 Options are provided to the constructor as an object with these
 properties:
 
- * *prefix* (`"#"`): A prefix string used for temporary properties added
-     to objects during serialization and deserialization. It is
-     important that you don't use any properties beginning with this
-     string. This option must be consistent between both serialization
-     and deserialization.
+ * *prefix* (default: `"#"`): A prefix string used for temporary properties added to objects during serialization and deserialization. It is important that you don't use any properties beginning with this string. This option also must be the same between both serialization and deserialization.
 
- * *cleanup* (`false`): Perform full property cleanup after both
-     serialization and deserialization using the `delete` operator.
-     This may cause performance penalties (i.e. breaking hidden
-     classes in V8) on objects that ResurrectJS touches, so enable
-     with care.
+ * *cleanup* (default: false): Perform full property cleanup after both serialization and deserialization using the `delete` operator. This may cause performance penalties (i.e. breaking hidden classes and forcing de-optimization) on objects that Resurrect touches, so enable with care.
 
- * *revive* (`true`): Restore behavior (`__proto__`) to objects that
-     have been resurrected. If this is set to false during
-     serialization, resurrection information will not be encoded. You
-     still get circularity and Date support.
+ * *revive* (default: true): Restore behavior (`__proto__`) to objects that have been resurrected. If this is set to false during serialization, resurrection information will not be encoded. You still get circularity and Date/HTML/URL support.
 
- * *resolver* (`NamespaceResolver`): Converts between a name
-     and a prototype. Create a custom resolver if your constructors
-     are not stored in global variables. The resolver has two methods:
-     getName(object) and getPrototype(string).
-
-> [!CAUTION]
-> If you're using ES6 modules for your custom classes, you MUST use a custom resolver since module scope is not global scope!
+ * *resolver* (`NamespaceResolver`, default undefined): Converts between a name and a prototype. Create a custom resolver if your constructors are not stored in global variables. The resolver has three methods: `getName(object)`, `getConstructor(string)`, and `getPrototype(string)`.
 
 For example,
 
@@ -99,66 +82,51 @@ const necromancer = new Resurrect({
 
 ## Methods
 
-Only two methods are significant when using ResurrectJS.
+There are only two public methods:
 
- * `.stringify(object[, replacer[, space]])`: Serializes an arbitrary
-     object or value into a string. The `replacer` and `space`
-     arguments are the same as [JSON.stringify][json-mdn], being
-     passed through to this method. Note that the replacer will *not*
-     be called for ResurrectJS's intrusive keys.
+ * `.stringify(object[, replacer[, space]])`: Serializes an arbitrary object or value into a string. The `replacer` and `space` arguments are the same as [JSON.stringify][json-mdn], being passed through to this method. Note that the replacer will *not* be called for Resurrect's intrusive keys (i.e. the ones that are created using the `.prefix` option).
 
- * `.resurrect(string)`: Deserializes an object stored in a string by
-     a previous call to `.stringify()`. Circularity and, optionally,
-     behavior (prototype chain) will be restored.
+ * `.resurrect(string)`: Deserializes an object stored in a string by a previous call to `.stringify()`. Circularity and, optionally, behavior (prototype chain) will be restored.
 
 ## Restrictions
 
-With the default resolver, all constructors must be named and stored
-in the global variable under that name. This is required so that the
-prototypes can be looked up and reconnected at resurrection time.
+With the default resolver, all constructors must be named and stored in the global scope under that name. This is required so that the prototypes can be looked up and reconnected at resurrection time.
+
+> [!CAUTION]
+> If you're using ES6 modules for your custom classes, you MUST use a custom resolver since module scope is not global scope!
 
-The wrapper objects Boolean, String, and Number will be
-unwrapped. This means extra properties added to these objects will not
-be preserved.
+The wrapper objects Boolean, String, and Number will be unwrapped. This means extra properties added to these objects will not be preserved.
 
-Functions cannot ever be serialized. Resurrect will throw an error if
-a function is found when traversing a data structure, rather than just silently dropping the property or replacing it with `null` like JSON.stringify does.
+Functions cannot ever be serialized. Resurrect will throw an error if a function is found when traversing a data structure, rather than just silently dropping the property or replacing it with `null` like JSON.stringify does.
 
 ### Custom Resolvers
 
-There is a caveat with the provided resolver, NamespaceResolver: all
-constructors *must* be explicitly named when defined. For example, see
-the Foo constructor in this example,
+New in 2.0.5: the NamespaceResolver will now use the name on the namespace object of whatever you pass in instead of the `.name` of the object's constructor. This is to better support minifiers that rename the class and produce code output similar to this:
 
 ```ts
-import { Resurrect, NamespaceResolver } from "resurrect-esm";
-const namespace = {
-    Foo: class Foo {
-        constructor() {
-            this.bar = true;
-            Foo.bax(this);
-        }
-        static bax(obj) {
-
-        }
+import { Resurrect as r, NamespaceResolver as e } from "resurrect-esm";
+var c = class d {
+    constructor() {
+        this.bar = true;
+        d.bax(this);
+    }
+    static bax(obj) {
+
     }
 };
-const necromancer = new Resurrect({
-    resolver: new NamespaceResolver(namespace)
+var n = {
+    Foo: c, // <== Always uses name given here
+};
+var a = new r({
+    resolver: new e(n)
 });
 ```
 
-The constructor been assigned to the Foo property *and* the function
-itself has been given a matching name. This is how the resolver will
-find the name of the constructor in the namespace when given the
-constructor. Keep in mind that using this form will bind the variable
-Foo to the surrounding function within the body of Foo.
-
-If you're using a bundler, you **must** enable the "keep names" option
-for at least the classes that will be stringified, so that Resurrect.js can get the correct `.name` from the constructor functions. (For esbuild, the option is `--keep-names`.)
+In the serializer above, the "name" given to the class will always be "Foo", even though the `.name` of the constructor is "c" and might be different on the next build.
 
 ## See Also
 
 * [HydrateJS](https://github.com/nanodeath/HydrateJS)
 
 [json-mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify
+[issue11]: https://github.com/skeeto/resurrect-js/issues/11

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "resurrect-esm",
-    "version": "2.0.4",
+    "version": "2.0.6",
     "type": "module",
     "description": "ResurrectJS preserves object behavior (prototypes) and reference circularity with a special JSON encoding. Unlike flat JSON, it can also properly resurrect self-referential objects, objects with shared structure, Dates, RegExps, HTMLElements, NaN, Infinity, undefined (which won't get turned into null), and any other custom object type given the proper resolver.",
     "repository": {
@@ -20,7 +20,7 @@
             "url": "https://github.com/dragoncoder047"
         }
     ],
-    "license": "UNLICENSE",
+    "license": "CC0-1.0",
     "bugs": {
         "url": "https://github.com/dragoncoder047/resurrect-esm/issues"
     },
@@ -37,6 +37,9 @@
         "build": "pnpm esbuild --sourcemap --platform=browser --target=esnext --format=esm resurrect.ts --outfile=resurrect.js",
         "test": "pnpm bun test",
         "test:watch": "pnpm test --watch",
-        "prepare": "pnpm build --minify --mangle-props=^_"
+        "prepare": "pnpm build --minify"
+    },
+    "dependencies": {
+        "lib0": "^0.2.117"
     }
 }

package/resurrect.test.ts

@@ -1,6 +1,6 @@
 import { GlobalRegistrator } from "@happy-dom/global-registrator";
 import { describe, expect, test } from "bun:test";
-import { NamespaceResolver, Resurrect, ResurrectError, ResurrectOptions } from "./resurrect";
+import { FakeNode, NamespaceResolver, Resurrect, ResurrectError, ResurrectOptions } from "./resurrect";
 
 GlobalRegistrator.register();
 
@@ -55,7 +55,7 @@ function suite(opt?: ResurrectOptions) {
     });
 
     test("serialization with DOM elements", () => {
-        const obj = new Resurrect.Node("<span id=foo><a id=1></a></span>");
+        const obj = new FakeNode("<span id=foo><a id=1></a></span>");
         const roundtripped = roundtrip(obj);
         expect(roundtripped).toBeInstanceOf(HTMLSpanElement);
         expect(roundtripped.firstChild).toBeInstanceOf(HTMLAnchorElement);
@@ -98,6 +98,16 @@ function suite(opt?: ResurrectOptions) {
             expect(roundtripped).toBeInstanceOf(Dog);
             expect(roundtripped.woof()).toEqual("wowwowwow!");
         });
+        test("revive/serialize works with minifier-renamed classes", () => {
+            class z {
+                constructor(public foo: number) { };
+            }
+            const obj = new z(1);
+            const roundtripped = roundtrip(obj, {
+                resolver: new NamespaceResolver({ Foo: z }),
+            });
+            expect(roundtripped).toBeInstanceOf(z);
+        })
         test("can't serialize anonymous classes", () => {
             const obj = new class {
                 foo: number;

package/resurrect.ts

@@ -1,203 +1,141 @@
 /**
- * # ResurrectJS
- * @version 1.0.3
- * @license Public Domain
- *
- * ResurrectJS preserves object behavior (prototypes) and reference
- * circularity with a special JSON encoding. Unlike regular JSON,
- * Date, URL, RegExp, DOM objects, and `undefined` are also properly
- * preserved.
- *
- * ## Examples
- *
- * function Foo() {}
- * Foo.prototype.greet = function() { return "hello"; };
- *
- * // Behavior is preserved:
- * const necromancer = new Resurrect();
- * const json = necromancer.stringify(new Foo());
- * const foo = necromancer.resurrect(json);
- * foo.greet();  // => "hello"
- *
- * // References to the same object are preserved:
- * json = necromancer.stringify([foo, foo]);
- * const array = necromancer.resurrect(json);
- * array[0] === array[1];  // => true
- * array[1].greet();  // => "hello"
- *
- * // Dates are restored properly
- * json = necromancer.stringify(new Date());
- * const date = necromancer.resurrect(json);
- * Object.prototype.toString.call(date);  // => "[object Date]"
- *
- * ## Options
- *
- * Options are provided to the constructor as an object with these
- * properties:
- *
- *   prefix ('#'): A prefix string used for temporary properties added
- *     to objects during serialization and deserialization. It is
- *     important that you don't use any properties beginning with this
- *     string. This option must be consistent between both
- *     serialization and deserialization.
- *
- *   revive (true): Restore behavior (__proto__) to objects that have
- *     been resurrected. If this is set to false during serialization,
- *     resurrection information will not be encoded. You still get
- *     circularity and Date/URL support.
- *
- *   resolver (Resurrect.NamespaceResolver(window)): Converts between
- *     a name and a prototype. Create a custom resolver if your
- *     constructors are not stored in global variables. The resolver
- *     has two methods: getName(object) and getPrototype(string).
- *
- * For example,
- *
- * const necromancer = new Resurrect({
- *     prefix: "__#",
- * });
- *
- * ## Caveats
- *
- *   * With the default resolver, all constructors must be named and
- *   stored in the global variable under that name. This is required
- *   so that the prototypes can be looked up and reconnected at
- *   resurrection time.
- *
- *   * The wrapper objects Boolean, String, and Number will be
- *   unwrapped. This means extra properties added to these objects
- *   will not be preserved.
- *
- *   * Functions cannot ever be serialized. Resurrect will throw an
- *   error if a function is found when traversing a data structure.
- *
+ * resurrect-esm, a fork of resurrect-ts, which is in turn a fork of resurrect.js
+ * @version 2.0.6
+ * @license CC0
  * @see http://nullprogram.com/blog/2013/03/28/
  */
 
+import { parse, stringify } from "lib0/json";
+import { keys } from "lib0/object";
+
+const getPrototypeOf = Object.getPrototypeOf;
+const getOwnPropertyNames = Object.getOwnPropertyNames;
+const create = Object.create;
+/**
+ * Portable access to the global object (window, global).
+ * Uses indirect eval.
+ * @constant
+ */
+const GLOBAL: typeof globalThis = globalThis ?? (0, eval)("this");
+
+/**
+ * Escape special regular expression characters in a string.
+ * Uses `RegExp.escape` if available, otherwise falls back to http://stackoverflow.com/a/6969486.
+ * @param {string} string
+ * @returns {string} The string escaped for exact matches.
+ */
+const escapeRegExp = RegExp.escape ?? ((string: string) => string.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"));
+
+function is(type: string) {
+    const string = `[object ${type}]`;
+    return (obj: any) => {
+        return {}.toString.call(obj) === string;
+    };
+}
+
+const isArray = is("Array") as (obj: any) => obj is any[];
+const isString = is("String") as (obj: any) => obj is string;
+const isBoolean = is("Boolean") as (obj: any) => obj is boolean;
+const isNumber = is("Number") as (obj: any) => obj is number;
+const isFunction = is("Function") as (obj: any) => obj is Function;
+const isDate = is("Date") as (obj: any) => obj is Date;
+const isURL = is("URL") as (obj: any) => obj is URL;
+const isRegExp = is("RegExp") as (obj: any) => obj is RegExp;
+const isObject = is("Object") as (obj: any) => obj is object;
+function isAtom(object: any) {
+    return !isObject(object) && !isArray(object);
+}
+function isPrimitive(object: any) {
+    return object == null ||
+        isNumber(object) ||
+        isString(object) ||
+        isBoolean(object);
+}
+
+/**
+ * Create a DOM node from HTML source; behaves like a constructor.
+ */
+export const FakeNode = class {
+    constructor(html: string) {
+        const div = document.createElement("a");
+        div.innerHTML = html;
+        return div.firstChild as HTMLElement;
+    }
+} as new (x: string) => HTMLElement;
+
+
 export class Resurrect {
-    private _table: any[] | null;
-    private _cleanups: (() => void)[] = [];
+    #table: any[] | null;
+    #cleanups: (() => void)[] = [];
     prefix: string;
     cleanup: boolean;
     revive: boolean;
-    get _refcode() { return this.prefix + "#" };
-    get _backrefcode() { return this.prefix + "=" };
-    get _protocode() { return this.prefix + "+" };
-    get _origcode() { return this.prefix + "&" };
-    get _buildcode() { return this.prefix + "@" };
-    get _valuecode() { return this.prefix + "_" };
+    get #refcode() { return this.prefix + "#" };
+    get #backrefcode() { return this.prefix + "=" };
+    get #protocode() { return this.prefix + "+" };
+    get #origcode() { return this.prefix + "&" };
+    get #buildcode() { return this.prefix + "@" };
+    get #valuecode() { return this.prefix + "_" };
     resolver: NamespaceResolver;
     constructor(opt: ResurrectOptions = {}) {
-        this._table = null;
+        this.#table = null;
         this.prefix = opt.prefix ?? "#";
         this.cleanup = opt.cleanup ?? false;
         this.revive = opt.revive ?? true;
-        this.resolver = opt.resolver ?? new NamespaceResolver(Resurrect.GLOBAL as any);
-    }
-
-    /**
-     * Portable access to the global object (window, global).
-     * Uses indirect eval.
-     * @constant
-     */
-    static readonly GLOBAL: typeof globalThis = globalThis ?? (0, eval)("this");
-
-    /**
-     * Escape special regular expression characters in a string.
-     * Uses `RegExp.escape` if available, otherwise falls back to http://stackoverflow.com/a/6969486.
-     * @param {string} string
-     * @returns {string} The string escaped for exact matches.
-     */
-    private static _escapeRegExp = RegExp.escape ?? ((string: string) => string.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"));
-
-    /**
-     * Create a DOM node from HTML source; behaves like a constructor.
-     */
-    static Node = class {
-        constructor(html: string) {
-            const div = document.createElement("a");
-            div.innerHTML = html;
-            return div.firstChild as HTMLElement;
-        }
-    } as new (x: string) => HTMLElement;
-
-    private static _is(type: string) {
-        const string = `[object ${type}]`;
-        return (obj: any) => {
-            return {}.toString.call(obj) === string;
-        };
-    }
-
-    private static _isArray = Resurrect._is("Array") as (obj: any) => obj is any[];
-    private static _isString = Resurrect._is("String") as (obj: any) => obj is string;
-    private static _isBoolean = Resurrect._is("Boolean") as (obj: any) => obj is boolean;
-    private static _isNumber = Resurrect._is("Number") as (obj: any) => obj is number;
-    private static _isFunction = Resurrect._is("Function") as (obj: any) => obj is Function;
-    private static _isDate = Resurrect._is("Date") as (obj: any) => obj is Date;
-    private static _isURL = Resurrect._is("URL") as (obj: any) => obj is URL;
-    private static _isRegExp = Resurrect._is("RegExp") as (obj: any) => obj is RegExp;
-    private static _isObject = Resurrect._is("Object") as (obj: any) => obj is object;
-    private static _isAtom(object: any) {
-        return !Resurrect._isObject(object) && !Resurrect._isArray(object);
-    }
-    private static _isPrimitive(object: any) {
-        return object == null ||
-            Resurrect._isNumber(object) ||
-            Resurrect._isString(object) ||
-            Resurrect._isBoolean(object);
+        this.resolver = opt.resolver ?? new NamespaceResolver(GLOBAL as any);
     }
 
-    private _cleanup() {
-        this._cleanups.forEach(e => e());
-        this._cleanups = [];
+    #cleanup() {
+        this.#cleanups.forEach(e => e());
+        this.#cleanups = [];
     }
 
     /**
      * Create a reference (encoding) to an object.
      */
-    private _ref(object: any) {
+    #reference(object: any) {
         return {
-            [this._backrefcode]: object === undefined ? -1 : object[this._refcode],
+            [this.#backrefcode]: object === undefined ? -1 : object[this.#refcode],
         };
     }
 
     /**
      * Lookup an object in the table by reference object.
      */
-    private _deref(ref: any) {
-        return this._table![ref[this._backrefcode]];
+    #dereference(ref: any) {
+        return this.#table![ref[this.#backrefcode]];
     }
 
     /**
      * Put a temporary identifier on an object and store it in the table.
      */
-    private _tag(object: any): number {
+    #tagObject(object: any): number {
         if (this.revive) {
             const constructor = this.resolver.getName(object);
             if (constructor) {
-                const proto = Object.getPrototypeOf(object);
+                const proto = getPrototypeOf(object);
                 if (this.resolver.getPrototype(constructor) !== proto) {
                     throw new ResurrectError("Constructor mismatch!");
                 } else {
-                    object[this._protocode] = constructor;
-                    this._cleanups.push(() => delete object[this._protocode]);
+                    object[this.#protocode] = constructor;
+                    this.#cleanups.push(() => delete object[this.#protocode]);
                 }
             }
         }
-        object[this._refcode] = this._table!.length;
-        this._cleanups.push(() => delete object[this._refcode]);
-        this._table!.push(object);
-        return object[this._refcode];
+        object[this.#refcode] = this.#table!.length;
+        this.#cleanups.push(() => delete object[this.#refcode]);
+        this.#table!.push(object);
+        return object[this.#refcode];
     }
 
     /**
      * Create a builder object (encoding) for serialization.
      * @param value The value to pass to the constructor.
      */
-    private _builder(name: string, value: any): object {
+    #createBuilderObject(name: string, value: any): object {
         return {
-            [this._buildcode]: name,
-            [this._valuecode]: value
+            [this.#buildcode]: name,
+            [this.#valuecode]: value
         };
     }
 
@@ -206,11 +144,11 @@ export class Resurrect {
      * @see http://stackoverflow.com/a/14378462
      * @see http://nullprogram.com/blog/2013/03/24/
      */
-    private _build(ref: any): any {
-        const type = this.resolver.getConstructor(ref[this._buildcode]);
+    #buildFromEncoding(ref: any): any {
+        const type = this.resolver.getConstructor(ref[this.#buildcode]);
         /* Brilliant hack by kybernetikos: */
-        const result: any = new (type.bind.apply(type, [null].concat(ref[this._valuecode]) as [any, any[]]))();
-        if (Resurrect._isPrimitive(result)) {
+        const result: any = new (type.bind.apply(type, [null].concat(ref[this.#valuecode]) as [any, any[]]))();
+        if (isPrimitive(result)) {
             return result.valueOf(); // unwrap
         } else {
             return result;
@@ -221,11 +159,11 @@ export class Resurrect {
      * Dereference or build an object or value from an encoding.
      * @method
      */
-    private _decode(ref: object): object | undefined {
-        if (this._backrefcode in ref) {
-            return this._deref(ref);
-        } else if (this._buildcode in ref) {
-            return this._build(ref);
+    #decodeReference(ref: object): object | undefined {
+        if (this.#backrefcode in ref) {
+            return this.#dereference(ref);
+        } else if (this.#buildcode in ref) {
+            return this.#buildFromEncoding(ref);
         } else {
             throw new ResurrectError("Unknown encoding.");
         }
@@ -234,8 +172,8 @@ export class Resurrect {
     /**
      * @returns {boolean} True if the provided object is tagged for serialization.
      */
-    private _isTagged(object: any): boolean {
-        return (this._refcode in object) && (object[this._refcode] != null);
+    #isTagged(object: any): boolean {
+        return (this.#refcode in object) && (object[this.#refcode] != null);
     }
 
 
@@ -243,58 +181,58 @@ export class Resurrect {
      * Visit root and all its ancestors, visiting atoms with f.
      * @returns A fresh copy of root to be serialized.
      */
-    private _visit(root: any, transform: (obj: any) => any, replacer?: (k: string, v: any) => any): any {
-        if (Resurrect._isAtom(root)) {
+    #visit(root: any, transform: (obj: any) => any, replacer?: (k: string, v: any) => any): any {
+        if (isAtom(root)) {
             return transform(root);
-        } else if (!this._isTagged(root)) {
+        } else if (!this.#isTagged(root)) {
             let copy: any = null;
-            if (Resurrect._isArray(root)) {
+            if (isArray(root)) {
                 copy = [];
-                root[this._refcode as any] = this._tag(copy);
-                this._cleanups.push(() => delete root[this._refcode as any]);
+                root[this.#refcode as any] = this.#tagObject(copy);
+                this.#cleanups.push(() => delete root[this.#refcode as any]);
                 for (let i = 0; i < root.length; i++) {
-                    copy.push(this._visit(root[i], transform, replacer));
+                    copy.push(this.#visit(root[i], transform, replacer));
                 }
             } else { /* Object */
-                copy = Object.create(Object.getPrototypeOf(root));
-                root[this._refcode as any] = this._tag(copy);
-                this._cleanups.push(() => delete root[this._refcode]);
-                for (const key of Object.getOwnPropertyNames(root)) {
+                copy = create(getPrototypeOf(root));
+                root[this.#refcode as any] = this.#tagObject(copy);
+                this.#cleanups.push(() => delete root[this.#refcode]);
+                for (const key of getOwnPropertyNames(root)) {
                     let value = root[key];
                     if (replacer && value !== undefined) {
                         // Call replacer like JSON.stringify's replacer
                         value = replacer.call(root, key, root[key]);
                         if (value === undefined) continue; // Omit from result
                     }
-                    copy[key] = this._visit(value, transform, replacer);
+                    copy[key] = this.#visit(value, transform, replacer);
                 }
             }
-            copy[this._origcode] = root;
-            return this._ref(copy);
+            copy[this.#origcode] = root;
+            return this.#reference(copy);
         } else {
-            return this._ref(root);
+            return this.#reference(root);
         }
     }
 
     /**
      * Manage special atom values, possibly returning an encoding.
      */
-    private _handleAtom(atom: any): any {
-        const Node = Resurrect.GLOBAL.Node || function () { };
-        if (Resurrect._isFunction(atom)) {
+    #encodeAtom(atom: any): any {
+        const Node = GLOBAL.Node || function () { };
+        if (isFunction(atom)) {
             throw new ResurrectError("Can't serialize functions.");
         } else if (atom instanceof Node) {
-            return this._builder("Resurrect.Node", [new XMLSerializer().serializeToString(atom)]);
-        } else if (Resurrect._isDate(atom)) {
-            return this._builder("Date", [atom.toISOString()]);
-        } else if (Resurrect._isURL(atom)) {
-            return this._builder("URL", [atom.href]);
-        } else if (Resurrect._isRegExp(atom)) {
-            return this._builder("RegExp", ("" + atom).match(/\/(.+)\/([a-z]*)/)!.slice(1));
+            return this.#createBuilderObject("Resurrect.Node", [new XMLSerializer().serializeToString(atom)]);
+        } else if (isDate(atom)) {
+            return this.#createBuilderObject("Date", [atom.toISOString()]);
+        } else if (isURL(atom)) {
+            return this.#createBuilderObject("URL", [atom.href]);
+        } else if (isRegExp(atom)) {
+            return this.#createBuilderObject("RegExp", ("" + atom).match(/\/(.+)\/([a-z]*)/)!.slice(1));
         } else if (atom === undefined) {
-            return this._ref(undefined);
-        } else if (Resurrect._isNumber(atom) && (isNaN(atom) || !isFinite(atom))) {
-            return this._builder("Number", ["" + atom]);
+            return this.#reference(undefined);
+        } else if (isNumber(atom) && (isNaN(atom) || !isFinite(atom))) {
+            return this.#createBuilderObject("Number", ["" + atom]);
         } else {
             return atom;
         }
@@ -304,8 +242,8 @@ export class Resurrect {
      * Hides intrusive keys from a user-supplied replacer.
      * @method
      */
-    private _replacerWrapper<K extends string, V, U>(replacer: (k: K, v: V) => U): (k: K, v: V) => U | V {
-        const skip = new RegExp("^" + Resurrect._escapeRegExp(this.prefix));
+    #replacerWrapper<K extends string, V, U>(replacer: (k: K, v: V) => U): (k: K, v: V) => U | V {
+        const skip = new RegExp("^" + escapeRegExp(this.prefix));
         return (k, v) => {
             if (skip.test(k)) {
                 return v;
@@ -319,37 +257,37 @@ export class Resurrect {
      * Serialize an arbitrary JavaScript object, carefully preserving it.
      */
     stringify(object: any, replacer?: any[] | ((k: string, v: any) => any), space?: string | number) {
-        if (Resurrect._isFunction(replacer)) {
-            replacer = this._replacerWrapper(replacer);
-        } else if (Resurrect._isArray(replacer)) {
+        if (isFunction(replacer)) {
+            replacer = this.#replacerWrapper(replacer);
+        } else if (isArray(replacer)) {
             const acceptKeys = replacer;
             replacer = (k, v) => acceptKeys.includes(k) ? v : undefined;
         }
-        if (Resurrect._isAtom(object)) {
-            return JSON.stringify(this._handleAtom(object), replacer, space);
+        if (isAtom(object)) {
+            return stringify(this.#encodeAtom(object), replacer, space);
         } else {
-            this._cleanups = [];
-            const table = this._table = [] as any[];
+            this.#cleanups = [];
+            const table = this.#table = [] as any[];
             try {
-                this._visit(object, this._handleAtom.bind(this), replacer);
+                this.#visit(object, this.#encodeAtom.bind(this), replacer);
             } catch (e) {
-                this._cleanup();
+                this.#cleanup();
                 throw e;
             } finally {
                 for (let i = 0; i < table.length; i++) {
                     if (this.cleanup) {
-                        delete table[i]?.[this._origcode]?.[this._refcode];
+                        delete table[i]?.[this.#origcode]?.[this.#refcode];
                     } else {
-                        const obj = table[i]?.[this._origcode];
-                        if (obj) obj[this._refcode] = null;
+                        const obj = table[i]?.[this.#origcode];
+                        if (obj) obj[this.#refcode] = null;
                     }
-                    delete table[i]?.[this._refcode];
-                    delete table[i]?.[this._origcode];
+                    delete table[i]?.[this.#refcode];
+                    delete table[i]?.[this.#origcode];
                 }
-                this._table = null;
+                this.#table = null;
             }
-            const s = JSON.stringify(table, null, space);
-            if (this.cleanup) this._cleanup();
+            const s = stringify(table, null, space);
+            if (this.cleanup) this.#cleanup();
             return s;
         }
     }
@@ -358,21 +296,21 @@ export class Resurrect {
      * Restore the `__proto__` of the given object to the proper value.
      * @method
      */
-    private _fixPrototype<T extends object>(object: T): T {
-        if (this._protocode in object) {
-            const name = (object as any)[this._protocode];
+    #fixPrototype<T extends object>(object: T): T {
+        if (this.#protocode in object) {
+            const name = (object as any)[this.#protocode];
             const prototype = this.resolver.getPrototype(name);
             if ("__proto__" in object) {
                 object.__proto__ = prototype;
                 if (this.cleanup) {
-                    delete (object as any)[this._protocode];
+                    delete (object as any)[this.#protocode];
                 }
                 return object;
             }
-            // IE
-            const copy = Object.create(prototype);
-            for (const key of Object.getOwnPropertyNames(object)) {
-                if (key !== this._protocode) {
+            // IE. Who uses this anyway...
+            const copy = create(prototype);
+            for (const key of getOwnPropertyNames(object)) {
+                if (key !== this.#protocode) {
                     copy[key] = (object as any)[key];
                 }
             }
@@ -386,34 +324,34 @@ export class Resurrect {
      */
     resurrect(string: string): any {
         let result = null;
-        const data = JSON.parse(string);
+        const data = parse(string);
         try {
-            if (Resurrect._isArray(data)) {
-                this._table = data;
+            if (isArray(data)) {
+                this.#table = data;
                 /* Restore __proto__. */
                 if (this.revive) {
-                    for (let i = 0; i < this._table.length; i++) {
-                        this._table[i] = this._fixPrototype(this._table[i]);
+                    for (let i = 0; i < this.#table.length; i++) {
+                        this.#table[i] = this.#fixPrototype(this.#table[i]);
                     }
                 }
                 /* Re-establish object references and construct atoms. */
-                for (let i = 0; i < this._table.length; i++) {
-                    const object = this._table[i];
-                    for (const key of Object.getOwnPropertyNames(object)) {
-                        if (!(Resurrect._isAtom(object[key]))) {
-                            object[key] = this._decode(object[key]);
+                for (let i = 0; i < this.#table.length; i++) {
+                    const object = this.#table[i];
+                    for (const key of getOwnPropertyNames(object)) {
+                        if (!(isAtom(object[key]))) {
+                            object[key] = this.#decodeReference(object[key]);
                         }
                     }
                 }
-                result = this._table[0];
-            } else if (Resurrect._isObject(data)) {
-                this._table = [];
-                result = this._decode(data);
+                result = this.#table[0];
+            } else if (isObject(data)) {
+                this.#table = [];
+                result = this.#decodeReference(data);
             } else {
                 result = data;
             }
         } finally {
-            this._table = null;
+            this.#table = null;
         }
         return result;
     }
@@ -483,9 +421,10 @@ export class NamespaceResolver {
      * @returns null if the constructor is `Object` or `Array`.
      */
     getName(object: object): string | null {
-        let constructor = object.constructor.name;
+        const constructorFun = object.constructor;
+        let constructor = keys(this.scope).find(realName => this.scope[realName] === constructorFun) ?? constructorFun.name;
         if (constructor == null) { // IE
-            constructor = /^\s*function\s*([A-Za-z0-9_$]*)/.exec("" + object.constructor)?.[1] ?? "";
+            constructor = /^\s*function\s*([A-Za-z0-9_$]*)/.exec("" + constructorFun)?.[1] ?? "";
         }
         if (constructor === "") {
             throw new ResurrectError("Can't serialize objects with anonymous constructors.");
@@ -499,8 +438,8 @@ export class NamespaceResolver {
      * object's constructor isn't in the namespace.
      */
     getConstructor(name: string): new (...args: any[]) => any {
-        return (name === "Resurrect.Node" ? Resurrect.Node : this.scope[name] ?? name.split(/\./).reduce((object, name) => {
+        return (name === "Resurrect.Node" ? FakeNode : this.scope[name] ?? name.split(/\./).reduce((object, name) => {
             return (object as any)[name];
-        }, Resurrect.GLOBAL)) as unknown as new () => any;
+        }, GLOBAL)) as unknown as new () => any;
     }
 }

package/tsconfig.json

@@ -14,6 +14,9 @@
         "lib": [
             "esnext",
             "dom",
+        ],
+        "types": [
+            "bun",
         ]
     }
 }