typeson-registry 2.0.0 → 3.0.0

package/dist/index.js

@@ -119,7 +119,7 @@ const bigintObject = {
         test (x) {
             return typeof x === 'object' && hasConstructorOf(x, BigInt);
         },
-        replace (n) { return String(n); },
+        replace: String,
         revive (s) {
             // Filed this to avoid error: https://github.com/eslint/eslint/issues/11810
             // eslint-disable-next-line no-new-object
@@ -135,8 +135,8 @@ const bigint = {
         test (x) {
             return typeof x === 'bigint';
         },
-        replace (n) { return String(n); },
-        revive (s) { return BigInt(s); }
+        replace: String,
+        revive: BigInt
     }
 };
 
@@ -408,31 +408,34 @@ const error = {
     }
 };
 
-/* eslint-env browser, node */
-
-/* c8 ignore next */
-const _global$2 = typeof self === 'undefined' ? global : self;
+/* globals InternalError */
 
 const errors = {};
-// Comprises all built-in errors.
+
+// JS standard
 [
-    'TypeError',
-    'RangeError',
-    'SyntaxError',
-    'ReferenceError',
-    'EvalError',
-    'URIError',
-    'InternalError' // non-standard
-].forEach((errName) => {
-    const Cnstrctr = _global$2[errName];
-    if (Cnstrctr) {
-        errors[errName.toLowerCase()] = {
-            test (x) { return hasConstructorOf(x, Cnstrctr); },
-            replace (e) { return e.message; },
-            revive (message) { return new Cnstrctr(message); }
-        };
-    }
-});
+    TypeError, RangeError, SyntaxError, ReferenceError, EvalError, URIError
+].forEach((error) => create$2(error));
+
+/* c8 ignore next 2 */
+// @ts-ignore Non-standard
+typeof InternalError === 'function' && create$2(InternalError);
+
+/**
+ * Comprises all built-in errors.
+ * @param {
+ *   TypeError|RangeError|SyntaxError|ReferenceError|EvalError|URIError|
+ *   InternalError
+ * } Ctor
+ * @returns {void}
+ */
+function create$2 (Ctor) {
+    errors[Ctor.name.toLowerCase()] = {
+        test (x) { return hasConstructorOf(x, Ctor); },
+        replace (e) { return e.message; },
+        revive (message) { return new Ctor(message); }
+    };
+}
 
 /* globals XMLHttpRequest, File, FileReader */
 
@@ -710,7 +713,7 @@ const primitiveObjects = {
         test (x) {
             return toStringTag(x) === 'String' && typeof x === 'object';
         },
-        replace (s) { return String(s); }, // convert to primitive string
+        replace: String, // convert to primitive string
         revive (s) { return new String(s); } // Revive to an objectified string
     },
     // Boolean Object (not primitive boolean which need no type spec)
@@ -719,7 +722,7 @@ const primitiveObjects = {
             return toStringTag(x) === 'Boolean' &&
                 typeof x === 'object';
         },
-        replace (b) { return Boolean(b); }, // convert to primitive boolean
+        replace: Boolean, // convert to primitive boolean
         revive (b) {
             // Revive to an objectified Boolean
             return new Boolean(b);
@@ -730,7 +733,7 @@ const primitiveObjects = {
         test (x) {
             return toStringTag(x) === 'Number' && typeof x === 'object';
         },
-        replace (n) { return Number(n); }, // convert to primitive number
+        replace: Number, // convert to primitive number
         revive (n) { return new Number(n); } // Revive to an objectified number
     }
 };
@@ -786,30 +789,20 @@ const set = {
 
 /* eslint-env browser, node */
 
-/* c8 ignore next */
-const _global$1 = typeof self === 'undefined' ? global : self;
-
 // Support all kinds of typed arrays (views of ArrayBuffers)
 const typedArraysSocketIO = {};
-[
-    'Int8Array',
-    'Uint8Array',
-    'Uint8ClampedArray',
-    'Int16Array',
-    'Uint16Array',
-    'Int32Array',
-    'Uint32Array',
-    'Float32Array',
-    'Float64Array'
-].forEach(function (typeName) {
-    const arrType = typeName;
-    const TypedArray = _global$1[typeName];
-    /* c8 ignore next 3 */
-    if (!TypedArray) {
-        return;
-    }
+
+/**
+ * @param {
+ *   Int8Array|Uint8Array|Uint8ClampedArray|Int16Array|Uint16Array|Int32Array|
+ *   Uint32Array|Float32Array|Float64Array
+ * } TypedArray
+ * @returns {void}
+ */
+function create$1 (TypedArray) {
+    const typeName = TypedArray.name;
     typedArraysSocketIO[typeName.toLowerCase()] = {
-        test (x) { return toStringTag(x) === arrType; },
+        test (x) { return toStringTag(x) === typeName; },
         replace (a) {
             return (a.byteOffset === 0 &&
                 a.byteLength === a.buffer.byteLength
@@ -832,33 +825,40 @@ const typedArraysSocketIO = {};
                 : buf;
         }
     };
-});
+}
 
-/* eslint-env browser, node */
+if (typeof Int8Array === 'function') {
+    // Those constructors are added in ES6 as a group.
+    // If we have Int8Array, we can assume the rest also exists.
+
+    [
+        Int8Array,
+        Uint8Array,
+        Uint8ClampedArray,
+        Int16Array,
+        Uint16Array,
+        Int32Array,
+        Uint32Array,
+        Float32Array,
+        Float64Array
+    ].forEach((TypedArray) => create$1(TypedArray));
+}
 
-/* c8 ignore next */
-const _global = typeof self === 'undefined' ? global : self;
+/* eslint-env browser, node */
 
 const typedArrays = {};
-[
-    'Int8Array',
-    'Uint8Array',
-    'Uint8ClampedArray',
-    'Int16Array',
-    'Uint16Array',
-    'Int32Array',
-    'Uint32Array',
-    'Float32Array',
-    'Float64Array'
-].forEach(function (typeName) {
-    const arrType = typeName;
-    const TypedArray = _global[arrType];
-    /* c8 ignore next 3 */
-    if (!TypedArray) {
-        return;
-    }
+
+/**
+ * @param {
+ *   Int8Array|Uint8Array|Uint8ClampedArray|Int16Array|Uint16Array|Int32Array|
+ *   Uint32Array|Float32Array|Float64Array
+ * } TypedArray
+ * @returns {void}
+ */
+function create (TypedArray) {
+    const typeName = TypedArray.name;
     typedArrays[typeName.toLowerCase()] = {
-        test (x) { return toStringTag(x) === arrType; },
+        test (x) { return toStringTag(x) === typeName; },
         replace ({buffer, byteOffset, length: l}, stateObj) {
             if (!stateObj.buffers) {
                 stateObj.buffers = [];
@@ -889,7 +889,23 @@ const typedArrays = {};
             return new TypedArray(buffer, byteOffset, len);
         }
     };
-});
+}
+
+if (typeof Int8Array === 'function') {
+    // Those constructors are added in ES6 as a group.
+    // If we have Int8Array, we can assume the rest also exists.
+    [
+        Int8Array,
+        Uint8Array,
+        Uint8ClampedArray,
+        Int16Array,
+        Uint16Array,
+        Int32Array,
+        Uint32Array,
+        Float32Array,
+        Float64Array
+    ].forEach((TypedArray) => create(TypedArray));
+}
 
 // This does not preserve `undefined` in sparse arrays; see the `undef`