mediabunny 1.17.2 → 1.18.0

package/dist/bundles/mediabunny.cjs

@@ -53,6 +53,7 @@ var Mediabunny = (() => {
     AUDIO_CODECS: () => AUDIO_CODECS,
     AdtsInputFormat: () => AdtsInputFormat,
     AdtsOutputFormat: () => AdtsOutputFormat,
+    AttachedFile: () => AttachedFile,
     AudioBufferSink: () => AudioBufferSink,
     AudioBufferSource: () => AudioBufferSource,
     AudioSample: () => AudioSample,
@@ -526,19 +527,41 @@ var Mediabunny = (() => {
     return ISO_639_2_REGEX.test(x);
   };
   var SECOND_TO_MICROSECOND_FACTOR = 1e6 * (1 + Number.EPSILON);
-  var mergeObjectsDeeply = (a, b) => {
-    const result = { ...a };
-    for (const key in b) {
-      if (typeof a[key] === "object" && a[key] !== null && typeof b[key] === "object" && b[key] !== null) {
-        result[key] = mergeObjectsDeeply(
-          a[key],
-          b[key]
+  var mergeRequestInit = (init1, init2) => {
+    const merged = { ...init1, ...init2 };
+    if (init1.headers || init2.headers) {
+      const headers1 = init1.headers ? normalizeHeaders(init1.headers) : {};
+      const headers2 = init2.headers ? normalizeHeaders(init2.headers) : {};
+      const mergedHeaders = { ...headers1 };
+      Object.entries(headers2).forEach(([key2, value2]) => {
+        const existingKey = Object.keys(mergedHeaders).find(
+          (key1) => key1.toLowerCase() === key2.toLowerCase()
         );
-      } else {
-        result[key] = b[key];
-      }
+        if (existingKey) {
+          delete mergedHeaders[existingKey];
+        }
+        mergedHeaders[key2] = value2;
+      });
+      merged.headers = mergedHeaders;
     }
-    return result;
+    return merged;
+  };
+  var normalizeHeaders = (headers) => {
+    if (headers instanceof Headers) {
+      const result = {};
+      headers.forEach((value, key) => {
+        result[key] = value;
+      });
+      return result;
+    }
+    if (Array.isArray(headers)) {
+      const result = {};
+      headers.forEach(([key, value]) => {
+        result[key] = value;
+      });
+      return result;
+    }
+    return headers;
   };
   var retriedFetch = async (url2, requestInit, getRetryDelay) => {
     let attempts = 0;
@@ -671,6 +694,17 @@ var Mediabunny = (() => {
     }
     return btoa(string);
   };
+  var uint8ArraysAreEqual = (a, b) => {
+    if (a.length !== b.length) {
+      return false;
+    }
+    for (let i = 0; i < a.length; i++) {
+      if (a[i] !== b[i]) {
+        return false;
+      }
+    }
+    return true;
+  };
 
   // src/tags.ts
   var RichImageData = class {
@@ -678,6 +712,33 @@ var Mediabunny = (() => {
     constructor(data, mimeType) {
       this.data = data;
       this.mimeType = mimeType;
+      if (!(data instanceof Uint8Array)) {
+        throw new TypeError("data must be a Uint8Array.");
+      }
+      if (typeof mimeType !== "string") {
+        throw new TypeError("mimeType must be a string.");
+      }
+    }
+  };
+  var AttachedFile = class {
+    /** Creates a new {@link AttachedFile}. */
+    constructor(data, mimeType, name, description) {
+      this.data = data;
+      this.mimeType = mimeType;
+      this.name = name;
+      this.description = description;
+      if (!(data instanceof Uint8Array)) {
+        throw new TypeError("data must be a Uint8Array.");
+      }
+      if (mimeType !== void 0 && typeof mimeType !== "string") {
+        throw new TypeError("mimeType, when provided, must be a string.");
+      }
+      if (name !== void 0 && typeof name !== "string") {
+        throw new TypeError("name, when provided, must be a string.");
+      }
+      if (description !== void 0 && typeof description !== "string") {
+        throw new TypeError("description, when provided, must be a string.");
+      }
     }
   };
   var validateMetadataTags = (tags) => {
@@ -747,9 +808,9 @@ var Mediabunny = (() => {
         throw new TypeError("tags.raw, when provided, must be an object.");
       }
       for (const value of Object.values(tags.raw)) {
-        if (value !== null && typeof value !== "string" && !(value instanceof Uint8Array) && !(value instanceof RichImageData)) {
+        if (value !== null && typeof value !== "string" && !(value instanceof Uint8Array) && !(value instanceof RichImageData) && !(value instanceof AttachedFile)) {
           throw new TypeError(
-            "Each value in tags.raw must be a string, Uint8Array, RichImageData, or null."
+            "Each value in tags.raw must be a string, Uint8Array, RichImageData, AttachedFile, or null."
           );
         }
       }
@@ -3207,6 +3268,7 @@ var Mediabunny = (() => {
     skip(byteCount) {
       this.bufferPos += byteCount;
     }
+    /** Creates a new subslice of this slice whose byte range must be contained within this slice. */
     slice(filePos, length = this.end - filePos) {
       if (filePos < this.start || filePos + length > this.end) {
         throw new RangeError("Slicing outside of original slice.");
@@ -6667,6 +6729,25 @@ var Mediabunny = (() => {
       return 6;
     }
   };
+  var measureUnsignedBigInt = (value) => {
+    if (value < 1n << 8n) {
+      return 1;
+    } else if (value < 1n << 16n) {
+      return 2;
+    } else if (value < 1n << 24n) {
+      return 3;
+    } else if (value < 1n << 32n) {
+      return 4;
+    } else if (value < 1n << 40n) {
+      return 5;
+    } else if (value < 1n << 48n) {
+      return 6;
+    } else if (value < 1n << 56n) {
+      return 7;
+    } else {
+      return 8;
+    }
+  };
   var measureSignedInt = (value) => {
     if (value >= -(1 << 6) && value < 1 << 6) {
       return 1;
@@ -6750,6 +6831,13 @@ var Mediabunny = (() => {
       }
       this.writer.write(this.helper.subarray(0, pos));
     }
+    writeUnsignedBigInt(value, width = measureUnsignedBigInt(value)) {
+      let pos = 0;
+      for (let i = width - 1; i >= 0; i--) {
+        this.helperView.setUint8(pos++, Number(value >> BigInt(i * 8) & 0xffn));
+      }
+      this.writer.write(this.helper.subarray(0, pos));
+    }
     writeSignedInt(value, width = measureSignedInt(value)) {
       if (value < 0) {
         value += 2 ** (width * 8);
@@ -6833,6 +6921,10 @@ var Mediabunny = (() => {
           const size = data.size ?? measureUnsignedInt(data.data);
           this.writeVarInt(size);
           this.writeUnsignedInt(data.data, size);
+        } else if (typeof data.data === "bigint") {
+          const size = data.size ?? measureUnsignedBigInt(data.data);
+          this.writeVarInt(size);
+          this.writeUnsignedBigInt(data.data, size);
         } else if (typeof data.data === "string") {
           this.writeVarInt(data.data.length);
           this.writeAsciiString(data.data);
@@ -6905,6 +6997,17 @@ var Mediabunny = (() => {
     }
     return value;
   };
+  var readUnsignedBigInt = (slice, width) => {
+    if (width < 1) {
+      throw new Error("Bad unsigned int size " + width);
+    }
+    let value = 0n;
+    for (let i = 0; i < width; i++) {
+      value <<= 8n;
+      value += BigInt(readU8(slice));
+    }
+    return value;
+  };
   var readSignedInt = (slice, width) => {
     let value = readUnsignedInt(slice, width);
     if (value & 1 << width * 8 - 1) {
@@ -7417,11 +7520,10 @@ var Mediabunny = (() => {
     }
     maybeCreateAttachments() {
       const metadataTags = this.output._metadataTags;
-      if (!metadataTags.images || metadataTags.images.length === 0) {
-        return;
-      }
+      const elements = [];
       const existingFileUids = /* @__PURE__ */ new Set();
-      this.attachmentsElement = { id: 423732329 /* Attachments */, data: metadataTags.images.map((image) => {
+      const images = metadataTags.images ?? [];
+      for (const image of images) {
         let imageName = image.name;
         if (imageName === void 0) {
           const baseName = image.kind === "coverFront" ? "cover" : image.kind === "coverBack" ? "back" : "image";
@@ -7429,13 +7531,17 @@ var Mediabunny = (() => {
         }
         let fileUid;
         while (true) {
-          fileUid = Math.floor(Math.random() * Number.MAX_SAFE_INTEGER);
-          if (fileUid !== 0 && !existingFileUids.has(fileUid)) {
+          fileUid = 0n;
+          for (let i = 0; i < 8; i++) {
+            fileUid <<= 8n;
+            fileUid |= BigInt(Math.floor(Math.random() * 256));
+          }
+          if (fileUid !== 0n && !existingFileUids.has(fileUid)) {
             break;
           }
         }
         existingFileUids.add(fileUid);
-        return {
+        elements.push({
           id: 24999 /* AttachedFile */,
           data: [
             image.description !== void 0 ? { id: 18046 /* FileDescription */, data: new EBMLUnicodeString(image.description) } : null,
@@ -7444,8 +7550,34 @@ var Mediabunny = (() => {
             { id: 18012 /* FileData */, data: image.data },
             { id: 18094 /* FileUID */, data: fileUid }
           ]
-        };
-      }) };
+        });
+      }
+      for (const [key, value] of Object.entries(metadataTags.raw ?? {})) {
+        if (!(value instanceof AttachedFile)) {
+          continue;
+        }
+        const keyIsNumeric = /^\d+$/.test(key);
+        if (!keyIsNumeric) {
+          continue;
+        }
+        if (images.find((x) => x.mimeType === value.mimeType && uint8ArraysAreEqual(x.data, value.data))) {
+          continue;
+        }
+        elements.push({
+          id: 24999 /* AttachedFile */,
+          data: [
+            value.description !== void 0 ? { id: 18046 /* FileDescription */, data: new EBMLUnicodeString(value.description) } : null,
+            { id: 18030 /* FileName */, data: new EBMLUnicodeString(value.name ?? "") },
+            { id: 18016 /* FileMediaType */, data: value.mimeType ?? "" },
+            { id: 18012 /* FileData */, data: value.data },
+            { id: 18094 /* FileUID */, data: BigInt(key) }
+          ]
+        });
+      }
+      if (elements.length === 0) {
+        return;
+      }
+      this.attachmentsElement = { id: 423732329 /* Attachments */, data: elements };
     }
     createSegment() {
       this.createTracks();
@@ -8053,11 +8185,11 @@ ${cue.notes ?? ""}`;
     if (layer === 0) {
       return 0;
     } else if (layer === 1) {
-      return Math.round(144 * bitrate / (sampleRate << lowSamplingFrequency)) + padding;
+      return Math.floor(144 * bitrate / (sampleRate << lowSamplingFrequency)) + padding;
     } else if (layer === 2) {
-      return Math.round(144 * bitrate / sampleRate) + padding;
+      return Math.floor(144 * bitrate / sampleRate) + padding;
     } else {
-      return (Math.round(12 * bitrate / sampleRate) + padding) * 4;
+      return (Math.floor(12 * bitrate / sampleRate) + padding) * 4;
     }
   };
   var getXingOffset = (mpegVersionId, channel) => {
@@ -15590,7 +15722,7 @@ ${cue.notes ?? ""}`;
       const abortController = new AbortController();
       const response = await retriedFetch(
         this._url,
-        mergeObjectsDeeply(this._options.requestInit ?? {}, {
+        mergeRequestInit(this._options.requestInit ?? {}, {
           headers: {
             // We could also send a non-range request to request the same bytes (all of them), but doing it like
             // this is an easy way to check if the server supports range requests in the first place
@@ -15641,7 +15773,7 @@ ${cue.notes ?? ""}`;
           abortController = new AbortController();
           response = await retriedFetch(
             this._url,
-            mergeObjectsDeeply(this._options.requestInit ?? {}, {
+            mergeRequestInit(this._options.requestInit ?? {}, {
               headers: {
                 Range: `bytes=${worker.currentPos}-`
               },
@@ -20072,12 +20204,23 @@ ${cue.notes ?? ""}`;
           {
             if (!this.currentSegment) break;
             this.currentAttachedFile = {
+              fileUid: null,
               fileName: null,
               fileMediaType: null,
               fileData: null,
               fileDescription: null
             };
             this.readContiguousElements(slice.slice(dataStartPos, size));
+            const tags = this.currentSegment.metadataTags;
+            if (this.currentAttachedFile.fileUid && this.currentAttachedFile.fileData) {
+              tags.raw ??= {};
+              tags.raw[this.currentAttachedFile.fileUid.toString()] = new AttachedFile(
+                this.currentAttachedFile.fileData,
+                this.currentAttachedFile.fileMediaType ?? void 0,
+                this.currentAttachedFile.fileName ?? void 0,
+                this.currentAttachedFile.fileDescription ?? void 0
+              );
+            }
             if (this.currentAttachedFile.fileMediaType?.startsWith("image/") && this.currentAttachedFile.fileData) {
               const fileName = this.currentAttachedFile.fileName;
               let kind = "unknown";
@@ -20089,8 +20232,8 @@ ${cue.notes ?? ""}`;
                   kind = "coverBack";
                 }
               }
-              this.currentSegment.metadataTags.images ??= [];
-              this.currentSegment.metadataTags.images.push({
+              tags.images ??= [];
+              tags.images.push({
                 data: this.currentAttachedFile.fileData,
                 mimeType: this.currentAttachedFile.fileMediaType,
                 kind,
@@ -20102,6 +20245,13 @@ ${cue.notes ?? ""}`;
           }
           ;
           break;
+        case 18094 /* FileUID */:
+          {
+            if (!this.currentAttachedFile) break;
+            this.currentAttachedFile.fileUid = readUnsignedBigInt(slice, size);
+          }
+          ;
+          break;
         case 18030 /* FileName */:
           {
             if (!this.currentAttachedFile) break;
@@ -22164,7 +22314,8 @@ ${cue.notes ?? ""}`;
       let currentPos = 4;
       return this.metadataPromise ??= (async () => {
         while (this.reader.fileSize === null || currentPos < this.reader.fileSize) {
-          const sizeSlice = await this.reader.requestSlice(currentPos, 4);
+          let sizeSlice = this.reader.requestSlice(currentPos, 4);
+          if (sizeSlice instanceof Promise) sizeSlice = await sizeSlice;
           currentPos += 4;
           if (sizeSlice === null) {
             throw new Error(
@@ -22178,10 +22329,11 @@ ${cue.notes ?? ""}`;
           const metaBlockType = byte & 127;
           switch (metaBlockType) {
             case 0 /* STREAMINFO */: {
-              const streamInfoBlock = await this.reader.requestSlice(
+              let streamInfoBlock = this.reader.requestSlice(
                 currentPos,
                 size
               );
+              if (streamInfoBlock instanceof Promise) streamInfoBlock = await streamInfoBlock;
               assert(streamInfoBlock);
               if (streamInfoBlock === null) {
                 throw new Error(
@@ -22217,25 +22369,24 @@ ${cue.notes ?? ""}`;
               break;
             }
             case 4 /* VORBIS_COMMENT */: {
-              const vorbisCommentBlock = await this.reader.requestSlice(
+              let vorbisCommentBlock = this.reader.requestSlice(
                 currentPos,
                 size
               );
+              if (vorbisCommentBlock instanceof Promise) vorbisCommentBlock = await vorbisCommentBlock;
               assert(vorbisCommentBlock);
               readVorbisComments(
-                vorbisCommentBlock.bytes.subarray(
-                  vorbisCommentBlock.start,
-                  vorbisCommentBlock.end
-                ),
+                readBytes(vorbisCommentBlock, size),
                 this.metadataTags
               );
               break;
             }
             case 6 /* PICTURE */: {
-              const pictureBlock = await this.reader.requestSlice(
+              let pictureBlock = this.reader.requestSlice(
                 currentPos,
                 size
               );
+              if (pictureBlock instanceof Promise) pictureBlock = await pictureBlock;
               assert(pictureBlock);
               const pictureType = readU32Be(pictureBlock);
               const mediaTypeLength = readU32Be(pictureBlock);
@@ -22538,10 +22689,11 @@ ${cue.notes ?? ""}`;
       if (options.metadataOnly) {
         data = PLACEHOLDER_DATA;
       } else {
-        const slice = await this.demuxer.reader.requestSlice(
+        let slice = this.demuxer.reader.requestSlice(
           rawSample.byteOffset,
           rawSample.byteSize
         );
+        if (slice instanceof Promise) slice = await slice;
         if (!slice) {
           return null;
         }
@@ -22740,7 +22892,7 @@ ${cue.notes ?? ""}`;
       if (id3V2HeaderFound) {
         return true;
       }
-      currentPos = firstResult.startPos += firstResult.header.totalSize;
+      currentPos = firstResult.startPos + firstResult.header.totalSize;
       const secondResult = await readNextFrameHeader(input._reader, currentPos, currentPos + FRAME_HEADER_SIZE);
       if (!secondResult) {
         return false;