@common.js/serialize-error 11.0.3 → 13.0.2

package/README.md

@@ -2,4 +2,4 @@
 
 The [serialize-error](https://www.npmjs.com/package/serialize-error) package exported as CommonJS modules.
 
-Exported from [serialize-error@11.0.3](https://www.npmjs.com/package/serialize-error/v/11.0.3) using https://github.com/etienne-martin/common.js.
+Exported from [serialize-error@13.0.1](https://www.npmjs.com/package/serialize-error/v/13.0.1) using https://github.com/etienne-martin/common.js.

package/error-constructors.d.ts

@@ -1,8 +1,44 @@
+export type ErrorFactory<T extends Error> = () => T;
+
 /**
-Map of error constructors to recreate from the serialize `name` property. If the name is not found in this map, the errors will be deserialized as simple `Error` instances.
+Let `serialize-error` know about your custom error constructors so that when `{name: 'MyCustomError', message: 'It broke'}` is found, it uses the right error constructor. If "MyCustomError" isn't found in the global list of known constructors, it defaults to the base `Error` error constructor.
 
-Warning: Only simple and standard error constructors are supported, like `new MyCustomError(name)`. If your error constructor *requires* a second parameter or does not accept a string as first parameter, adding it to this map *will* break the deserialization.
-*/
-declare const errorConstructors: Map<string, ErrorConstructor>;
+@param constructor - The error constructor to add.
+@param factory - Factory function to create instances. Optional if the constructor can be called without arguments, required if it needs arguments.
+
+@example
+```
+// Constructor that works without arguments - factory is optional
+addKnownErrorConstructor(Error);
+addKnownErrorConstructor(TypeError);
+
+class MyError extends Error {
+	name = 'MyError';
 
-export default errorConstructors;
+	constructor(message?: string) {
+		super(message);
+		this.name = 'MyError';
+	}
+}
+addKnownErrorConstructor(MyError);
+
+// Constructor that requires arguments - factory is required
+class CustomError extends Error {
+	name = 'CustomError';
+
+	constructor(message: string, options: {code: string}) {
+		super(message);
+		this.code = options.code;
+	}
+}
+addKnownErrorConstructor(CustomError, () => new CustomError('', {code: 'ERR_UNICORN'}));
+```
+*/
+export function addKnownErrorConstructor<T extends Error>(
+	constructor: new () => T,
+	factory?: ErrorFactory<T>
+): void;
+export function addKnownErrorConstructor<T extends Error>(
+	constructor: new (...arguments_: [any, ...any[]]) => T,
+	factory: ErrorFactory<T>
+): void;

package/error-constructors.js

@@ -2,20 +2,40 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return _default;
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    errorConstructors: function() {
+        return errorConstructors;
+    },
+    errorFactories: function() {
+        return errorFactories;
+    },
+    addKnownErrorConstructor: function() {
+        return addKnownErrorConstructor;
     }
 });
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
 var list = [
     // Native ES errors https://262.ecma-international.org/12.0/#sec-well-known-intrinsic-objects
+    Error,
     EvalError,
     RangeError,
     ReferenceError,
     SyntaxError,
     TypeError,
     URIError,
+    AggregateError,
     // Built-in errors
     globalThis.DOMException,
     // Node-specific errors
@@ -30,4 +50,44 @@ var list = [
     ];
 });
 var errorConstructors = new Map(list);
-var _default = errorConstructors;
+var errorFactories = new Map();
+function addKnownErrorConstructor(constructor, factory) {
+    var instance;
+    var resolvedName;
+    if (factory) {
+        if (typeof factory !== "function") {
+            throw new TypeError("Factory must be a function");
+        }
+        // Verify factory can execute without throwing
+        try {
+            instance = factory();
+        } catch (error) {
+            throw new Error("Factory is not compatible", {
+                cause: error
+            });
+        }
+        if (!_instanceof(instance, constructor)) {
+            throw new TypeError("Factory must return an instance of the constructor");
+        }
+        resolvedName = instance.name;
+    } else {
+        try {
+            instance = new constructor();
+        } catch (error1) {
+            throw new Error('Constructor "'.concat(constructor.name, '" is not compatible'), {
+                cause: error1
+            });
+        }
+        resolvedName = instance.name;
+    }
+    if (!resolvedName || typeof resolvedName !== "string") {
+        throw new TypeError('Error instances must have a non-empty string "name" property');
+    }
+    if (errorConstructors.has(resolvedName)) {
+        throw new Error('Error constructor "'.concat(resolvedName, '" is already known'));
+    }
+    errorConstructors.set(resolvedName, constructor);
+    if (factory) {
+        errorFactories.set(resolvedName, factory);
+    }
+}

