typeson-registry 13.3.0 → 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}
    */
@@ -2703,6 +2781,92 @@
     }
   };
 
+  /**
+   * @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 */
 
   /**
@@ -2853,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
@@ -2938,7 +3103,10 @@
   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
@@ -3067,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;
@@ -3110,6 +3280,7 @@
   exports.unescapeKeyPathComponent = unescapeKeyPathComponent;
   exports.universal = universal;
   exports.userObject = userObject;
+  exports.videoframe = videoframe;
   exports.webtransporterror = webtransporterror;
 
 }));