typeson-registry 13.2.1 → 14.0.0

package/dist/index.umd.cjs

@@ -1769,6 +1769,84 @@
     };
   }
 
+  /* globals EncodedAudioChunk -- Polyfills */
+
+  /**
+   * @type {import('typeson').TypeSpecSet}
+   */
+  var encodedaudiochunk = {
+    encodedaudiochunk: {
+      test: function test(x) {
+        return toStringTag(x) === 'EncodedAudioChunk';
+      },
+      replace: function replace(chunk) {
+        var type = chunk.type,
+          timestamp = chunk.timestamp,
+          duration = chunk.duration,
+          byteLength = chunk.byteLength;
+        var data = new ArrayBuffer(byteLength);
+        chunk.copyTo(data);
+        return {
+          type: type,
+          timestamp: timestamp,
+          duration: duration,
+          data: data
+        };
+      },
+      revive: function revive(_ref) {
+        var type = _ref.type,
+          timestamp = _ref.timestamp,
+          duration = _ref.duration,
+          data = _ref.data;
+        return new EncodedAudioChunk({
+          type: type,
+          timestamp: timestamp,
+          duration: duration,
+          data: new Uint8Array(data)
+        });
+      }
+    }
+  };
+
+  /* globals EncodedVideoChunk -- Polyfills */
+
+  /**
+   * @type {import('typeson').TypeSpecSet}
+   */
+  var encodedvideochunk = {
+    encodedvideochunk: {
+      test: function test(x) {
+        return toStringTag(x) === 'EncodedVideoChunk';
+      },
+      replace: function replace(chunk) {
+        var type = chunk.type,
+          timestamp = chunk.timestamp,
+          duration = chunk.duration,
+          byteLength = chunk.byteLength;
+        var data = new ArrayBuffer(byteLength);
+        chunk.copyTo(data);
+        return {
+          type: type,
+          timestamp: timestamp,
+          duration: duration,
+          data: data
+        };
+      },
+      revive: function revive(_ref) {
+        var type = _ref.type,
+          timestamp = _ref.timestamp,
+          duration = _ref.duration,
+          data = _ref.data;
+        return new EncodedVideoChunk({
+          type: type,
+          timestamp: timestamp,
+          duration: duration,
+          data: new Uint8Array(data)
+        });
+      }
+    }
+  };
+
   /**
    * @type {import('typeson').TypeSpecSet}
    */
@@ -2401,6 +2479,41 @@
     }
   };
 
+  /**
+   * @type {import('typeson').TypeSpecSet}
+   */
+  var quotaexceedederror = {
+    quotaexceedederror: {
+      test: function test(x) {
+        return toStringTag(x) === 'QuotaExceededError';
+      },
+      replace: function replace(_ref) {
+        var message = _ref.message,
+          quota = _ref.quota,
+          requested = _ref.requested;
+        return {
+          message: message,
+          quota: quota,
+          requested: requested
+        };
+      },
+      revive: function revive(_ref2) {
+        var message = _ref2.message,
+          quota = _ref2.quota,
+          requested = _ref2.requested;
+        /** @type {{quota?: number, requested?: number}} */
+        var options = {};
+        if (quota !== null && quota !== undefined) {
+          options.quota = quota;
+        }
+        if (requested !== null && requested !== undefined) {
+          options.requested = requested;
+        }
+        return new QuotaExceededError(message, options);
+      }
+    }
+  };
+
   /**
    * @type {import('typeson').TypeSpecSet}
    */
@@ -2668,6 +2781,127 @@
     }
   };
 