package/index.d.ts

@@ -1,6 +1,7 @@
-import {Primitive, JsonObject} from 'type-fest';
+import {type JsonObject} from 'type-fest';
 
-export {default as errorConstructors} from './error-constructors.js';
+export {addKnownErrorConstructor, type ErrorFactory} from './error-constructors.js';
+export {default as NonError} from 'non-error';
 
 export type ErrorObject = {
 	name?: string;
@@ -19,7 +20,7 @@ export type ErrorLike = {
 	code?: string;
 };
 
-export interface Options {
+export type Options = {
 	/**
 	The maximum depth of properties to preserve when serializing/deserializing.
 
@@ -33,10 +34,10 @@ export interface Options {
 	error.one = {two: {three: {}}};
 
 	console.log(serializeError(error, {maxDepth: 1}));
-	//=> {name: 'Error', message: '…', one: {}}
+	//=> {name: 'Error', message: '🦄', one: {}}
 
 	console.log(serializeError(error, {maxDepth: 2}));
-	//=> {name: 'Error', message: '…', one: { two: {}}}
+	//=> {name: 'Error', message: '🦄', one: { two: {}}}
 	```
 	*/
 	readonly maxDepth?: number;
@@ -47,13 +48,15 @@ export interface Options {
 	@default true
 	*/
 	readonly useToJSON?: boolean;
-}
+};
 
 /**
 Serialize an `Error` object into a plain object.
 
-- Non-error values are passed through.
 - Custom properties are preserved.
+- Non-enumerable properties are kept non-enumerable (name, message, stack).
+- Enumerable properties are kept enumerable (all properties besides the non-enumerable ones).
+- Primitive values (including `null`, `undefined`, strings, numbers, etc.) and functions are wrapped in a `NonError` error and serialized.
 - Buffer properties are replaced with `[object Buffer]`.
 - Circular references are handled.
 - If the input object has a `.toJSON()` method, then it's called instead of serializing the object's properties.
@@ -105,9 +108,7 @@ serializeError(error);
 // => {horn: 'x', name, message, stack}
 ```
 */
-export function serializeError<ErrorType>(error: ErrorType, options?: Options): ErrorType extends Primitive
-	? ErrorType
-	: ErrorObject;
+export function serializeError(error: unknown, options?: Options): ErrorObject;
 
 /**
 Deserialize a plain object or any value into an `Error` object.
@@ -157,7 +158,7 @@ isErrorLike({
 isErrorLike(new Error('🦄'));
 //=> true
 
-isErrorLike(serializeError(new Error('🦄'));
+isErrorLike(serializeError(new Error('🦄')));
 //=> true
 
 isErrorLike({

package/index.js

@@ -9,9 +9,6 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    NonError: function() {
-        return NonError;
-    },
     serializeError: function() {
         return serializeError;
     },
@@ -21,107 +18,15 @@ _export(exports, {
     isErrorLike: function() {
         return isErrorLike;
     },
-    errorConstructors: function() {
-        return _errorConstructorsJs.default;
+    addKnownErrorConstructor: function() {
+        return _errorConstructorsJs.addKnownErrorConstructor;
+    },
+    NonError: function() {
+        return _nonError.default;
     }
 });
-var _errorConstructorsJs = /*#__PURE__*/ _interopRequireDefault(require("./error-constructors.js"));
-function _arrayLikeToArray(arr, len) {
-    if (len == null || len > arr.length) len = arr.length;
-    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
-    return arr2;
-}
-function _arrayWithHoles(arr) {
-    if (Array.isArray(arr)) return arr;
-}
-function _arrayWithoutHoles(arr) {
-    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
-}
-function _assertThisInitialized(self) {
-    if (self === void 0) {
-        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-    }
-    return self;
-}
-function _classCallCheck(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-        throw new TypeError("Cannot call a class as a function");
-    }
-}
-function isNativeReflectConstruct() {
-    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
-    if (Reflect.construct.sham) return false;
-    if (typeof Proxy === "function") return true;
-    try {
-        Date.prototype.toString.call(Reflect.construct(Date, [], function() {}));
-        return true;
-    } catch (e) {
-        return false;
-    }
-}
-function _construct(Parent, args, Class) {
-    if (isNativeReflectConstruct()) {
-        _construct = Reflect.construct;
-    } else {
-        _construct = function _construct(Parent, args, Class) {
-            var a = [
-                null
-            ];
-            a.push.apply(a, args);
-            var Constructor = Function.bind.apply(Parent, a);
-            var instance = new Constructor();
-            if (Class) _setPrototypeOf(instance, Class.prototype);
-            return instance;
-        };
-    }
-    return _construct.apply(null, arguments);
-}
-function _defineProperties(target, props) {
-    for(var i = 0; i < props.length; i++){
-        var descriptor = props[i];
-        descriptor.enumerable = descriptor.enumerable || false;
-        descriptor.configurable = true;
-        if ("value" in descriptor) descriptor.writable = true;
-        Object.defineProperty(target, descriptor.key, descriptor);
-    }
-}
-function _createClass(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-    if (staticProps) _defineProperties(Constructor, staticProps);
-    return Constructor;
-}
-function _defineProperty(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _getPrototypeOf(o) {
-    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
-        return o.__proto__ || Object.getPrototypeOf(o);
-    };
-    return _getPrototypeOf(o);
-}
-function _inherits(subClass, superClass) {
-    if (typeof superClass !== "function" && superClass !== null) {
-        throw new TypeError("Super expression must either be null or a function");
-    }
-    subClass.prototype = Object.create(superClass && superClass.prototype, {
-        constructor: {
-            value: subClass,
-            writable: true,
-            configurable: true
-        }
-    });
-    if (superClass) _setPrototypeOf(subClass, superClass);
-}
+var _nonError = /*#__PURE__*/ _interopRequireDefault(require("non-error"));
+var _errorConstructorsJs = require("./error-constructors.js");
 function _instanceof(left, right) {
     if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
         return !!right[Symbol.hasInstance](left);
@@ -134,149 +39,11 @@ function _interopRequireDefault(obj) {
         default: obj
     };
 }
-function _isNativeFunction(fn) {
-    return Function.toString.call(fn).indexOf("[native code]") !== -1;
-}
-function _iterableToArray(iter) {
-    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
-}
-function _iterableToArrayLimit(arr, i) {
-    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
-    if (_i == null) return;
-    var _arr = [];
-    var _n = true;
-    var _d = false;
-    var _s, _e;
-    try {
-        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
-            _arr.push(_s.value);
-            if (i && _arr.length === i) break;
-        }
-    } catch (err) {
-        _d = true;
-        _e = err;
-    } finally{
-        try {
-            if (!_n && _i["return"] != null) _i["return"]();
-        } finally{
-            if (_d) throw _e;
-        }
-    }
-    return _arr;
-}
-function _nonIterableRest() {
-    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-function _nonIterableSpread() {
-    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-function _possibleConstructorReturn(self, call) {
-    if (call && (_typeof(call) === "object" || typeof call === "function")) {
-        return call;
-    }
-    return _assertThisInitialized(self);
-}
-function _setPrototypeOf(o, p) {
-    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
-        o.__proto__ = p;
-        return o;
-    };
-    return _setPrototypeOf(o, p);
-}
-function _slicedToArray(arr, i) {
-    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
-}
-function _toConsumableArray(arr) {
-    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
-}
 var _typeof = function(obj) {
     "@swc/helpers - typeof";
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 };
-function _unsupportedIterableToArray(o, minLen) {
-    if (!o) return;
-    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-    var n = Object.prototype.toString.call(o).slice(8, -1);
-    if (n === "Object" && o.constructor) n = o.constructor.name;
-    if (n === "Map" || n === "Set") return Array.from(n);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
-}
-function _wrapNativeSuper(Class) {
-    var _cache = typeof Map === "function" ? new Map() : undefined;
-    _wrapNativeSuper = function _wrapNativeSuper(Class) {
-        if (Class === null || !_isNativeFunction(Class)) return Class;
-        if (typeof Class !== "function") {
-            throw new TypeError("Super expression must either be null or a function");
-        }
-        if (typeof _cache !== "undefined") {
-            if (_cache.has(Class)) return _cache.get(Class);
-            _cache.set(Class, Wrapper);
-        }
-        function Wrapper() {
-            return _construct(Class, arguments, _getPrototypeOf(this).constructor);
-        }
-        Wrapper.prototype = Object.create(Class.prototype, {
-            constructor: {
-                value: Wrapper,
-                enumerable: false,
-                writable: true,
-                configurable: true
-            }
-        });
-        return _setPrototypeOf(Wrapper, Class);
-    };
-    return _wrapNativeSuper(Class);
-}
-function _isNativeReflectConstruct() {
-    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
-    if (Reflect.construct.sham) return false;
-    if (typeof Proxy === "function") return true;
-    try {
-        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
-        return true;
-    } catch (e) {
-        return false;
-    }
-}
-function _createSuper(Derived) {
-    var hasNativeReflectConstruct = _isNativeReflectConstruct();
-    return function _createSuperInternal() {
-        var Super = _getPrototypeOf(Derived), result;
-        if (hasNativeReflectConstruct) {
-            var NewTarget = _getPrototypeOf(this).constructor;
-            result = Reflect.construct(Super, arguments, NewTarget);
-        } else {
-            result = Super.apply(this, arguments);
-        }
-        return _possibleConstructorReturn(this, result);
-    };
-}
-var NonError = /*#__PURE__*/ function(Error1) {
-    "use strict";
-    _inherits(NonError, Error1);
-    var _super = _createSuper(NonError);
-    function NonError(message) {
-        _classCallCheck(this, NonError);
-        var _this;
-        _this = _super.call(this, NonError._prepareSuperMessage(message));
-        _defineProperty(_assertThisInitialized(_this), "name", "NonError");
-        return _this;
-    }
-    _createClass(NonError, null, [
-        {
-            key: "_prepareSuperMessage",
-            value: function _prepareSuperMessage(message) {
-                try {
-                    return JSON.stringify(message);
-                } catch (e) {
-                    return String(message);
-                }
-            }
-        }
-    ]);
-    return NonError;
-}(_wrapNativeSuper(Error));
-var commonProperties = [
+var errorProperties = [
     {
         property: "name",
         enumerable: false
@@ -296,6 +63,10 @@ var commonProperties = [
     {
         property: "cause",
         enumerable: false
+    },
+    {
+        property: "errors",
+        enumerable: false
     }, 
 ];
 var toJsonWasCalled = new WeakSet();
@@ -305,55 +76,70 @@ var toJSON = function(from) {
     toJsonWasCalled.delete(from);
     return json;
 };
-var ref;
-var getErrorConstructor = function(name) {
-    return (ref = _errorConstructorsJs.default.get(name)) !== null && ref !== void 0 ? ref : Error;
+var newError = function(name) {
+    if (name === "NonError") {
+        return new _nonError.default();
+    }
+    var factory = _errorConstructorsJs.errorFactories.get(name);
+    if (factory) {
+        return factory();
+    }
+    var ref;
+    var ErrorConstructor = (ref = _errorConstructorsJs.errorConstructors.get(name)) !== null && ref !== void 0 ? ref : Error;
+    return ErrorConstructor === AggregateError ? new ErrorConstructor([]) : new ErrorConstructor();
 };
-// eslint-disable-next-line complexity
 var destroyCircular = function(param) {
     var from = param.from, seen = param.seen, to = param.to, forceEnumerable = param.forceEnumerable, maxDepth = param.maxDepth, depth = param.depth, useToJSON = param.useToJSON, serialize = param.serialize;
     if (!to) {
         if (Array.isArray(from)) {
             to = [];
         } else if (!serialize && isErrorLike(from)) {
-            var _$Error = getErrorConstructor(from.name);
-            to = new _$Error();
+            to = newError(from.name);
         } else {
             to = {};
         }
     }
-    seen.push(from);
+    seen.add(from);
     if (depth >= maxDepth) {
+        seen.delete(from);
         return to;
     }
     if (useToJSON && typeof from.toJSON === "function" && !toJsonWasCalled.has(from)) {
+        seen.delete(from);
         return toJSON(from);
     }
     var continueDestroyCircular = function(value) {
         return destroyCircular({
             from: value,
-            seen: _toConsumableArray(seen),
+            seen: seen,
             forceEnumerable: forceEnumerable,
             maxDepth: maxDepth,
-            depth: depth,
+            depth: depth + 1,
             useToJSON: useToJSON,
             serialize: serialize
         });
     };
     var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
     try {
-        for(var _iterator = Object.entries(from)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-            var _value = _slicedToArray(_step.value, 2), key = _value[0], value = _value[1];
+        for(var _iterator = Object.keys(from)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var key = _step.value;
+            var value = from[key];
             if (value && _instanceof(value, Uint8Array) && value.constructor.name === "Buffer") {
-                to[key] = "[object Buffer]";
+                to[key] = serialize ? "[object Buffer]" : value;
                 continue;
             }
-            // TODO: Use `stream.isReadable()` when targeting Node.js 18.
             if (value !== null && typeof value === "object" && typeof value.pipe === "function") {
-                to[key] = "[object Stream]";
+                to[key] = serialize ? "[object Stream]" : value;
                 continue;
             }
             if (typeof value === "function") {
+                if (!serialize) {
+                    to[key] = value;
+                }
+                continue;
+            }
+            if (serialize && (typeof value === "undefined" ? "undefined" : _typeof(value)) === "bigint") {
+                to[key] = "".concat(value, "n");
                 continue;
             }
             if (!value || typeof value !== "object") {
@@ -363,9 +149,8 @@ var destroyCircular = function(param) {
                 } catch (e) {}
                 continue;
             }
-            if (!seen.includes(from[key])) {
-                depth++;
-                to[key] = continueDestroyCircular(from[key]);
+            if (!seen.has(value)) {
+                to[key] = continueDestroyCircular(value);
                 continue;
             }
             to[key] = "[Circular]";
@@ -384,33 +169,46 @@ var destroyCircular = function(param) {
             }
         }
     }
-    var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
-    try {
-        for(var _iterator1 = commonProperties[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
-            var _value1 = _step1.value, property = _value1.property, enumerable = _value1.enumerable;
-            if (typeof from[property] !== "undefined" && from[property] !== null) {
+    if (serialize || _instanceof(to, Error)) {
+        var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+        try {
+            for(var _iterator1 = errorProperties[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                var _value = _step1.value, property = _value.property, enumerable = _value.enumerable;
+                var value1 = from[property];
+                if (value1 === undefined || value1 === null) {
+                    continue;
+                }
+                var descriptor = Object.getOwnPropertyDescriptor(to, property);
+                if ((descriptor === null || descriptor === void 0 ? void 0 : descriptor.configurable) === false) {
+                    continue;
+                }
+                var processedValue = value1;
+                if (typeof value1 === "object") {
+                    processedValue = seen.has(value1) ? "[Circular]" : continueDestroyCircular(value1);
+                }
                 Object.defineProperty(to, property, {
-                    value: isErrorLike(from[property]) ? continueDestroyCircular(from[property]) : from[property],
-                    enumerable: forceEnumerable ? true : enumerable,
+                    value: processedValue,
+                    enumerable: forceEnumerable || enumerable,
                     configurable: true,
                     writable: true
                 });
             }
-        }
-    } catch (err) {
-        _didIteratorError1 = true;
-        _iteratorError1 = err;
-    } finally{
-        try {
-            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
-                _iterator1.return();
-            }
+        } catch (err) {
+            _didIteratorError1 = true;
+            _iteratorError1 = err;
         } finally{
-            if (_didIteratorError1) {
-                throw _iteratorError1;
+            try {
+                if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                    _iterator1.return();
+                }
+            } finally{
+                if (_didIteratorError1) {
+                    throw _iteratorError1;
+                }
             }
         }
     }
+    seen.delete(from);
     return to;
 };
 function serializeError(value) {
@@ -419,7 +217,7 @@ function serializeError(value) {
     if (typeof value === "object" && value !== null) {
         return destroyCircular({
             from: value,
-            seen: [],
+            seen: new Set(),
             forceEnumerable: true,
             maxDepth: maxDepth,
             depth: 0,
@@ -429,11 +227,17 @@ function serializeError(value) {
     }
     // People sometimes throw things besides Error objects…
     if (typeof value === "function") {
-        // `JSON.stringify()` discards functions. We do too, unless a function is thrown directly.
-        // We intentionally use `||` because `.name` is an empty string for anonymous functions.
-        return "[Function: ".concat(value.name || "anonymous", "]");
+        value = "<Function>";
     }
-    return value;
+    return destroyCircular({
+        from: new _nonError.default(value),
+        seen: new Set(),
+        forceEnumerable: true,
+        maxDepth: maxDepth,
+        depth: 0,
+        useToJSON: useToJSON,
+        serialize: true
+    });
 }
 function deserializeError(value) {
     var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
@@ -442,21 +246,21 @@ function deserializeError(value) {
         return value;
     }
     if (isMinimumViableSerializedError(value)) {
-        var _$Error = getErrorConstructor(value.name);
         return destroyCircular({
             from: value,
-            seen: [],
-            to: new _$Error(),
+            seen: new Set(),
+            to: newError(value.name),
             maxDepth: maxDepth,
             depth: 0,
             serialize: false
         });
     }
-    return new NonError(value);
+    return new _nonError.default(value);
 }
 function isErrorLike(value) {
-    return Boolean(value) && typeof value === "object" && "name" in value && "message" in value && "stack" in value;
+    return Boolean(value) && typeof value === "object" && typeof value.name === "string" && typeof value.message === "string" && typeof value.stack === "string";
 }
+// Used as a weak check for immediately-passed objects, whereas `isErrorLike` is used for nested values to avoid bad detection
 function isMinimumViableSerializedError(value) {
-    return Boolean(value) && typeof value === "object" && "message" in value && !Array.isArray(value);
+    return Boolean(value) && typeof value === "object" && typeof value.message === "string" && !Array.isArray(value);
 }

package/package.json

@@ -1,18 +1,21 @@
 {
   "name": "@common.js/serialize-error",
-  "version": "11.0.3",
+  "version": "13.0.2",
   "description": "serialize-error package exported as CommonJS modules",
   "license": "MIT",
   "repository": "etienne-martin/common.js",
   "funding": "https://github.com/sponsors/sindresorhus",
   "type": "commonjs",
+  "exports": {
+    "types": "./index.d.ts",
+    "default": "./index.js"
+  },
   "sideEffects": false,
   "engines": {
-    "node": ">=14.16"
+    "node": ">=20"
   },
   "scripts": {
-    "//test": "xo && ava && tsd",
-    "test": "ava && tsd"
+    "test": "xo && ava && tsd"
   },
   "files": [
     "index.js",
@@ -21,13 +24,24 @@
     "error-constructors.d.ts"
   ],
   "dependencies": {
-    "type-fest": "^2.12.2"
+    "non-error": "npm:@common.js/non-error@0.1.1",
+    "type-fest": "npm:@common.js/type-fest@5.8.1"
   },
   "devDependencies": {
-    "ava": "^4.2.0",
-    "tsd": "^0.20.0",
-    "xo": "^0.48.0"
+    "ava": "^6.4.1",
+    "expect-type": "^1.3.0",
+    "tsd": "^0.33.0",
+    "xo": "^1.2.3"
   },
   "homepage": "https://github.com/etienne-martin/common.js#readme",
-  "main": "./index.js"
+  "commonjs": {
+    "source": {
+      "name": "serialize-error",
+      "version": "13.0.1"
+    },
+    "transformRevision": 1,
+    "buildKey": "8530708b32db000b7585a8fd006d421d5cf41245a3048b674c3cc5c820e6b372"
+  },
+  "main": "./index.js",
+  "types": "./index.d.ts"
 }