typeson-registry 14.2.0 → 14.2.2

package/dist/index.js

@@ -1312,8 +1312,51 @@ const primitiveObjects = {
         test (x) {
             return toStringTag(x) === 'Number' && typeof x === 'object';
         },
-        replace: Number, // convert to primitive number
-        revive (n) { return new Number(n); } // Revive to an objectified number
+        // `_encapsulate`'s nested-replace guard (`_stateObj.replaced`)
+        //   means a bare `NaN`/`Infinity`/`-Infinity`/`-0` returned here
+        //   would skip the sentinel treatment the bare `nan`/`infinity`/
+        //   `negativeZero` type specs normally give those values (since
+        //   we're already inside this spec's own `replace()`) -- JSON
+        //   can't represent them, so they'd otherwise silently become
+        //   `null` (or lose their sign, for `-0`). Encode them the same
+        //   way those specs do, directly, rather than relying on that
+        //   nested pass.
+        replace (o) {
+            const n = o.valueOf();
+            if (Number.isNaN(n)) {
+                return 'NaN';
+            }
+            if (n === Infinity) {
+                return 'Infinity';
+            }
+            if (n === -Infinity) {
+                return '-Infinity';
+            }
+            if (Object.is(n, -0)) {
+                // A plain `0` here would be indistinguishable from a
+                //   genuine positive `0` once round-tripped through JSON
+                //   (which can't represent the sign), so this needs its
+                //   own sentinel too, same as the others above.
+                return '-0';
+            }
+            return n;
+        },
+        // Revive to an objectified number
+        revive (n) {
+            if (n === 'NaN') {
+                return new Number(NaN);
+            }
+            if (n === 'Infinity') {
+                return new Number(Infinity);
+            }
+            if (n === '-Infinity') {
+                return new Number(-Infinity);
+            }
+            if (n === '-0') {
+                return new Number(-0);
+            }
+            return new Number(n);
+        }
     }
 };
 
@@ -2071,8 +2114,25 @@ const structuredCloningThrowing = expObj.concat({
                     // HTML-SPECIFIC
                     'Event',
                     // Also in Node `worker_threads` (currently experimental)
-                    'MessageChannel'
+                    'MessageChannel',
+                    'MessagePort'
                 ].includes(stringTag) ||
+                // Node's native `worker_threads` `MessageChannel`/
+                //   `MessagePort` don't set `Symbol.toStringTag` per
+                //      https://github.com/nodejs/node/issues/65527
+                //   (verified directly:
+                //   `{}.toString.call(new MessageChannel())` is
+                //   `"[object Object]"`, and `.port1`'s is
+                //   `"[object EventTarget]"`, its own base class), so the
+                //   `stringTag` check above can't catch them there; a real
+                //   browser's `MessagePort`/`MessageChannel` already match
+                //   via `stringTag` (or, for `MessagePort`, would need its
+                //   own `stringTag` entry if ever seen failing to match) --
+                //   this is purely a fallback for environments (like Node)
+                //   that don't set the tag.
+                (val && val.constructor && [
+                    'MessageChannel', 'MessagePort'
+                ].includes(val.constructor.name)) ||
                 // 1. `IsDetachedBuffer` (a process not called within the
                 //      ECMAScript spec)
                 ([