+  /**
+   * @type {import('typeson').TypeSpecSet}
+   */
+  var videoframe = {
+    videoframe: {
+      test: function test(x) {
+        return toStringTag(x) === 'VideoFrame';
+      },
+      replaceAsync: function replaceAsync(frame) {
+        return new TypesonPromise(/*#__PURE__*/function () {
+          var _ref = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(resolve, reject) {
+            var format, codedWidth, codedHeight, timestamp, duration, visibleRect, displayWidth, displayHeight, colorSpace, data, _t;
+            return _regenerator().w(function (_context) {
+              while (1) switch (_context.p = _context.n) {
+                case 0:
+                  _context.p = 0;
+                  format = frame.format, codedWidth = frame.codedWidth, codedHeight = frame.codedHeight, timestamp = frame.timestamp, duration = frame.duration, visibleRect = frame.visibleRect, displayWidth = frame.displayWidth, displayHeight = frame.displayHeight, colorSpace = frame.colorSpace;
+                  data = new ArrayBuffer(frame.allocationSize());
+                  _context.n = 1;
+                  return frame.copyTo(data);
+                case 1:
+                  resolve({
+                    format: format,
+                    codedWidth: codedWidth,
+                    codedHeight: codedHeight,
+                    timestamp: timestamp,
+                    duration: duration,
+                    visibleRect: {
+                      x: visibleRect.x,
+                      y: visibleRect.y,
+                      width: visibleRect.width,
+                      height: visibleRect.height
+                    },
+                    displayWidth: displayWidth,
+                    displayHeight: displayHeight,
+                    colorSpace: {
+                      primaries: colorSpace.primaries,
+                      transfer: colorSpace.transfer,
+                      matrix: colorSpace.matrix,
+                      fullRange: colorSpace.fullRange
+                    },
+                    data: data
+                  });
+                  /* c8 ignore next 3 -- How to simulate? */
+                  _context.n = 3;
+                  break;
+                case 2:
+                  _context.p = 2;
+                  _t = _context.v;
+                  reject(_t);
+                case 3:
+                  return _context.a(2);
+              }
+            }, _callee, null, [[0, 2]]);
+          }));
+          return function (_x, _x2) {
+            return _ref.apply(this, arguments);
+          };
+        }());
+      },
+      revive: function revive(_ref2) {
+        var format = _ref2.format,
+          codedWidth = _ref2.codedWidth,
+          codedHeight = _ref2.codedHeight,
+          timestamp = _ref2.timestamp,
+          duration = _ref2.duration,
+          visibleRect = _ref2.visibleRect,
+          displayWidth = _ref2.displayWidth,
+          displayHeight = _ref2.displayHeight,
+          colorSpace = _ref2.colorSpace,
+          data = _ref2.data;
+        return new VideoFrame(new Uint8Array(data), {
+          format: format,
+          codedWidth: codedWidth,
+          codedHeight: codedHeight,
+          timestamp: timestamp,
+          duration: duration,
+          visibleRect: visibleRect,
+          displayWidth: displayWidth,
+          displayHeight: displayHeight,
+          colorSpace: colorSpace
+        });
+      }
+    }
+  };
+
+  /* globals WebTransportError -- Newer API */
+
+  /**
+   * @type {import('typeson').TypeSpecSet}
+   */
+  var webtransporterror = {
+    webtransporterror: {
+      test: function test(x) {
+        return toStringTag(x) === 'WebTransportError';
+      },
+      // Note that we can't support the `source` property (defaults
+      //   to `stream` instead of `session`)
+      replace: function replace(_ref) {
+        var message = _ref.message,
+          streamErrorCode = _ref.streamErrorCode;
+        return {
+          message: message,
+          streamErrorCode: streamErrorCode
+        };
+      },
+      revive: function revive(_ref2) {
+        var message = _ref2.message,
+          streamErrorCode = _ref2.streamErrorCode;
+        // TS lib still models the older two-argument
+        //   `(message, options)` form; browsers implement a single
+        //   `init` object (which also carries `message`).
+        // @ts-expect-error - More recent API
+        return new WebTransportError({
+          message: message,
+          streamErrorCode: streamErrorCode
+        });
+      }
+    }
+  };
+
   /**
    * @type {import('typeson').Preset}
    */
@@ -2783,8 +3017,9 @@
   DOM types. Therefore, only types that are not included in the structured clone
   algorithm need to be registered, which is:
 
-  * Error
-  * Specific Errors like SyntaxError, TypeError, etc.
+  * Error (now included in structured cloning)
+  * Specific Errors like SyntaxError, TypeError, etc. (now included in structured
+  *   cloning)
   * Any custom type you want to send across window- or worker boundraries
 
   This preset will only include the Error types and you can register your
@@ -2862,11 +3097,16 @@
   typeof crypto !== 'undefined' ? cryptokey : [], /* c8 ignore next */
   typeof BigInt !== 'undefined' ? [bigint, bigintObject] : [], /* c8 ignore next */
   typeof DOMException !== 'undefined' ? domexception : [], /* c8 ignore next */
+  typeof QuotaExceededError !== 'undefined' ? quotaexceedederror : [], /* c8 ignore next */
+  typeof WebTransportError !== 'undefined' ? webtransporterror : [], /* c8 ignore next */
   typeof DOMRect !== 'undefined' ? domrect : [], /* c8 ignore next */
   typeof DOMPoint !== 'undefined' ? dompoint : [], /* c8 ignore next */
   typeof DOMQuad !== 'undefined' ? domquad : [], /* c8 ignore next */
   typeof DOMMatrix !== 'undefined' ? dommatrix : [], /* c8 ignore next */
-  typeof AudioData !== 'undefined' ? audiodata : []);
+  typeof AudioData !== 'undefined' ? audiodata : [], /* c8 ignore next */
+  typeof EncodedAudioChunk !== 'undefined' ? encodedaudiochunk : [], /* c8 ignore next */
+  typeof EncodedVideoChunk !== 'undefined' ? encodedvideochunk : [], /* c8 ignore next */
+  typeof VideoFrame !== 'undefined' ? videoframe : []);
 
   /**
    * @param {BufferSource} buffer
@@ -2995,6 +3235,8 @@
   exports.dompoint = dompoint;
   exports.domquad = domquad;
   exports.domrect = domrect;
+  exports.encodedaudiochunk = encodedaudiochunk;
+  exports.encodedvideochunk = encodedvideochunk;
   exports.error = error;
   exports.errors = errors;
   exports.escapeKeyPathComponent = escapeKeyPathComponent;
@@ -3019,6 +3261,7 @@
   exports.postmessage = postmessage;
   exports.primitiveObjects = primitiveObjects;
   exports.promise = promise;
+  exports.quotaexceedederror = quotaexceedederror;
   exports.regexp = regexp;
   exports.resurrectable = resurrectable;
   exports.set = set;
@@ -3037,6 +3280,8 @@
   exports.unescapeKeyPathComponent = unescapeKeyPathComponent;
   exports.universal = universal;
   exports.userObject = userObject;
+  exports.videoframe = videoframe;
+  exports.webtransporterror = webtransporterror;
 
 }));
 //# sourceMappingURL=index.umd.cjs.map