mediabunny 1.13.3 → 1.14.0

package/dist/bundles/mediabunny.cjs

@@ -93,6 +93,7 @@ var Mediabunny = (() => {
     Quality: () => Quality,
     QuickTimeInputFormat: () => QuickTimeInputFormat,
     ReadableStreamSource: () => ReadableStreamSource,
+    RichImageData: () => RichImageData,
     SUBTITLE_CODECS: () => SUBTITLE_CODECS,
     Source: () => Source,
     StreamSource: () => StreamSource,
@@ -253,6 +254,15 @@ var Mediabunny = (() => {
   };
   var textDecoder = new TextDecoder();
   var textEncoder = new TextEncoder();
+  var isIso88591Compatible = (text) => {
+    for (let i = 0; i < text.length; i++) {
+      const code = text.charCodeAt(i);
+      if (code > 255) {
+        return false;
+      }
+    }
+    return true;
+  };
   var invertObject = (object) => {
     return Object.fromEntries(Object.entries(object).map(([key, value]) => [value, key]));
   };
@@ -576,9 +586,149 @@ var Mediabunny = (() => {
     isSafariCache = result;
     return result;
   };
+  var coalesceIndex = (a, b) => {
+    return a !== -1 ? a : b;
+  };
   var closedIntervalsOverlap = (startA, endA, startB, endB) => {
     return startA <= endB && startB <= endA;
   };
+  var keyValueIterator = function* (object) {
+    for (const key in object) {
+      const value = object[key];
+      if (value === void 0) {
+        continue;
+      }
+      yield { key, value };
+    }
+  };
+  var imageMimeTypeToExtension = (mimeType) => {
+    switch (mimeType.toLowerCase()) {
+      case "image/jpeg":
+      case "image/jpg":
+        return ".jpg";
+      case "image/png":
+        return ".png";
+      case "image/gif":
+        return ".gif";
+      case "image/webp":
+        return ".webp";
+      case "image/bmp":
+        return ".bmp";
+      case "image/svg+xml":
+        return ".svg";
+      case "image/tiff":
+        return ".tiff";
+      case "image/avif":
+        return ".avif";
+      case "image/x-icon":
+      case "image/vnd.microsoft.icon":
+        return ".ico";
+      default:
+        return null;
+    }
+  };
+  var base64ToBytes = (base64) => {
+    const decoded = atob(base64);
+    const bytes2 = new Uint8Array(decoded.length);
+    for (let i = 0; i < decoded.length; i++) {
+      bytes2[i] = decoded.charCodeAt(i);
+    }
+    return bytes2;
+  };
+  var bytesToBase64 = (bytes2) => {
+    let string = "";
+    for (let i = 0; i < bytes2.length; i++) {
+      string += String.fromCharCode(bytes2[i]);
+    }
+    return btoa(string);
+  };
+
+  // src/tags.ts
+  var RichImageData = class {
+    /** Creates a new {@link RichImageData}. */
+    constructor(data, mimeType) {
+      this.data = data;
+      this.mimeType = mimeType;
+    }
+  };
+  var validateMetadataTags = (tags) => {
+    if (!tags || typeof tags !== "object") {
+      throw new TypeError("tags must be an object.");
+    }
+    if (tags.title !== void 0 && typeof tags.title !== "string") {
+      throw new TypeError("tags.title, when provided, must be a string.");
+    }
+    if (tags.description !== void 0 && typeof tags.description !== "string") {
+      throw new TypeError("tags.description, when provided, must be a string.");
+    }
+    if (tags.artist !== void 0 && typeof tags.artist !== "string") {
+      throw new TypeError("tags.artist, when provided, must be a string.");
+    }
+    if (tags.album !== void 0 && typeof tags.album !== "string") {
+      throw new TypeError("tags.album, when provided, must be a string.");
+    }
+    if (tags.albumArtist !== void 0 && typeof tags.albumArtist !== "string") {
+      throw new TypeError("tags.albumArtist, when provided, must be a string.");
+    }
+    if (tags.trackNumber !== void 0 && (!Number.isInteger(tags.trackNumber) || tags.trackNumber <= 0)) {
+      throw new TypeError("tags.trackNumber, when provided, must be a positive integer.");
+    }
+    if (tags.tracksTotal !== void 0 && (!Number.isInteger(tags.tracksTotal) || tags.tracksTotal <= 0)) {
+      throw new TypeError("tags.tracksTotal, when provided, must be a positive integer.");
+    }
+    if (tags.discNumber !== void 0 && (!Number.isInteger(tags.discNumber) || tags.discNumber <= 0)) {
+      throw new TypeError("tags.discNumber, when provided, must be a positive integer.");
+    }
+    if (tags.discsTotal !== void 0 && (!Number.isInteger(tags.discsTotal) || tags.discsTotal <= 0)) {
+      throw new TypeError("tags.discsTotal, when provided, must be a positive integer.");
+    }
+    if (tags.genre !== void 0 && typeof tags.genre !== "string") {
+      throw new TypeError("tags.genre, when provided, must be a string.");
+    }
+    if (tags.date !== void 0 && (!(tags.date instanceof Date) || Number.isNaN(tags.date.getTime()))) {
+      throw new TypeError("tags.date, when provided, must be a valid Date.");
+    }
+    if (tags.lyrics !== void 0 && typeof tags.lyrics !== "string") {
+      throw new TypeError("tags.lyrics, when provided, must be a string.");
+    }
+    if (tags.images !== void 0) {
+      if (!Array.isArray(tags.images)) {
+        throw new TypeError("tags.images, when provided, must be an array.");
+      }
+      for (const image of tags.images) {
+        if (!image || typeof image !== "object") {
+          throw new TypeError("Each image in tags.images must be an object.");
+        }
+        if (!(image.data instanceof Uint8Array)) {
+          throw new TypeError("Each image.data must be a Uint8Array.");
+        }
+        if (typeof image.mimeType !== "string") {
+          throw new TypeError("Each image.mimeType must be a string.");
+        }
+        if (!["coverFront", "coverBack", "unknown"].includes(image.kind)) {
+          throw new TypeError("Each image.kind must be 'coverFront', 'coverBack', or 'unknown'.");
+        }
+      }
+    }
+    if (tags.comment !== void 0 && typeof tags.comment !== "string") {
+      throw new TypeError("tags.comment, when provided, must be a string.");
+    }
+    if (tags.raw !== void 0) {
+      if (!tags.raw || typeof tags.raw !== "object") {
+        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)) {
+          throw new TypeError(
+            "Each value in tags.raw must be a string, Uint8Array, RichImageData, or null."
+          );
+        }
+      }
+    }
+  };
+  var metadataTagsAreEmpty = (tags) => {
+    return tags.title === void 0 && tags.description === void 0 && tags.artist === void 0 && tags.album === void 0 && tags.albumArtist === void 0 && tags.trackNumber === void 0 && tags.tracksTotal === void 0 && tags.discNumber === void 0 && tags.discsTotal === void 0 && tags.genre === void 0 && tags.date === void 0 && tags.lyrics === void 0 && (!tags.images || tags.images.length === 0) && tags.comment === void 0 && (tags.raw === void 0 || Object.keys(tags.raw).length === 0);
+  };
 
   // src/codec.ts
   var VIDEO_CODECS = [
@@ -1460,13 +1610,13 @@ var Mediabunny = (() => {
     async addEncodedVideoPacket() {
       throw new Error("ADTS does not support video.");
     }
-    async addEncodedAudioPacket(track, packet, meta) {
+    async addEncodedAudioPacket(track, packet, meta2) {
       const release = await this.mutex.acquire();
       try {
         this.validateAndNormalizeTimestamp(track, packet.timestamp, packet.type === "key");
         if (!this.audioSpecificConfig) {
-          validateAudioChunkMetadata(meta);
-          const description = meta?.decoderConfig?.description;
+          validateAudioChunkMetadata(meta2);
+          const description = meta2?.decoderConfig?.description;
           assert(description);
           this.audioSpecificConfig = parseAacAudioSpecificConfig(toUint8Array(description));
           const { objectType, frequencyIndex, channelConfiguration } = this.audioSpecificConfig;
@@ -1562,14 +1712,14 @@ var Mediabunny = (() => {
           settings: cueSettings,
           notes
         };
-        const meta = {};
+        const meta2 = {};
         if (!this.preambleEmitted) {
-          meta.config = {
+          meta2.config = {
             description: this.preambleText
           };
           this.preambleEmitted = true;
         }
-        this.options.output(cue, meta);
+        this.options.output(cue, meta2);
       }
     }
   };
@@ -2902,10 +3052,11 @@ var Mediabunny = (() => {
     ]);
   };
   var mdat = (reserveLargeSize) => ({ type: "mdat", largeSize: reserveLargeSize });
-  var moov = (trackDatas, creationTime, fragmented = false) => box("moov", void 0, [
-    mvhd(creationTime, trackDatas),
-    ...trackDatas.map((x) => trak(x, creationTime)),
-    fragmented ? mvex(trackDatas) : null
+  var moov = (muxer, fragmented = false) => box("moov", void 0, [
+    mvhd(muxer.creationTime, muxer.trackDatas),
+    ...muxer.trackDatas.map((x) => trak(x, muxer.creationTime)),
+    fragmented ? mvex(muxer.trackDatas) : null,
+    udta(muxer)
   ]);
   var mvhd = (creationTime, trackDatas) => {
     const duration = intoTimescale(Math.max(
@@ -2947,7 +3098,8 @@ var Mediabunny = (() => {
       tkhd(trackData, creationTime),
       mdia(trackData, creationTime),
       trackMetadata.name !== void 0 ? box("udta", void 0, [
-        box("\xA9nam", [
+        box("name", [
+          // VLC (and Mediabunny) also recognize ©nam
           ...textEncoder.encode(trackMetadata.name)
         ])
       ]) : null
@@ -3010,11 +3162,6 @@ var Mediabunny = (() => {
     );
     const needsU64 = !isU32(creationTime) || !isU32(localDuration);
     const u32OrU64 = needsU64 ? u64 : u32;
-    let language = 0;
-    for (const character of trackData.track.metadata.languageCode ?? UNDETERMINED_LANGUAGE) {
-      language <<= 5;
-      language += character.charCodeAt(0) - 96;
-    }
     return fullBox("mdhd", +needsU64, 0, [
       u32OrU64(creationTime),
       // Creation time
@@ -3024,7 +3171,7 @@ var Mediabunny = (() => {
       // Timescale
       u32OrU64(localDuration),
       // Duration
-      u16(language),
+      u16(getLanguageCodeInt(trackData.track.metadata.languageCode ?? UNDETERMINED_LANGUAGE)),
       // Language
       u16(0)
       // Quality
@@ -3040,12 +3187,12 @@ var Mediabunny = (() => {
     audio: "MediabunnySoundHandler",
     subtitle: "MediabunnyTextHandler"
   };
-  var hdlr = (hasComponentType, handlerType, name) => fullBox("hdlr", 0, 0, [
+  var hdlr = (hasComponentType, handlerType, name, manufacturer = "\0\0\0\0") => fullBox("hdlr", 0, 0, [
     hasComponentType ? ascii("mhlr") : u32(0),
     // Component type
     ascii(handlerType),
     // Component subtype
-    u32(0),
+    ascii(manufacturer),
     // Component manufacturer
     u32(0),
     // Component flags
@@ -3740,6 +3887,303 @@ var Mediabunny = (() => {
     box("payl", [...textEncoder.encode(payload)])
   ]);
   var vtta = (notes) => box("vtta", [...textEncoder.encode(notes)]);
+  var udta = (muxer) => {
+    const boxes = [];
+    if (muxer.isQuickTime) {
+      addQuickTimeMetadataTagBoxes(boxes, muxer.output._metadataTags);
+    } else {
+      const metaBox = meta(muxer.output._metadataTags);
+      if (metaBox) {
+        boxes.push(metaBox);
+      }
+    }
+    if (boxes.length === 0) {
+      return null;
+    }
+    return box("udta", void 0, boxes);
+  };
+  var addQuickTimeMetadataTagBoxes = (boxes, tags) => {
+    for (const { key, value } of keyValueIterator(tags)) {
+      switch (key) {
+        case "title":
+          {
+            boxes.push(metadataTagStringBoxShort("\xA9nam", value));
+          }
+          ;
+          break;
+        case "description":
+          {
+            boxes.push(metadataTagStringBoxShort("\xA9des", value));
+          }
+          ;
+          break;
+        case "artist":
+          {
+            boxes.push(metadataTagStringBoxShort("\xA9ART", value));
+          }
+          ;
+          break;
+        case "album":
+          {
+            boxes.push(metadataTagStringBoxShort("\xA9alb", value));
+          }
+          ;
+          break;
+        case "albumArtist":
+          {
+            boxes.push(metadataTagStringBoxShort("albr", value));
+          }
+          ;
+          break;
+        case "genre":
+          {
+            boxes.push(metadataTagStringBoxShort("\xA9gen", value));
+          }
+          ;
+          break;
+        case "date":
+          {
+            boxes.push(metadataTagStringBoxShort("\xA9day", value.toISOString().slice(0, 10)));
+          }
+          ;
+          break;
+        case "comment":
+          {
+            boxes.push(metadataTagStringBoxShort("\xA9cmt", value));
+          }
+          ;
+          break;
+        case "lyrics":
+          {
+            boxes.push(metadataTagStringBoxShort("\xA9lyr", value));
+          }
+          ;
+          break;
+        case "raw":
+          {
+          }
+          ;
+          break;
+        case "discNumber":
+        case "discsTotal":
+        case "trackNumber":
+        case "tracksTotal":
+        case "images":
+          {
+          }
+          ;
+          break;
+        default:
+          assertNever(key);
+      }
+    }
+    if (tags.raw) {
+      for (const key in tags.raw) {
+        const value = tags.raw[key];
+        if (value == null || key.length !== 4 || boxes.some((x) => x.type === key)) {
+          continue;
+        }
+        if (typeof value === "string") {
+          boxes.push(metadataTagStringBoxShort(key, value));
+        } else if (value instanceof Uint8Array) {
+          boxes.push(box(key, Array.from(value)));
+        }
+      }
+    }
+  };
+  var metadataTagStringBoxShort = (name, value) => {
+    const encoded = textEncoder.encode(value);
+    return box(name, [
+      u16(encoded.length),
+      u16(getLanguageCodeInt("und")),
+      Array.from(encoded)
+    ]);
+  };
+  var DATA_BOX_MIME_TYPE_MAP = {
+    "image/jpeg": 13,
+    "image/png": 14,
+    "image/bmp": 27
+  };
+  var meta = (tags) => {
+    const boxes = [];
+    for (const { key, value } of keyValueIterator(tags)) {
+      switch (key) {
+        case "title":
+          {
+            boxes.push(metadataTagStringBoxLong("\xA9nam", value));
+          }
+          ;
+          break;
+        case "description":
+          {
+            boxes.push(metadataTagStringBoxLong("\xA9des", value));
+          }
+          ;
+          break;
+        case "artist":
+          {
+            boxes.push(metadataTagStringBoxLong("\xA9ART", value));
+          }
+          ;
+          break;
+        case "album":
+          {
+            boxes.push(metadataTagStringBoxLong("\xA9alb", value));
+          }
+          ;
+          break;
+        case "albumArtist":
+          {
+            boxes.push(metadataTagStringBoxLong("aART", value));
+          }
+          ;
+          break;
+        case "comment":
+          {
+            boxes.push(metadataTagStringBoxLong("\xA9cmt", value));
+          }
+          ;
+          break;
+        case "genre":
+          {
+            boxes.push(metadataTagStringBoxLong("\xA9gen", value));
+          }
+          ;
+          break;
+        case "lyrics":
+          {
+            boxes.push(metadataTagStringBoxLong("\xA9lyr", value));
+          }
+          ;
+          break;
+        case "date":
+          {
+            boxes.push(metadataTagStringBoxLong("\xA9day", value.toISOString().slice(0, 10)));
+          }
+          ;
+          break;
+        case "images":
+          {
+            for (const image of value) {
+              if (image.kind !== "coverFront") {
+                continue;
+              }
+              boxes.push(box("covr", void 0, [
+                box("data", [
+                  u32(DATA_BOX_MIME_TYPE_MAP[image.mimeType] ?? 0),
+                  // Type indicator
+                  u32(0),
+                  // Locale indicator
+                  Array.from(image.data)
+                  // Kinda slow, hopefully temp
+                ])
+              ]));
+            }
+          }
+          ;
+          break;
+        case "trackNumber":
+          {
+            boxes.push(box("trkn", void 0, [
+              box("data", [
+                u32(0),
+                // 8 bytes empty
+                u32(0),
+                u16(0),
+                // Empty
+                u16(value),
+                u16(tags.tracksTotal ?? 0),
+                u16(0)
+                // Empty
+              ])
+            ]));
+          }
+          ;
+          break;
+        case "discNumber":
+          {
+            boxes.push(box("disc", void 0, [
+              box("data", [
+                u32(0),
+                // 8 bytes empty
+                u32(0),
+                u16(0),
+                // Empty
+                u16(value),
+                u16(tags.discsTotal ?? 0),
+                u16(0)
+                // Empty
+              ])
+            ]));
+          }
+          ;
+          break;
+        case "tracksTotal":
+        case "discsTotal":
+          {
+          }
+          ;
+          break;
+        case "raw":
+          {
+          }
+          ;
+          break;
+        default:
+          assertNever(key);
+      }
+    }
+    if (tags.raw) {
+      for (const key in tags.raw) {
+        const value = tags.raw[key];
+        if (value == null || key.length !== 4 || boxes.some((x) => x.type === key)) {
+          continue;
+        }
+        if (typeof value === "string") {
+          boxes.push(metadataTagStringBoxLong(key, value));
+        } else if (value instanceof Uint8Array) {
+          boxes.push(box(key, void 0, [
+            box("data", [
+              u32(0),
+              // Type indicator
+              u32(0),
+              // Locale indicator
+              Array.from(value)
+            ])
+          ]));
+        } else if (value instanceof RichImageData) {
+          boxes.push(box(key, void 0, [
+            box("data", [
+              u32(DATA_BOX_MIME_TYPE_MAP[value.mimeType] ?? 0),
+              // Type indicator
+              u32(0),
+              // Locale indicator
+              Array.from(value.data)
+              // Kinda slow, hopefully temp
+            ])
+          ]));
+        }
+      }
+    }
+    if (boxes.length === 0) {
+      return null;
+    }
+    return fullBox("meta", 0, 0, void 0, [
+      hdlr(false, "mdir", "", "appl"),
+      box("ilst", void 0, boxes)
+    ]);
+  };
+  var metadataTagStringBoxLong = (name, value) => {
+    return box(name, void 0, [
+      box("data", [
+        u32(1),
+        // Type indicator (UTF-8)
+        u32(0),
+        // Locale indicator
+        ...textEncoder.encode(value)
+      ])
+    ]);
+  };
   var VIDEO_CODEC_TO_BOX_NAME = {
     avc: "avc1",
     hevc: "hvc1",
@@ -3887,6 +4331,16 @@ var Mediabunny = (() => {
   var SUBTITLE_CODEC_TO_CONFIGURATION_BOX = {
     webvtt: vttC
   };
+  var getLanguageCodeInt = (code) => {
+    assert(code.length === 3);
+    ;
+    let language = 0;
+    for (let i = 0; i < 3; i++) {
+      language <<= 5;
+      language += code.charCodeAt(i) - 96;
+    }
+    return language;
+  };
 
   // src/writer.ts
   var Writer = class {
@@ -4522,6 +4976,36 @@ var Mediabunny = (() => {
     }
     return result;
   };
+  var readMetadataStringShort = (slice) => {
+    const stringLength = readU16Be(slice);
+    slice.skip(2);
+    return textDecoder.decode(readBytes(slice, stringLength));
+  };
+  var readDataBox = (slice) => {
+    const header = readBoxHeader(slice);
+    if (!header || header.name !== "data") {
+      return null;
+    }
+    const typeIndicator = readU32Be(slice);
+    slice.skip(4);
+    const data = readBytes(slice, header.contentSize - 8);
+    switch (typeIndicator) {
+      case 1:
+        return textDecoder.decode(data);
+      // UTF-8
+      case 2:
+        return new TextDecoder("utf-16be").decode(data);
+      // UTF-16-BE
+      case 13:
+        return new RichImageData(data, "image/jpeg");
+      case 14:
+        return new RichImageData(data, "image/png");
+      case 27:
+        return new RichImageData(data, "image/bmp");
+      default:
+        return data;
+    }
+  };
 
   // src/isobmff/isobmff-muxer.ts
   var GLOBAL_TIMESCALE = 1e3;
@@ -4538,7 +5022,7 @@ var Mediabunny = (() => {
     const value = timeInSeconds * timescale;
     return round ? Math.round(value) : value;
   };
-  var IsobmffMuxer = class extends Muxer {
+  var IsobmffMuxer2 = class extends Muxer {
     constructor(output, format) {
       super(output);
       this.auxTarget = new BufferTarget();
@@ -4623,15 +5107,15 @@ var Mediabunny = (() => {
         codecStrings
       });
     }
-    getVideoTrackData(track, packet, meta) {
+    getVideoTrackData(track, packet, meta2) {
       const existingTrackData = this.trackDatas.find((x) => x.track === track);
       if (existingTrackData) {
         return existingTrackData;
       }
-      validateVideoChunkMetadata(meta);
-      assert(meta);
-      assert(meta.decoderConfig);
-      const decoderConfig = { ...meta.decoderConfig };
+      validateVideoChunkMetadata(meta2);
+      assert(meta2);
+      assert(meta2.decoderConfig);
+      const decoderConfig = { ...meta2.decoderConfig };
       assert(decoderConfig.codedWidth !== void 0);
       assert(decoderConfig.codedHeight !== void 0);
       let requiresAnnexBTransformation = false;
@@ -4684,25 +5168,25 @@ var Mediabunny = (() => {
       }
       return newTrackData;
     }
-    getAudioTrackData(track, meta) {
+    getAudioTrackData(track, meta2) {
       const existingTrackData = this.trackDatas.find((x) => x.track === track);
       if (existingTrackData) {
         return existingTrackData;
       }
-      validateAudioChunkMetadata(meta);
-      assert(meta);
-      assert(meta.decoderConfig);
+      validateAudioChunkMetadata(meta2);
+      assert(meta2);
+      assert(meta2.decoderConfig);
       const newTrackData = {
         muxer: this,
         track,
         type: "audio",
         info: {
-          numberOfChannels: meta.decoderConfig.numberOfChannels,
-          sampleRate: meta.decoderConfig.sampleRate,
-          decoderConfig: meta.decoderConfig,
+          numberOfChannels: meta2.decoderConfig.numberOfChannels,
+          sampleRate: meta2.decoderConfig.sampleRate,
+          decoderConfig: meta2.decoderConfig,
           requiresPcmTransformation: !this.isFragmented && PCM_AUDIO_CODECS.includes(track.source._codec)
         },
-        timescale: meta.decoderConfig.sampleRate,
+        timescale: meta2.decoderConfig.sampleRate,
         samples: [],
         sampleQueue: [],
         timestampProcessingQueue: [],
@@ -4721,20 +5205,20 @@ var Mediabunny = (() => {
       }
       return newTrackData;
     }
-    getSubtitleTrackData(track, meta) {
+    getSubtitleTrackData(track, meta2) {
       const existingTrackData = this.trackDatas.find((x) => x.track === track);
       if (existingTrackData) {
         return existingTrackData;
       }
-      validateSubtitleMetadata(meta);
-      assert(meta);
-      assert(meta.config);
+      validateSubtitleMetadata(meta2);
+      assert(meta2);
+      assert(meta2.config);
       const newTrackData = {
         muxer: this,
         track,
         type: "subtitle",
         info: {
-          config: meta.config
+          config: meta2.config
         },
         timescale: 1e3,
         // Reasonable
@@ -4760,10 +5244,10 @@ var Mediabunny = (() => {
       }
       return newTrackData;
     }
-    async addEncodedVideoPacket(track, packet, meta) {
+    async addEncodedVideoPacket(track, packet, meta2) {
       const release = await this.mutex.acquire();
       try {
-        const trackData = this.getVideoTrackData(track, packet, meta);
+        const trackData = this.getVideoTrackData(track, packet, meta2);
         let packetData = packet.data;
         if (trackData.info.requiresAnnexBTransformation) {
           const transformedData = transformAnnexBToLengthPrefixed(packetData);
@@ -4791,10 +5275,10 @@ var Mediabunny = (() => {
         release();
       }
     }
-    async addEncodedAudioPacket(track, packet, meta) {
+    async addEncodedAudioPacket(track, packet, meta2) {
       const release = await this.mutex.acquire();
       try {
-        const trackData = this.getAudioTrackData(track, meta);
+        const trackData = this.getAudioTrackData(track, meta2);
         const timestamp = this.validateAndNormalizeTimestamp(
           trackData.track,
           packet.timestamp,
@@ -4836,10 +5320,10 @@ var Mediabunny = (() => {
         await this.registerSample(trackData, paddingSample);
       }
     }
-    async addSubtitleCue(track, cue, meta) {
+    async addSubtitleCue(track, cue, meta2) {
       const release = await this.mutex.acquire();
       try {
-        const trackData = this.getSubtitleTrackData(track, meta);
+        const trackData = this.getSubtitleTrackData(track, meta2);
         this.validateAndNormalizeTimestamp(trackData.track, cue.timestamp, true);
         if (track.source._codec === "webvtt") {
           trackData.cueQueue.push(cue);
@@ -5154,7 +5638,7 @@ var Mediabunny = (() => {
         if (this.format._options.onMoov) {
           this.writer.startTrackingWrites();
         }
-        const movieBox = moov(this.trackDatas, this.creationTime, true);
+        const movieBox = moov(this, true);
         this.boxWriter.writeBox(movieBox);
         if (this.format._options.onMoov) {
           const { data, start } = this.writer.stopTrackingWrites();
@@ -5260,7 +5744,7 @@ var Mediabunny = (() => {
         assert(this.mdat);
         let mdatSize;
         for (let i = 0; i < 2; i++) {
-          const movieBox2 = moov(this.trackDatas, this.creationTime);
+          const movieBox2 = moov(this);
           const movieBoxSize = this.boxWriter.measureBox(movieBox2);
           mdatSize = this.boxWriter.measureBox(this.mdat);
           let currentChunkPos = this.writer.getPos() + movieBoxSize + mdatSize;
@@ -5278,7 +5762,7 @@ var Mediabunny = (() => {
         if (this.format._options.onMoov) {
           this.writer.startTrackingWrites();
         }
-        const movieBox = moov(this.trackDatas, this.creationTime);
+        const movieBox = moov(this);
         this.boxWriter.writeBox(movieBox);
         if (this.format._options.onMoov) {
           const { data, start } = this.writer.stopTrackingWrites();
@@ -5322,7 +5806,7 @@ var Mediabunny = (() => {
         if (this.format._options.onMoov) {
           this.writer.startTrackingWrites();
         }
-        const movieBox = moov(this.trackDatas, this.creationTime);
+        const movieBox = moov(this);
         this.boxWriter.writeBox(movieBox);
         if (this.format._options.onMoov) {
           const { data, start } = this.writer.stopTrackingWrites();
@@ -5767,7 +6251,7 @@ var Mediabunny = (() => {
   // src/matroska/matroska-muxer.ts
   var MIN_CLUSTER_TIMESTAMP_MS = -(2 ** 15);
   var MAX_CLUSTER_TIMESTAMP_MS = 2 ** 15 - 1;
-  var APP_NAME = "https://github.com/Vanilagy/mediabunny";
+  var APP_NAME = "Mediabunny";
   var SEGMENT_SIZE_BYTES = 6;
   var CLUSTER_SIZE_BYTES = 5;
   var TRACK_TYPE_MAP = {
@@ -5784,6 +6268,8 @@ var Mediabunny = (() => {
       this.segmentInfo = null;
       this.seekHead = null;
       this.tracksElement = null;
+      this.tagsElement = null;
+      this.attachmentsElement = null;
       this.segmentDuration = null;
       this.cues = null;
       this.currentCluster = null;
@@ -5801,9 +6287,6 @@ var Mediabunny = (() => {
     async start() {
       const release = await this.mutex.acquire();
       this.writeEBMLHeader();
-      if (!this.format._options.appendOnly) {
-        this.createSeekHead();
-      }
       this.createSegmentInfo();
       this.createCues();
       await this.writer.flush();
@@ -5832,23 +6315,56 @@ var Mediabunny = (() => {
      * Creates a SeekHead element which is positioned near the start of the file and allows the media player to seek to
      * relevant sections more easily. Since we don't know the positions of those sections yet, we'll set them later.
      */
-    createSeekHead() {
+    maybeCreateSeekHead(writeOffsets) {
+      if (this.format._options.appendOnly) {
+        return;
+      }
       const kaxCues = new Uint8Array([28, 83, 187, 107]);
       const kaxInfo = new Uint8Array([21, 73, 169, 102]);
       const kaxTracks = new Uint8Array([22, 84, 174, 107]);
+      const kaxAttachments = new Uint8Array([25, 65, 164, 105]);
+      const kaxTags = new Uint8Array([18, 84, 195, 103]);
       const seekHead = { id: 290298740 /* SeekHead */, data: [
         { id: 19899 /* Seek */, data: [
           { id: 21419 /* SeekID */, data: kaxCues },
-          { id: 21420 /* SeekPosition */, size: 5, data: 0 }
+          {
+            id: 21420 /* SeekPosition */,
+            size: 5,
+            data: writeOffsets ? this.ebmlWriter.offsets.get(this.cues) - this.segmentDataOffset : 0
+          }
         ] },
         { id: 19899 /* Seek */, data: [
           { id: 21419 /* SeekID */, data: kaxInfo },
-          { id: 21420 /* SeekPosition */, size: 5, data: 0 }
+          {
+            id: 21420 /* SeekPosition */,
+            size: 5,
+            data: writeOffsets ? this.ebmlWriter.offsets.get(this.segmentInfo) - this.segmentDataOffset : 0
+          }
         ] },
         { id: 19899 /* Seek */, data: [
           { id: 21419 /* SeekID */, data: kaxTracks },
-          { id: 21420 /* SeekPosition */, size: 5, data: 0 }
-        ] }
+          {
+            id: 21420 /* SeekPosition */,
+            size: 5,
+            data: writeOffsets ? this.ebmlWriter.offsets.get(this.tracksElement) - this.segmentDataOffset : 0
+          }
+        ] },
+        this.attachmentsElement ? { id: 19899 /* Seek */, data: [
+          { id: 21419 /* SeekID */, data: kaxAttachments },
+          {
+            id: 21420 /* SeekPosition */,
+            size: 5,
+            data: writeOffsets ? this.ebmlWriter.offsets.get(this.attachmentsElement) - this.segmentDataOffset : 0
+          }
+        ] } : null,
+        this.tagsElement ? { id: 19899 /* Seek */, data: [
+          { id: 21419 /* SeekID */, data: kaxTags },
+          {
+            id: 21420 /* SeekPosition */,
+            size: 5,
+            data: writeOffsets ? this.ebmlWriter.offsets.get(this.tagsElement) - this.segmentDataOffset : 0
+          }
+        ] } : null
       ] };
       this.seekHead = seekHead;
     }
@@ -5971,48 +6487,221 @@ var Mediabunny = (() => {
         { id: 25506 /* CodecPrivate */, data: textEncoder.encode(trackData.info.config.description) }
       ];
     }
-    createSegment() {
-      const segment = {
-        id: 408125543 /* Segment */,
-        size: this.format._options.appendOnly ? -1 : SEGMENT_SIZE_BYTES,
-        data: [
-          !this.format._options.appendOnly ? this.seekHead : null,
-          this.segmentInfo,
-          this.tracksElement
-        ]
+    maybeCreateTags() {
+      const simpleTags = [];
+      const addSimpleTag = (key, value) => {
+        simpleTags.push({ id: 26568 /* SimpleTag */, data: [
+          { id: 17827 /* TagName */, data: new EBMLUnicodeString(key) },
+          typeof value === "string" ? { id: 17543 /* TagString */, data: new EBMLUnicodeString(value) } : { id: 17541 /* TagBinary */, data: value }
+        ] });
       };
-      this.segment = segment;
-      if (this.format._options.onSegmentHeader) {
-        this.writer.startTrackingWrites();
-      }
-      this.ebmlWriter.writeEBML(segment);
-      if (this.format._options.onSegmentHeader) {
-        const { data, start } = this.writer.stopTrackingWrites();
-        this.format._options.onSegmentHeader(data, start);
-      }
-    }
-    createCues() {
-      this.cues = { id: 475249515 /* Cues */, data: [] };
-    }
-    get segmentDataOffset() {
-      assert(this.segment);
-      return this.ebmlWriter.dataOffsets.get(this.segment);
-    }
-    allTracksAreKnown() {
-      for (const track of this.output._tracks) {
-        if (!track.source._closed && !this.trackDatas.some((x) => x.track === track)) {
-          return false;
-        }
-      }
-      return true;
-    }
-    async getMimeType() {
-      await this.allTracksKnown.promise;
-      const codecStrings = this.trackDatas.map((trackData) => {
-        if (trackData.type === "video") {
-          return trackData.info.decoderConfig.codec;
-        } else if (trackData.type === "audio") {
-          return trackData.info.decoderConfig.codec;
+      const metadataTags = this.output._metadataTags;
+      const writtenTags = /* @__PURE__ */ new Set();
+      for (const { key, value } of keyValueIterator(metadataTags)) {
+        switch (key) {
+          case "title":
+            {
+              addSimpleTag("TITLE", value);
+              writtenTags.add("TITLE");
+            }
+            ;
+            break;
+          case "description":
+            {
+              addSimpleTag("DESCRIPTION", value);
+              writtenTags.add("DESCRIPTION");
+            }
+            ;
+            break;
+          case "artist":
+            {
+              addSimpleTag("ARTIST", value);
+              writtenTags.add("ARTIST");
+            }
+            ;
+            break;
+          case "album":
+            {
+              addSimpleTag("ALBUM", value);
+              writtenTags.add("ALBUM");
+            }
+            ;
+            break;
+          case "albumArtist":
+            {
+              addSimpleTag("ALBUM_ARTIST", value);
+              writtenTags.add("ALBUM_ARTIST");
+            }
+            ;
+            break;
+          case "genre":
+            {
+              addSimpleTag("GENRE", value);
+              writtenTags.add("GENRE");
+            }
+            ;
+            break;
+          case "comment":
+            {
+              addSimpleTag("COMMENT", value);
+              writtenTags.add("COMMENT");
+            }
+            ;
+            break;
+          case "lyrics":
+            {
+              addSimpleTag("LYRICS", value);
+              writtenTags.add("LYRICS");
+            }
+            ;
+            break;
+          case "date":
+            {
+              addSimpleTag("DATE", value.toISOString().slice(0, 10));
+              writtenTags.add("DATE");
+            }
+            ;
+            break;
+          case "trackNumber":
+            {
+              const string = metadataTags.tracksTotal !== void 0 ? `${value}/${metadataTags.tracksTotal}` : value.toString();
+              addSimpleTag("PART_NUMBER", string);
+              writtenTags.add("PART_NUMBER");
+            }
+            ;
+            break;
+          case "discNumber":
+            {
+              const string = metadataTags.discsTotal !== void 0 ? `${value}/${metadataTags.discsTotal}` : value.toString();
+              addSimpleTag("DISC", string);
+              writtenTags.add("DISC");
+            }
+            ;
+            break;
+          case "tracksTotal":
+          case "discsTotal":
+            {
+            }
+            ;
+            break;
+          case "images":
+          case "raw":
+            {
+            }
+            ;
+            break;
+          default:
+            assertNever(key);
+        }
+      }
+      if (metadataTags.raw) {
+        for (const key in metadataTags.raw) {
+          const value = metadataTags.raw[key];
+          if (value == null || writtenTags.has(key)) {
+            continue;
+          }
+          if (typeof value === "string" || value instanceof Uint8Array) {
+            addSimpleTag(key, value);
+          }
+        }
+      }
+      if (simpleTags.length === 0) {
+        return;
+      }
+      this.tagsElement = {
+        id: 307544935 /* Tags */,
+        data: [{ id: 29555 /* Tag */, data: [
+          { id: 25536 /* Targets */, data: [
+            { id: 26826 /* TargetTypeValue */, data: 50 },
+            { id: 25546 /* TargetType */, data: "MOVIE" }
+          ] },
+          ...simpleTags
+        ] }]
+      };
+    }
+    maybeCreateAttachments() {
+      const metadataTags = this.output._metadataTags;
+      if (!metadataTags.images || metadataTags.images.length === 0) {
+        return;
+      }
+      const existingFileUids = /* @__PURE__ */ new Set();
+      this.attachmentsElement = { id: 423732329 /* Attachments */, data: metadataTags.images.map((image) => {
+        let imageName = image.name;
+        if (imageName === void 0) {
+          const baseName = image.kind === "coverFront" ? "cover" : image.kind === "coverBack" ? "back" : "image";
+          imageName = baseName + (imageMimeTypeToExtension(image.mimeType) ?? "");
+        }
+        let fileUid;
+        while (true) {
+          fileUid = Math.floor(Math.random() * Number.MAX_SAFE_INTEGER);
+          if (fileUid !== 0 && !existingFileUids.has(fileUid)) {
+            break;
+          }
+        }
+        existingFileUids.add(fileUid);
+        return {
+          id: 24999 /* AttachedFile */,
+          data: [
+            image.description !== void 0 ? { id: 18046 /* FileDescription */, data: new EBMLUnicodeString(image.description) } : null,
+            { id: 18030 /* FileName */, data: new EBMLUnicodeString(imageName) },
+            { id: 18016 /* FileMediaType */, data: image.mimeType },
+            { id: 18012 /* FileData */, data: image.data },
+            { id: 18094 /* FileUID */, data: fileUid }
+          ]
+        };
+      }) };
+    }
+    createSegment() {
+      this.createTracks();
+      this.maybeCreateTags();
+      this.maybeCreateAttachments();
+      this.maybeCreateSeekHead(false);
+      const segment = {
+        id: 408125543 /* Segment */,
+        size: this.format._options.appendOnly ? -1 : SEGMENT_SIZE_BYTES,
+        data: [
+          this.seekHead,
+          // null if append-only
+          this.segmentInfo,
+          this.tracksElement,
+          // Matroska spec says put this at the end of the file, but I think placing it before the first cluster
+          // makes more sense, and FFmpeg agrees (argumentum ad ffmpegum fallacy)
+          this.attachmentsElement,
+          this.tagsElement
+        ]
+      };
+      this.segment = segment;
+      if (this.format._options.onSegmentHeader) {
+        this.writer.startTrackingWrites();
+      }
+      this.ebmlWriter.writeEBML(segment);
+      if (this.format._options.onSegmentHeader) {
+        const { data, start } = this.writer.stopTrackingWrites();
+        this.format._options.onSegmentHeader(data, start);
+      }
+    }
+    createCues() {
+      this.cues = { id: 475249515 /* Cues */, data: [] };
+    }
+    get segmentDataOffset() {
+      assert(this.segment);
+      return this.ebmlWriter.dataOffsets.get(this.segment);
+    }
+    allTracksAreKnown() {
+      for (const track of this.output._tracks) {
+        if (!track.source._closed && !this.trackDatas.some((x) => x.track === track)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    async getMimeType() {
+      await this.allTracksKnown.promise;
+      const codecStrings = this.trackDatas.map((trackData) => {
+        if (trackData.type === "video") {
+          return trackData.info.decoderConfig.codec;
+        } else if (trackData.type === "audio") {
+          return trackData.info.decoderConfig.codec;
         } else {
           const map = {
             webvtt: "wvtt"
@@ -6027,23 +6716,23 @@ var Mediabunny = (() => {
         codecStrings
       });
     }
-    getVideoTrackData(track, meta) {
+    getVideoTrackData(track, meta2) {
       const existingTrackData = this.trackDatas.find((x) => x.track === track);
       if (existingTrackData) {
         return existingTrackData;
       }
-      validateVideoChunkMetadata(meta);
-      assert(meta);
-      assert(meta.decoderConfig);
-      assert(meta.decoderConfig.codedWidth !== void 0);
-      assert(meta.decoderConfig.codedHeight !== void 0);
+      validateVideoChunkMetadata(meta2);
+      assert(meta2);
+      assert(meta2.decoderConfig);
+      assert(meta2.decoderConfig.codedWidth !== void 0);
+      assert(meta2.decoderConfig.codedHeight !== void 0);
       const newTrackData = {
         track,
         type: "video",
         info: {
-          width: meta.decoderConfig.codedWidth,
-          height: meta.decoderConfig.codedHeight,
-          decoderConfig: meta.decoderConfig
+          width: meta2.decoderConfig.codedWidth,
+          height: meta2.decoderConfig.codedHeight,
+          decoderConfig: meta2.decoderConfig
         },
         chunkQueue: [],
         lastWrittenMsTimestamp: null
@@ -6070,21 +6759,21 @@ var Mediabunny = (() => {
       }
       return newTrackData;
     }
-    getAudioTrackData(track, meta) {
+    getAudioTrackData(track, meta2) {
       const existingTrackData = this.trackDatas.find((x) => x.track === track);
       if (existingTrackData) {
         return existingTrackData;
       }
-      validateAudioChunkMetadata(meta);
-      assert(meta);
-      assert(meta.decoderConfig);
+      validateAudioChunkMetadata(meta2);
+      assert(meta2);
+      assert(meta2.decoderConfig);
       const newTrackData = {
         track,
         type: "audio",
         info: {
-          numberOfChannels: meta.decoderConfig.numberOfChannels,
-          sampleRate: meta.decoderConfig.sampleRate,
-          decoderConfig: meta.decoderConfig
+          numberOfChannels: meta2.decoderConfig.numberOfChannels,
+          sampleRate: meta2.decoderConfig.sampleRate,
+          decoderConfig: meta2.decoderConfig
         },
         chunkQueue: [],
         lastWrittenMsTimestamp: null
@@ -6096,19 +6785,19 @@ var Mediabunny = (() => {
       }
       return newTrackData;
     }
-    getSubtitleTrackData(track, meta) {
+    getSubtitleTrackData(track, meta2) {
       const existingTrackData = this.trackDatas.find((x) => x.track === track);
       if (existingTrackData) {
         return existingTrackData;
       }
-      validateSubtitleMetadata(meta);
-      assert(meta);
-      assert(meta.config);
+      validateSubtitleMetadata(meta2);
+      assert(meta2);
+      assert(meta2.config);
       const newTrackData = {
         track,
         type: "subtitle",
         info: {
-          config: meta.config
+          config: meta2.config
         },
         chunkQueue: [],
         lastWrittenMsTimestamp: null
@@ -6120,10 +6809,10 @@ var Mediabunny = (() => {
       }
       return newTrackData;
     }
-    async addEncodedVideoPacket(track, packet, meta) {
+    async addEncodedVideoPacket(track, packet, meta2) {
       const release = await this.mutex.acquire();
       try {
-        const trackData = this.getVideoTrackData(track, meta);
+        const trackData = this.getVideoTrackData(track, meta2);
         const isKeyFrame = packet.type === "key";
         let timestamp = this.validateAndNormalizeTimestamp(trackData.track, packet.timestamp, isKeyFrame);
         let duration = packet.duration;
@@ -6139,10 +6828,10 @@ var Mediabunny = (() => {
         release();
       }
     }
-    async addEncodedAudioPacket(track, packet, meta) {
+    async addEncodedAudioPacket(track, packet, meta2) {
       const release = await this.mutex.acquire();
       try {
-        const trackData = this.getAudioTrackData(track, meta);
+        const trackData = this.getAudioTrackData(track, meta2);
         const isKeyFrame = packet.type === "key";
         const timestamp = this.validateAndNormalizeTimestamp(trackData.track, packet.timestamp, isKeyFrame);
         const audioChunk = this.createInternalChunk(packet.data, timestamp, packet.duration, packet.type);
@@ -6152,10 +6841,10 @@ var Mediabunny = (() => {
         release();
       }
     }
-    async addSubtitleCue(track, cue, meta) {
+    async addSubtitleCue(track, cue, meta2) {
       const release = await this.mutex.acquire();
       try {
-        const trackData = this.getSubtitleTrackData(track, meta);
+        const trackData = this.getSubtitleTrackData(track, meta2);
         const timestamp = this.validateAndNormalizeTimestamp(trackData.track, cue.timestamp, true);
         let bodyText = cue.text;
         const timestampMs = Math.round(timestamp * 1e3);
@@ -6254,7 +6943,6 @@ ${cue.notes ?? ""}`;
     /** Writes a block containing media data to the file. */
     writeBlock(trackData, chunk) {
       if (!this.segment) {
-        this.createTracks();
         this.createSegment();
       }
       const msTimestamp = Math.round(1e3 * chunk.timestamp);
@@ -6396,7 +7084,6 @@ ${cue.notes ?? ""}`;
       const release = await this.mutex.acquire();
       this.allTracksKnown.resolve();
       if (!this.segment) {
-        this.createTracks();
         this.createSegment();
       }
       await this.interleaveChunks(true);
@@ -6413,10 +7100,9 @@ ${cue.notes ?? ""}`;
         this.segmentDuration.data = new EBMLFloat64(this.duration);
         this.writer.seek(this.ebmlWriter.offsets.get(this.segmentDuration));
         this.ebmlWriter.writeEBML(this.segmentDuration);
-        this.seekHead.data[0].data[1].data = this.ebmlWriter.offsets.get(this.cues) - this.segmentDataOffset;
-        this.seekHead.data[1].data[1].data = this.ebmlWriter.offsets.get(this.segmentInfo) - this.segmentDataOffset;
-        this.seekHead.data[2].data[1].data = this.ebmlWriter.offsets.get(this.tracksElement) - this.segmentDataOffset;
+        assert(this.seekHead);
         this.writer.seek(this.ebmlWriter.offsets.get(this.seekHead));
+        this.maybeCreateSeekHead(true);
         this.ebmlWriter.writeEBML(this.seekHead);
         this.writer.seek(endPos);
       }
@@ -6532,6 +7218,726 @@ ${cue.notes ?? ""}`;
       bytesAdvanced: 1
     };
   };
+  var encodeSynchsafe = (unsynchsafed) => {
+    let mask = 127;
+    let synchsafed = 0;
+    let unsynchsafedRest = unsynchsafed;
+    while ((mask ^ 2147483647) !== 0) {
+      synchsafed = unsynchsafedRest & ~mask;
+      synchsafed <<= 1;
+      synchsafed |= unsynchsafedRest & mask;
+      mask = (mask + 1 << 8) - 1;
+      unsynchsafedRest = synchsafed;
+    }
+    return synchsafed;
+  };
+  var decodeSynchsafe = (synchsafed) => {
+    let mask = 2130706432;
+    let unsynchsafed = 0;
+    while (mask !== 0) {
+      unsynchsafed >>= 1;
+      unsynchsafed |= synchsafed & mask;
+      mask >>= 8;
+    }
+    return unsynchsafed;
+  };
+
+  // src/mp3/mp3-reader.ts
+  var ID3_V1_TAG_SIZE = 128;
+  var ID3_V2_HEADER_SIZE = 10;
+  var ID3_V1_GENRES = [
+    "Blues",
+    "Classic rock",
+    "Country",
+    "Dance",
+    "Disco",
+    "Funk",
+    "Grunge",
+    "Hip-hop",
+    "Jazz",
+    "Metal",
+    "New age",
+    "Oldies",
+    "Other",
+    "Pop",
+    "Rhythm and blues",
+    "Rap",
+    "Reggae",
+    "Rock",
+    "Techno",
+    "Industrial",
+    "Alternative",
+    "Ska",
+    "Death metal",
+    "Pranks",
+    "Soundtrack",
+    "Euro-techno",
+    "Ambient",
+    "Trip-hop",
+    "Vocal",
+    "Jazz & funk",
+    "Fusion",
+    "Trance",
+    "Classical",
+    "Instrumental",
+    "Acid",
+    "House",
+    "Game",
+    "Sound clip",
+    "Gospel",
+    "Noise",
+    "Alternative rock",
+    "Bass",
+    "Soul",
+    "Punk",
+    "Space",
+    "Meditative",
+    "Instrumental pop",
+    "Instrumental rock",
+    "Ethnic",
+    "Gothic",
+    "Darkwave",
+    "Techno-industrial",
+    "Electronic",
+    "Pop-folk",
+    "Eurodance",
+    "Dream",
+    "Southern rock",
+    "Comedy",
+    "Cult",
+    "Gangsta",
+    "Top 40",
+    "Christian rap",
+    "Pop/funk",
+    "Jungle music",
+    "Native US",
+    "Cabaret",
+    "New wave",
+    "Psychedelic",
+    "Rave",
+    "Showtunes",
+    "Trailer",
+    "Lo-fi",
+    "Tribal",
+    "Acid punk",
+    "Acid jazz",
+    "Polka",
+    "Retro",
+    "Musical",
+    "Rock 'n' roll",
+    "Hard rock",
+    "Folk",
+    "Folk rock",
+    "National folk",
+    "Swing",
+    "Fast fusion",
+    "Bebop",
+    "Latin",
+    "Revival",
+    "Celtic",
+    "Bluegrass",
+    "Avantgarde",
+    "Gothic rock",
+    "Progressive rock",
+    "Psychedelic rock",
+    "Symphonic rock",
+    "Slow rock",
+    "Big band",
+    "Chorus",
+    "Easy listening",
+    "Acoustic",
+    "Humour",
+    "Speech",
+    "Chanson",
+    "Opera",
+    "Chamber music",
+    "Sonata",
+    "Symphony",
+    "Booty bass",
+    "Primus",
+    "Porn groove",
+    "Satire",
+    "Slow jam",
+    "Club",
+    "Tango",
+    "Samba",
+    "Folklore",
+    "Ballad",
+    "Power ballad",
+    "Rhythmic Soul",
+    "Freestyle",
+    "Duet",
+    "Punk rock",
+    "Drum solo",
+    "A cappella",
+    "Euro-house",
+    "Dance hall",
+    "Goa music",
+    "Drum & bass",
+    "Club-house",
+    "Hardcore techno",
+    "Terror",
+    "Indie",
+    "Britpop",
+    "Negerpunk",
+    "Polsk punk",
+    "Beat",
+    "Christian gangsta rap",
+    "Heavy metal",
+    "Black metal",
+    "Crossover",
+    "Contemporary Christian",
+    "Christian rock",
+    "Merengue",
+    "Salsa",
+    "Thrash metal",
+    "Anime",
+    "Jpop",
+    "Synthpop",
+    "Christmas",
+    "Art rock",
+    "Baroque",
+    "Bhangra",
+    "Big beat",
+    "Breakbeat",
+    "Chillout",
+    "Downtempo",
+    "Dub",
+    "EBM",
+    "Eclectic",
+    "Electro",
+    "Electroclash",
+    "Emo",
+    "Experimental",
+    "Garage",
+    "Global",
+    "IDM",
+    "Illbient",
+    "Industro-Goth",
+    "Jam Band",
+    "Krautrock",
+    "Leftfield",
+    "Lounge",
+    "Math rock",
+    "New romantic",
+    "Nu-breakz",
+    "Post-punk",
+    "Post-rock",
+    "Psytrance",
+    "Shoegaze",
+    "Space rock",
+    "Trop rock",
+    "World music",
+    "Neoclassical",
+    "Audiobook",
+    "Audio theatre",
+    "Neue Deutsche Welle",
+    "Podcast",
+    "Indie rock",
+    "G-Funk",
+    "Dubstep",
+    "Garage rock",
+    "Psybient"
+  ];
+  var readNextFrameHeader = async (reader, startPos, until) => {
+    let currentPos = startPos;
+    while (until === null || currentPos < until) {
+      let slice = reader.requestSlice(currentPos, FRAME_HEADER_SIZE);
+      if (slice instanceof Promise) slice = await slice;
+      if (!slice) break;
+      const word = readU32Be(slice);
+      const result = readFrameHeader(word, reader.fileSize !== null ? reader.fileSize - currentPos : null);
+      if (result.header) {
+        return { header: result.header, startPos: currentPos };
+      }
+      currentPos += result.bytesAdvanced;
+    }
+    return null;
+  };
+  var parseId3V1Tag = (slice, tags) => {
+    const startPos = slice.filePos;
+    tags.raw ??= {};
+    tags.raw["TAG"] ??= readBytes(slice, ID3_V1_TAG_SIZE - 3);
+    slice.filePos = startPos;
+    const title = readId3V1String(slice, 30);
+    if (title) tags.title ??= title;
+    const artist = readId3V1String(slice, 30);
+    if (artist) tags.artist ??= artist;
+    const album = readId3V1String(slice, 30);
+    if (album) tags.album ??= album;
+    const yearText = readId3V1String(slice, 4);
+    const year = Number.parseInt(yearText, 10);
+    if (Number.isInteger(year) && year > 0) {
+      tags.date ??= new Date(year, 0, 1);
+    }
+    const commentBytes = readBytes(slice, 30);
+    let comment;
+    if (commentBytes[28] === 0 && commentBytes[29] !== 0) {
+      const trackNum = commentBytes[29];
+      if (trackNum > 0) {
+        tags.trackNumber ??= trackNum;
+      }
+      slice.skip(-30);
+      comment = readId3V1String(slice, 28);
+      slice.skip(2);
+    } else {
+      slice.skip(-30);
+      comment = readId3V1String(slice, 30);
+    }
+    if (comment) tags.comment ??= comment;
+    const genreIndex = readU8(slice);
+    if (genreIndex < ID3_V1_GENRES.length) {
+      tags.genre ??= ID3_V1_GENRES[genreIndex];
+    }
+  };
+  var readId3V1String = (slice, length) => {
+    const bytes2 = readBytes(slice, length);
+    const endIndex = coalesceIndex(bytes2.indexOf(0), bytes2.length);
+    const relevantBytes = bytes2.subarray(0, endIndex);
+    let str = "";
+    for (let i = 0; i < relevantBytes.length; i++) {
+      str += String.fromCharCode(relevantBytes[i]);
+    }
+    return str.trimEnd();
+  };
+  var readId3V2Header = (slice) => {
+    const startPos = slice.filePos;
+    const tag = readAscii(slice, 3);
+    const majorVersion = readU8(slice);
+    const revision = readU8(slice);
+    const flags = readU8(slice);
+    const sizeRaw = readU32Be(slice);
+    if (tag !== "ID3" || majorVersion === 255 || revision === 255 || (sizeRaw & 2155905152) !== 0) {
+      slice.filePos = startPos;
+      return null;
+    }
+    const size = decodeSynchsafe(sizeRaw);
+    return { majorVersion, revision, flags, size };
+  };
+  var parseId3V2Tag = (slice, header, tags) => {
+    if (![2, 3, 4].includes(header.majorVersion)) {
+      console.warn(`Unsupported ID3v2 major version: ${header.majorVersion}`);
+      return;
+    }
+    const bytes2 = readBytes(slice, header.size);
+    const reader = new Id3V2Reader(header, bytes2);
+    if (header.flags & 16 /* Footer */) {
+      reader.removeFooter();
+    }
+    if (header.flags & 128 /* Unsynchronisation */ && header.majorVersion === 3) {
+      reader.ununsynchronizeAll();
+    }
+    if (header.flags & 64 /* ExtendedHeader */) {
+      const extendedHeaderSize = reader.readU32();
+      if (header.majorVersion === 3) {
+        reader.pos += extendedHeaderSize;
+      } else {
+        reader.pos += extendedHeaderSize - 4;
+      }
+    }
+    while (reader.pos <= reader.bytes.length - reader.frameHeaderSize()) {
+      const frame = reader.readId3V2Frame();
+      if (!frame) {
+        break;
+      }
+      const frameStartPos = reader.pos;
+      const frameEndPos = reader.pos + frame.size;
+      let frameEncrypted = false;
+      let frameCompressed = false;
+      let frameUnsynchronized = false;
+      if (header.majorVersion === 3) {
+        frameEncrypted = !!(frame.flags & 1 << 6);
+        frameCompressed = !!(frame.flags & 1 << 7);
+      } else if (header.majorVersion === 4) {
+        frameEncrypted = !!(frame.flags & 1 << 2);
+        frameCompressed = !!(frame.flags & 1 << 3);
+        frameUnsynchronized = !!(frame.flags & 1 << 1) || !!(header.flags & 128 /* Unsynchronisation */);
+      }
+      if (frameEncrypted) {
+        console.warn(`Skipping encrypted ID3v2 frame ${frame.id}`);
+        reader.pos = frameEndPos;
+        continue;
+      }
+      if (frameCompressed) {
+        console.warn(`Skipping compressed ID3v2 frame ${frame.id}`);
+        reader.pos = frameEndPos;
+        continue;
+      }
+      if (frameUnsynchronized) {
+        reader.ununsynchronizeRegion(reader.pos, frameEndPos);
+      }
+      tags.raw ??= {};
+      if (frame.id[0] === "T") {
+        tags.raw[frame.id] ??= reader.readId3V2EncodingAndText(frameEndPos);
+      } else {
+        tags.raw[frame.id] ??= reader.readBytes(frame.size);
+      }
+      reader.pos = frameStartPos;
+      switch (frame.id) {
+        case "TIT2":
+        case "TT2":
+          {
+            tags.title ??= reader.readId3V2EncodingAndText(frameEndPos);
+          }
+          ;
+          break;
+        case "TIT3":
+        case "TT3":
+          {
+            tags.description ??= reader.readId3V2EncodingAndText(frameEndPos);
+          }
+          ;
+          break;
+        case "TPE1":
+        case "TP1":
+          {
+            tags.artist ??= reader.readId3V2EncodingAndText(frameEndPos);
+          }
+          ;
+          break;
+        case "TALB":
+        case "TAL":
+          {
+            tags.album ??= reader.readId3V2EncodingAndText(frameEndPos);
+          }
+          ;
+          break;
+        case "TPE2":
+        case "TP2":
+          {
+            tags.albumArtist ??= reader.readId3V2EncodingAndText(frameEndPos);
+          }
+          ;
+          break;
+        case "TRCK":
+        case "TRK":
+          {
+            const trackText = reader.readId3V2EncodingAndText(frameEndPos);
+            const parts = trackText.split("/");
+            const trackNum = Number.parseInt(parts[0], 10);
+            const tracksTotal = parts[1] && Number.parseInt(parts[1], 10);
+            if (Number.isInteger(trackNum) && trackNum > 0) {
+              tags.trackNumber ??= trackNum;
+            }
+            if (tracksTotal && Number.isInteger(tracksTotal) && tracksTotal > 0) {
+              tags.tracksTotal ??= tracksTotal;
+            }
+          }
+          ;
+          break;
+        case "TPOS":
+        case "TPA":
+          {
+            const discText = reader.readId3V2EncodingAndText(frameEndPos);
+            const parts = discText.split("/");
+            const discNum = Number.parseInt(parts[0], 10);
+            const discsTotal = parts[1] && Number.parseInt(parts[1], 10);
+            if (Number.isInteger(discNum) && discNum > 0) {
+              tags.discNumber ??= discNum;
+            }
+            if (discsTotal && Number.isInteger(discsTotal) && discsTotal > 0) {
+              tags.discsTotal ??= discsTotal;
+            }
+          }
+          ;
+          break;
+        case "TCON":
+        case "TCO":
+          {
+            const genreText = reader.readId3V2EncodingAndText(frameEndPos);
+            let match = /^\((\d+)\)/.exec(genreText);
+            if (match) {
+              const genreNumber = Number.parseInt(match[1]);
+              if (ID3_V1_GENRES[genreNumber] !== void 0) {
+                tags.genre ??= ID3_V1_GENRES[genreNumber];
+                break;
+              }
+            }
+            match = /^\d+$/.exec(genreText);
+            if (match) {
+              const genreNumber = Number.parseInt(match[0]);
+              if (ID3_V1_GENRES[genreNumber] !== void 0) {
+                tags.genre ??= ID3_V1_GENRES[genreNumber];
+                break;
+              }
+            }
+            tags.genre ??= genreText;
+          }
+          ;
+          break;
+        case "TDRC":
+        case "TDAT":
+          {
+            const dateText = reader.readId3V2EncodingAndText(frameEndPos);
+            const date = new Date(dateText);
+            if (!Number.isNaN(date.getTime())) {
+              tags.date ??= date;
+            }
+          }
+          ;
+          break;
+        case "TYER":
+        case "TYE":
+          {
+            const yearText = reader.readId3V2EncodingAndText(frameEndPos);
+            const year = Number.parseInt(yearText, 10);
+            if (Number.isInteger(year)) {
+              tags.date ??= new Date(year, 0, 1);
+            }
+          }
+          ;
+          break;
+        case "USLT":
+        case "ULT":
+          {
+            const encoding = reader.readU8();
+            reader.pos += 3;
+            reader.readId3V2Text(encoding, frameEndPos);
+            tags.lyrics ??= reader.readId3V2Text(encoding, frameEndPos);
+          }
+          ;
+          break;
+        case "COMM":
+        case "COM":
+          {
+            const encoding = reader.readU8();
+            reader.pos += 3;
+            reader.readId3V2Text(encoding, frameEndPos);
+            tags.comment ??= reader.readId3V2Text(encoding, frameEndPos);
+          }
+          ;
+          break;
+        case "APIC":
+        case "PIC":
+          {
+            const encoding = reader.readId3V2TextEncoding();
+            let mimeType;
+            if (header.majorVersion === 2) {
+              const imageFormat = reader.readAscii(3);
+              mimeType = imageFormat === "PNG" ? "image/png" : imageFormat === "JPG" ? "image/jpeg" : "image/*";
+            } else {
+              mimeType = reader.readId3V2Text(encoding, frameEndPos);
+            }
+            const pictureType = reader.readU8();
+            const description = reader.readId3V2Text(encoding, frameEndPos).trimEnd();
+            const imageDataSize = frameEndPos - reader.pos;
+            if (imageDataSize >= 0) {
+              const imageData = reader.readBytes(imageDataSize);
+              if (!tags.images) tags.images = [];
+              tags.images.push({
+                data: imageData,
+                mimeType,
+                kind: pictureType === 3 ? "coverFront" : pictureType === 4 ? "coverBack" : "unknown",
+                description
+              });
+            }
+          }
+          ;
+          break;
+        default:
+          {
+            reader.pos += frame.size;
+          }
+          ;
+          break;
+      }
+      reader.pos = frameEndPos;
+    }
+  };
+  var Id3V2Reader = class {
+    constructor(header, bytes2) {
+      this.header = header;
+      this.bytes = bytes2;
+      this.pos = 0;
+      this.view = new DataView(bytes2.buffer, bytes2.byteOffset, bytes2.byteLength);
+    }
+    frameHeaderSize() {
+      return this.header.majorVersion === 2 ? 6 : 10;
+    }
+    ununsynchronizeAll() {
+      const newBytes = [];
+      for (let i = 0; i < this.bytes.length; i++) {
+        const value1 = this.bytes[i];
+        newBytes.push(value1);
+        if (value1 === 255 && i !== this.bytes.length - 1) {
+          const value2 = this.bytes[i];
+          if (value2 === 0) {
+            i++;
+          }
+        }
+      }
+      this.bytes = new Uint8Array(newBytes);
+      this.view = new DataView(this.bytes.buffer);
+    }
+    ununsynchronizeRegion(start, end) {
+      const newBytes = [];
+      for (let i = start; i < end; i++) {
+        const value1 = this.bytes[i];
+        newBytes.push(value1);
+        if (value1 === 255 && i !== end - 1) {
+          const value2 = this.bytes[i + 1];
+          if (value2 === 0) {
+            i++;
+          }
+        }
+      }
+      const before = this.bytes.subarray(0, start);
+      const after = this.bytes.subarray(end);
+      this.bytes = new Uint8Array(before.length + newBytes.length + after.length);
+      this.bytes.set(before, 0);
+      this.bytes.set(newBytes, before.length);
+      this.bytes.set(after, before.length + newBytes.length);
+      this.view = new DataView(this.bytes.buffer);
+    }
+    removeFooter() {
+      this.bytes = this.bytes.subarray(0, this.bytes.length - ID3_V2_HEADER_SIZE);
+      this.view = new DataView(this.bytes.buffer);
+    }
+    readBytes(length) {
+      const slice = this.bytes.subarray(this.pos, this.pos + length);
+      this.pos += length;
+      return slice;
+    }
+    readU8() {
+      const value = this.view.getUint8(this.pos);
+      this.pos += 1;
+      return value;
+    }
+    readU16() {
+      const value = this.view.getUint16(this.pos, false);
+      this.pos += 2;
+      return value;
+    }
+    readU24() {
+      const high = this.view.getUint16(this.pos, false);
+      const low = this.view.getUint8(this.pos + 1);
+      this.pos += 3;
+      return high * 256 + low;
+    }
+    readU32() {
+      const value = this.view.getUint32(this.pos, false);
+      this.pos += 4;
+      return value;
+    }
+    readAscii(length) {
+      let str = "";
+      for (let i = 0; i < length; i++) {
+        str += String.fromCharCode(this.view.getUint8(this.pos + i));
+      }
+      this.pos += length;
+      return str;
+    }
+    readId3V2Frame() {
+      if (this.header.majorVersion === 2) {
+        const id = this.readAscii(3);
+        if (id === "\0\0\0") {
+          return null;
+        }
+        const size = this.readU24();
+        return { id, size, flags: 0 };
+      } else {
+        const id = this.readAscii(4);
+        if (id === "\0\0\0\0") {
+          return null;
+        }
+        const sizeRaw = this.readU32();
+        let size = this.header.majorVersion === 4 ? decodeSynchsafe(sizeRaw) : sizeRaw;
+        const flags = this.readU16();
+        const headerEndPos = this.pos;
+        const isSizeValid = (size2) => {
+          const nextPos = this.pos + size2;
+          if (nextPos > this.bytes.length) {
+            return false;
+          }
+          if (nextPos <= this.bytes.length - this.frameHeaderSize()) {
+            this.pos += size2;
+            const nextId = this.readAscii(4);
+            if (nextId !== "\0\0\0\0" && !/[0-9A-Z]{4}/.test(nextId)) {
+              return false;
+            }
+          }
+          return true;
+        };
+        if (!isSizeValid(size)) {
+          const otherSize = this.header.majorVersion === 4 ? sizeRaw : decodeSynchsafe(sizeRaw);
+          if (isSizeValid(otherSize)) {
+            size = otherSize;
+          }
+        }
+        this.pos = headerEndPos;
+        return { id, size, flags };
+      }
+    }
+    readId3V2TextEncoding() {
+      const number = this.readU8();
+      if (number > 3) {
+        throw new Error(`Unsupported text encoding: ${number}`);
+      }
+      return number;
+    }
+    readId3V2Text(encoding, until) {
+      const startPos = this.pos;
+      const data = this.readBytes(until);
+      switch (encoding) {
+        case 0 /* ISO_8859_1 */: {
+          let str = "";
+          for (let i = 0; i < data.length; i++) {
+            const value = data[i];
+            if (value === 0) {
+              this.pos = startPos + i + 1;
+              break;
+            }
+            str += String.fromCharCode(value);
+          }
+          return str;
+        }
+        case 1 /* UTF_16_WITH_BOM */: {
+          if (data[0] === 255 && data[1] === 254) {
+            const decoder = new TextDecoder("utf-16le");
+            const endIndex = coalesceIndex(
+              data.findIndex((x, i) => x === 0 && data[i + 1] === 0 && i % 2 === 0),
+              data.length
+            );
+            this.pos = startPos + Math.min(endIndex + 2, data.length);
+            return decoder.decode(data.subarray(2, endIndex));
+          } else if (data[0] === 254 && data[1] === 255) {
+            const decoder = new TextDecoder("utf-16be");
+            const endIndex = coalesceIndex(
+              data.findIndex((x, i) => x === 0 && data[i + 1] === 0 && i % 2 === 0),
+              data.length
+            );
+            this.pos = startPos + Math.min(endIndex + 2, data.length);
+            return decoder.decode(data.subarray(2, endIndex));
+          } else {
+            const endIndex = coalesceIndex(data.findIndex((x) => x === 0), data.length);
+            this.pos = startPos + Math.min(endIndex + 1, data.length);
+            return textDecoder.decode(data.subarray(0, endIndex));
+          }
+        }
+        case 2 /* UTF_16_BE_NO_BOM */: {
+          const decoder = new TextDecoder("utf-16be");
+          const endIndex = coalesceIndex(
+            data.findIndex((x, i) => x === 0 && data[i + 1] === 0 && i % 2 === 0),
+            data.length
+          );
+          this.pos = startPos + Math.min(endIndex + 2, data.length);
+          return decoder.decode(data.subarray(0, endIndex));
+        }
+        case 3 /* UTF_8 */: {
+          const endIndex = coalesceIndex(data.findIndex((x) => x === 0), data.length);
+          this.pos = startPos + Math.min(endIndex + 1, data.length);
+          return textDecoder.decode(data.subarray(0, endIndex));
+        }
+      }
+    }
+    readId3V2EncodingAndText(until) {
+      if (this.pos >= until) {
+        return "";
+      }
+      const encoding = this.readId3V2TextEncoding();
+      return this.readId3V2Text(encoding, until);
+    }
+  };
 
   // src/mp3/mp3-writer.ts
   var Mp3Writer = class {
@@ -6540,10 +7946,112 @@ ${cue.notes ?? ""}`;
       this.helper = new Uint8Array(8);
       this.helperView = new DataView(this.helper.buffer);
     }
+    writeU8(value) {
+      this.helper[0] = value;
+      this.writer.write(this.helper.subarray(0, 1));
+    }
+    writeU16(value) {
+      this.helperView.setUint16(0, value, false);
+      this.writer.write(this.helper.subarray(0, 2));
+    }
     writeU32(value) {
       this.helperView.setUint32(0, value, false);
       this.writer.write(this.helper.subarray(0, 4));
     }
+    writeAscii(text) {
+      for (let i = 0; i < text.length; i++) {
+        this.helper[i] = text.charCodeAt(i);
+      }
+      this.writer.write(this.helper.subarray(0, text.length));
+    }
+    writeSynchsafeU32(value) {
+      this.writeU32(encodeSynchsafe(value));
+    }
+    writeIsoString(text) {
+      const bytes2 = new Uint8Array(text.length + 1);
+      for (let i = 0; i < text.length; i++) {
+        bytes2[i] = text.charCodeAt(i);
+      }
+      bytes2[text.length] = 0;
+      this.writer.write(bytes2);
+    }
+    writeUtf8String(text) {
+      const utf8Data = textEncoder.encode(text);
+      this.writer.write(utf8Data);
+      this.writeU8(0);
+    }
+    writeId3V2TextFrame(frameId, text) {
+      const useIso88591 = isIso88591Compatible(text);
+      const textDataLength = useIso88591 ? text.length : textEncoder.encode(text).byteLength;
+      const frameSize = 1 + textDataLength + 1;
+      this.writeAscii(frameId);
+      this.writeSynchsafeU32(frameSize);
+      this.writeU16(0);
+      this.writeU8(useIso88591 ? 0 /* ISO_8859_1 */ : 3 /* UTF_8 */);
+      if (useIso88591) {
+        this.writeIsoString(text);
+      } else {
+        this.writeUtf8String(text);
+      }
+    }
+    writeId3V2LyricsFrame(lyrics) {
+      const useIso88591 = isIso88591Compatible(lyrics);
+      const shortDescription = "";
+      const frameSize = 1 + 3 + shortDescription.length + 1 + lyrics.length + 1;
+      this.writeAscii("USLT");
+      this.writeSynchsafeU32(frameSize);
+      this.writeU16(0);
+      this.writeU8(useIso88591 ? 0 /* ISO_8859_1 */ : 3 /* UTF_8 */);
+      this.writeAscii("und");
+      if (useIso88591) {
+        this.writeIsoString(shortDescription);
+        this.writeIsoString(lyrics);
+      } else {
+        this.writeUtf8String(shortDescription);
+        this.writeUtf8String(lyrics);
+      }
+    }
+    writeId3V2CommentFrame(comment) {
+      const useIso88591 = isIso88591Compatible(comment);
+      const textDataLength = useIso88591 ? comment.length : textEncoder.encode(comment).byteLength;
+      const shortDescription = "";
+      const frameSize = 1 + 3 + shortDescription.length + 1 + textDataLength + 1;
+      this.writeAscii("COMM");
+      this.writeSynchsafeU32(frameSize);
+      this.writeU16(0);
+      this.writeU8(useIso88591 ? 0 /* ISO_8859_1 */ : 3 /* UTF_8 */);
+      this.writeU8(117);
+      this.writeU8(110);
+      this.writeU8(100);
+      if (useIso88591) {
+        this.writeIsoString(shortDescription);
+        this.writeIsoString(comment);
+      } else {
+        this.writeUtf8String(shortDescription);
+        this.writeUtf8String(comment);
+      }
+    }
+    writeId3V2ApicFrame(mimeType, pictureType, description, imageData) {
+      const useIso88591 = isIso88591Compatible(mimeType) && isIso88591Compatible(description);
+      const descriptionDataLength = useIso88591 ? description.length : textEncoder.encode(description).byteLength;
+      const frameSize = 1 + mimeType.length + 1 + 1 + descriptionDataLength + 1 + imageData.byteLength;
+      this.writeAscii("APIC");
+      this.writeSynchsafeU32(frameSize);
+      this.writeU16(0);
+      this.writeU8(useIso88591 ? 0 /* ISO_8859_1 */ : 3 /* UTF_8 */);
+      if (useIso88591) {
+        this.writeIsoString(mimeType);
+      } else {
+        this.writeUtf8String(mimeType);
+      }
+      this.writeU8(pictureType);
+      if (useIso88591) {
+        this.writeIsoString(description);
+      } else {
+        this.writeUtf8String(description);
+      }
+      this.writer.write(imageData);
+    }
     writeXingFrame(data) {
       const startPos = this.writer.getPos();
       const firstByte = 255;
@@ -6601,11 +8109,15 @@ ${cue.notes ?? ""}`;
       this.xingFrameData = null;
       this.frameCount = 0;
       this.framePositions = [];
+      this.xingFramePos = null;
       this.format = format;
       this.writer = output._writer;
       this.mp3Writer = new Mp3Writer(output._writer);
     }
     async start() {
+      if (!metadataTagsAreEmpty(this.output._metadataTags)) {
+        this.writeId3v2Tag(this.output._metadataTags);
+      }
     }
     async getMimeType() {
       return "audio/mpeg";
@@ -6648,6 +8160,7 @@ ${cue.notes ?? ""}`;
             fileSize: null,
             toc: null
           };
+          this.xingFramePos = this.writer.getPos();
           this.mp3Writer.writeXingFrame(this.xingFrameData);
           this.frameCount++;
         }
@@ -6665,13 +8178,157 @@ ${cue.notes ?? ""}`;
     async addSubtitleCue() {
       throw new Error("MP3 does not support subtitles.");
     }
+    writeId3v2Tag(tags) {
+      this.mp3Writer.writeAscii("ID3");
+      this.mp3Writer.writeU8(4);
+      this.mp3Writer.writeU8(0);
+      this.mp3Writer.writeU8(0);
+      this.mp3Writer.writeSynchsafeU32(0);
+      const startPos = this.writer.getPos();
+      const writtenTags = /* @__PURE__ */ new Set();
+      for (const { key, value } of keyValueIterator(tags)) {
+        switch (key) {
+          case "title":
+            {
+              this.mp3Writer.writeId3V2TextFrame("TIT2", value);
+              writtenTags.add("TIT2");
+            }
+            ;
+            break;
+          case "description":
+            {
+              this.mp3Writer.writeId3V2TextFrame("TIT3", value);
+              writtenTags.add("TIT3");
+            }
+            ;
+            break;
+          case "artist":
+            {
+              this.mp3Writer.writeId3V2TextFrame("TPE1", value);
+              writtenTags.add("TPE1");
+            }
+            ;
+            break;
+          case "album":
+            {
+              this.mp3Writer.writeId3V2TextFrame("TALB", value);
+              writtenTags.add("TALB");
+            }
+            ;
+            break;
+          case "albumArtist":
+            {
+              this.mp3Writer.writeId3V2TextFrame("TPE2", value);
+              writtenTags.add("TPE2");
+            }
+            ;
+            break;
+          case "trackNumber":
+            {
+              const string = tags.tracksTotal !== void 0 ? `${value}/${tags.tracksTotal}` : value.toString();
+              this.mp3Writer.writeId3V2TextFrame("TRCK", string);
+              writtenTags.add("TRCK");
+            }
+            ;
+            break;
+          case "discNumber":
+            {
+              const string = tags.discsTotal !== void 0 ? `${value}/${tags.discsTotal}` : value.toString();
+              this.mp3Writer.writeId3V2TextFrame("TPOS", string);
+              writtenTags.add("TPOS");
+            }
+            ;
+            break;
+          case "genre":
+            {
+              this.mp3Writer.writeId3V2TextFrame("TCON", value);
+              writtenTags.add("TCON");
+            }
+            ;
+            break;
+          case "date":
+            {
+              this.mp3Writer.writeId3V2TextFrame("TDRC", value.toISOString().slice(0, 10));
+              writtenTags.add("TDRC");
+            }
+            ;
+            break;
+          case "lyrics":
+            {
+              this.mp3Writer.writeId3V2LyricsFrame(value);
+              writtenTags.add("USLT");
+            }
+            ;
+            break;
+          case "comment":
+            {
+              this.mp3Writer.writeId3V2CommentFrame(value);
+              writtenTags.add("COMM");
+            }
+            ;
+            break;
+          case "images":
+            {
+              const pictureTypeMap = { coverFront: 3, coverBack: 4, unknown: 0 };
+              for (const image of value) {
+                const pictureType = pictureTypeMap[image.kind];
+                const description = image.description ?? "";
+                this.mp3Writer.writeId3V2ApicFrame(image.mimeType, pictureType, description, image.data);
+              }
+            }
+            ;
+            break;
+          case "tracksTotal":
+          case "discsTotal":
+            {
+            }
+            ;
+            break;
+          case "raw":
+            {
+            }
+            ;
+            break;
+          default:
+            assertNever(key);
+        }
+      }
+      if (tags.raw) {
+        for (const key in tags.raw) {
+          const value = tags.raw[key];
+          if (value == null || key.length !== 4 || writtenTags.has(key)) {
+            continue;
+          }
+          let bytes2;
+          if (typeof value === "string") {
+            const encoded = textEncoder.encode(value);
+            bytes2 = new Uint8Array(encoded.byteLength + 2);
+            bytes2[0] = 3 /* UTF_8 */;
+            bytes2.set(encoded, 1);
+          } else if (value instanceof Uint8Array) {
+            bytes2 = value;
+          } else {
+            continue;
+          }
+          this.mp3Writer.writeAscii(key);
+          this.mp3Writer.writeSynchsafeU32(bytes2.byteLength);
+          this.mp3Writer.writeU16(0);
+          this.writer.write(bytes2);
+        }
+      }
+      const endPos = this.writer.getPos();
+      const framesSize = endPos - startPos;
+      this.writer.seek(6);
+      this.mp3Writer.writeSynchsafeU32(framesSize);
+      this.writer.seek(endPos);
+    }
     async finalize() {
-      if (!this.xingFrameData) {
+      if (!this.xingFrameData || this.xingFramePos === null) {
         return;
       }
       const release = await this.mutex.acquire();
       const endPos = this.writer.getPos();
-      this.writer.seek(0);
+      this.writer.seek(this.xingFramePos);
       const toc = new Uint8Array(100);
       for (let i = 0; i < 100; i++) {
         const index = Math.floor(this.framePositions.length * (i / 100));
@@ -6841,7 +8498,7 @@ ${cue.notes ?? ""}`;
     addEncodedVideoPacket() {
       throw new Error("Video tracks are not supported.");
     }
-    getTrackData(track, meta) {
+    getTrackData(track, meta2) {
       const existingTrackData = this.trackDatas.find((td) => td.track === track);
       if (existingTrackData) {
         return existingTrackData;
@@ -6851,13 +8508,13 @@ ${cue.notes ?? ""}`;
         serialNumber = Math.floor(2 ** 32 * Math.random());
       } while (this.trackDatas.some((td) => td.serialNumber === serialNumber));
       assert(track.source._codec === "vorbis" || track.source._codec === "opus");
-      validateAudioChunkMetadata(meta);
-      assert(meta);
-      assert(meta.decoderConfig);
+      validateAudioChunkMetadata(meta2);
+      assert(meta2);
+      assert(meta2.decoderConfig);
       const newTrackData = {
         track,
         serialNumber,
-        internalSampleRate: track.source._codec === "opus" ? OPUS_INTERNAL_SAMPLE_RATE : meta.decoderConfig.sampleRate,
+        internalSampleRate: track.source._codec === "opus" ? OPUS_INTERNAL_SAMPLE_RATE : meta2.decoderConfig.sampleRate,
         codecInfo: {
           codec: track.source._codec,
           vorbisInfo: null,
@@ -6873,18 +8530,18 @@ ${cue.notes ?? ""}`;
         currentPageSize: 27,
         currentPageStartsWithFreshPacket: true
       };
-      this.queueHeaderPackets(newTrackData, meta);
+      this.queueHeaderPackets(newTrackData, meta2);
       this.trackDatas.push(newTrackData);
       if (this.allTracksAreKnown()) {
         this.allTracksKnown.resolve();
       }
       return newTrackData;
     }
-    queueHeaderPackets(trackData, meta) {
-      assert(meta.decoderConfig);
+    queueHeaderPackets(trackData, meta2) {
+      assert(meta2.decoderConfig);
       if (trackData.track.source._codec === "vorbis") {
-        assert(meta.decoderConfig.description);
-        const bytes2 = toUint8Array(meta.decoderConfig.description);
+        assert(meta2.decoderConfig.description);
+        const bytes2 = toUint8Array(meta2.decoderConfig.description);
         if (bytes2[0] !== 2) {
           throw new TypeError("First byte of Vorbis decoder description must be 2.");
         }
@@ -6909,8 +8566,17 @@ ${cue.notes ?? ""}`;
           throw new TypeError("Vorbis decoder description is too short.");
         }
         const identificationHeader = bytes2.subarray(pos, pos += identificationHeaderLength);
-        const commentHeader = bytes2.subarray(pos, pos += commentHeaderLength);
+        pos += commentHeaderLength;
         const setupHeader = bytes2.subarray(pos);
+        const commentHeaderHeader = new Uint8Array(7);
+        commentHeaderHeader[0] = 3;
+        commentHeaderHeader[1] = 118;
+        commentHeaderHeader[2] = 111;
+        commentHeaderHeader[3] = 114;
+        commentHeaderHeader[4] = 98;
+        commentHeaderHeader[5] = 105;
+        commentHeaderHeader[6] = 115;
+        const commentHeader = this.createVorbisComments(commentHeaderHeader);
         trackData.packetQueue.push({
           data: identificationHeader,
           endGranulePosition: 0,
@@ -6938,16 +8604,15 @@ ${cue.notes ?? ""}`;
           modeBlockflags: parseModesFromVorbisSetupPacket(setupHeader).modeBlockflags
         };
       } else if (trackData.track.source._codec === "opus") {
-        if (!meta.decoderConfig.description) {
+        if (!meta2.decoderConfig.description) {
           throw new TypeError("For Ogg, Opus decoder description is required.");
         }
-        const identificationHeader = toUint8Array(meta.decoderConfig.description);
-        const commentHeader = new Uint8Array(8 + 4 + 4);
-        const view2 = new DataView(commentHeader.buffer);
-        view2.setUint32(0, 1332770163, false);
-        view2.setUint32(4, 1415669619, false);
-        view2.setUint32(8, 0, true);
-        view2.setUint32(12, 0, true);
+        const identificationHeader = toUint8Array(meta2.decoderConfig.description);
+        const commentHeaderHeader = new Uint8Array(8);
+        const commentHeaderHeaderView = toDataView(commentHeaderHeader);
+        commentHeaderHeaderView.setUint32(0, 1332770163, false);
+        commentHeaderHeaderView.setUint32(4, 1415669619, false);
+        const commentHeader = this.createVorbisComments(commentHeaderHeader);
         trackData.packetQueue.push({
           data: identificationHeader,
           endGranulePosition: 0,
@@ -6965,10 +8630,182 @@ ${cue.notes ?? ""}`;
         };
       }
     }
-    async addEncodedAudioPacket(track, packet, meta) {
+    createVorbisComments(headerBytes) {
+      const tags = this.output._metadataTags;
+      const commentHeaderParts = [
+        headerBytes
+      ];
+      let vendorString = "";
+      if (typeof tags.raw?.["vendor"] === "string") {
+        vendorString = tags.raw?.["vendor"];
+      }
+      const encodedVendorString = textEncoder.encode(vendorString);
+      let currentBuffer = new Uint8Array(4 + encodedVendorString.length);
+      let currentView = new DataView(currentBuffer.buffer);
+      currentView.setUint32(0, encodedVendorString.length, true);
+      currentBuffer.set(encodedVendorString, 4);
+      commentHeaderParts.push(currentBuffer);
+      const writtenTags = /* @__PURE__ */ new Set();
+      const addCommentTag = (key, value) => {
+        const joined = `${key}=${value}`;
+        const encoded = textEncoder.encode(joined);
+        currentBuffer = new Uint8Array(4 + encoded.length);
+        currentView = new DataView(currentBuffer.buffer);
+        currentView.setUint32(0, encoded.length, true);
+        currentBuffer.set(encoded, 4);
+        commentHeaderParts.push(currentBuffer);
+        writtenTags.add(key);
+      };
+      for (const { key, value } of keyValueIterator(tags)) {
+        switch (key) {
+          case "title":
+            {
+              addCommentTag("TITLE", value);
+            }
+            ;
+            break;
+          case "description":
+            {
+              addCommentTag("DESCRIPTION", value);
+            }
+            ;
+            break;
+          case "artist":
+            {
+              addCommentTag("ARTIST", value);
+            }
+            ;
+            break;
+          case "album":
+            {
+              addCommentTag("ALBUM", value);
+            }
+            ;
+            break;
+          case "albumArtist":
+            {
+              addCommentTag("ALBUMARTIST", value);
+            }
+            ;
+            break;
+          case "genre":
+            {
+              addCommentTag("GENRE", value);
+            }
+            ;
+            break;
+          case "date":
+            {
+              addCommentTag("DATE", value.toISOString().slice(0, 10));
+            }
+            ;
+            break;
+          case "comment":
+            {
+              addCommentTag("COMMENT", value);
+            }
+            ;
+            break;
+          case "lyrics":
+            {
+              addCommentTag("LYRICS", value);
+            }
+            ;
+            break;
+          case "trackNumber":
+            {
+              addCommentTag("TRACKNUMBER", value.toString());
+            }
+            ;
+            break;
+          case "tracksTotal":
+            {
+              addCommentTag("TRACKTOTAL", value.toString());
+            }
+            ;
+            break;
+          case "discNumber":
+            {
+              addCommentTag("DISCNUMBER", value.toString());
+            }
+            ;
+            break;
+          case "discsTotal":
+            {
+              addCommentTag("DISCTOTAL", value.toString());
+            }
+            ;
+            break;
+          case "images":
+            {
+              for (const image of value) {
+                const pictureType = image.kind === "coverFront" ? 3 : image.kind === "coverBack" ? 4 : 0;
+                const encodedMediaType = new Uint8Array(image.mimeType.length);
+                for (let i = 0; i < image.mimeType.length; i++) {
+                  encodedMediaType[i] = image.mimeType.charCodeAt(i);
+                }
+                const encodedDescription = textEncoder.encode(image.description ?? "");
+                const buffer = new Uint8Array(
+                  4 + 4 + encodedMediaType.length + 4 + encodedDescription.length + 16 + 4 + image.data.length
+                  // Picture data
+                );
+                const view2 = toDataView(buffer);
+                view2.setUint32(0, pictureType, false);
+                view2.setUint32(4, encodedMediaType.length, false);
+                buffer.set(encodedMediaType, 8);
+                view2.setUint32(8 + encodedMediaType.length, encodedDescription.length, false);
+                buffer.set(encodedDescription, 12 + encodedMediaType.length);
+                view2.setUint32(
+                  28 + encodedMediaType.length + encodedDescription.length,
+                  image.data.length,
+                  false
+                );
+                buffer.set(
+                  image.data,
+                  32 + encodedMediaType.length + encodedDescription.length
+                );
+                const encoded = bytesToBase64(buffer);
+                addCommentTag("METADATA_BLOCK_PICTURE", encoded);
+              }
+            }
+            ;
+            break;
+          case "raw":
+            {
+            }
+            ;
+            break;
+          default:
+            assertNever(key);
+        }
+      }
+      if (tags.raw) {
+        for (const key in tags.raw) {
+          const value = tags.raw[key];
+          if (key === "vendor" || value == null || writtenTags.has(key)) {
+            continue;
+          }
+          if (typeof value === "string") {
+            addCommentTag(key, value);
+          }
+        }
+      }
+      const listLengthBuffer = new Uint8Array(4);
+      toDataView(listLengthBuffer).setUint32(0, writtenTags.size, true);
+      commentHeaderParts.splice(2, 0, listLengthBuffer);
+      const commentHeaderLength = commentHeaderParts.reduce((a, b) => a + b.length, 0);
+      const commentHeader = new Uint8Array(commentHeaderLength);
+      let pos = 0;
+      for (const part of commentHeaderParts) {
+        commentHeader.set(part, pos);
+        pos += part.length;
+      }
+      return commentHeader;
+    }
+    async addEncodedAudioPacket(track, packet, meta2) {
       const release = await this.mutex.acquire();
       try {
-        const trackData = this.getTrackData(track, meta);
+        const trackData = this.getTrackData(track, meta2);
         this.validateAndNormalizeTimestamp(trackData.track, packet.timestamp, packet.type === "key");
         const currentTimestampInSamples = trackData.currentTimestampInSamples;
         const { durationInSamples, vorbisBlockSize } = extractSampleMetadata(
@@ -9643,7 +11480,8 @@ ${cue.notes ?? ""}`;
     }
     /**
      * Returns the [decoder configuration](https://www.w3.org/TR/webcodecs/#video-decoder-config) for decoding the
-     * track's packets using a VideoDecoder. Returns null if the track's codec is unknown.
+     * track's packets using a [`VideoDecoder`](https://developer.mozilla.org/en-US/docs/Web/API/VideoDecoder). Returns
+     * null if the track's codec is unknown.
      */
     getDecoderConfig() {
       return this._backing.getDecoderConfig();
@@ -9708,7 +11546,8 @@ ${cue.notes ?? ""}`;
     }
     /**
      * Returns the [decoder configuration](https://www.w3.org/TR/webcodecs/#audio-decoder-config) for decoding the
-     * track's packets using an AudioDecoder. Returns null if the track's codec is unknown.
+     * track's packets using an [`AudioDecoder`](https://developer.mozilla.org/en-US/docs/Web/API/AudioDecoder). Returns
+     * null if the track's codec is unknown.
      */
     getDecoderConfig() {
       return this._backing.getDecoderConfig();
@@ -9763,6 +11602,7 @@ ${cue.notes ?? ""}`;
       this.audioInfo = null;
       this.tracks = [];
       this.lastKnownPacketIndex = 0;
+      this.metadataTags = {};
       this.reader = input._reader;
     }
     async readMetadata() {
@@ -9798,10 +11638,15 @@ ${cue.notes ?? ""}`;
             dataChunkSize ??= chunkSize;
             this.dataStart = slice2.filePos;
             this.dataSize = Math.min(dataChunkSize, (totalFileSize ?? Infinity) - this.dataStart);
+            if (this.reader.fileSize === null) {
+              break;
+            }
           } else if (chunkId === "ds64") {
             const riffChunkSize = readU64(slice2, littleEndian);
             dataChunkSize = readU64(slice2, littleEndian);
             totalFileSize = Math.min(riffChunkSize + 8, this.reader.fileSize ?? Infinity);
+          } else if (chunkId === "LIST") {
+            await this.parseListChunk(startPos, chunkSize, littleEndian);
           }
           currentPos = startPos + chunkSize + (chunkSize & 1);
           chunksRead++;
@@ -9853,6 +11698,110 @@ ${cue.notes ?? ""}`;
         blockSizeInBytes: blockAlign
       };
     }
+    async parseListChunk(startPos, size, littleEndian) {
+      let slice = this.reader.requestSlice(startPos, size);
+      if (slice instanceof Promise) slice = await slice;
+      if (!slice) return;
+      const infoType = readAscii(slice, 4);
+      if (infoType !== "INFO" && infoType !== "INF0") {
+        return;
+      }
+      let currentPos = slice.filePos;
+      while (currentPos <= startPos + size - 8) {
+        slice.filePos = currentPos;
+        const chunkName = readAscii(slice, 4);
+        const chunkSize = readU32(slice, littleEndian);
+        const bytes2 = readBytes(slice, chunkSize);
+        let stringLength = 0;
+        for (let i = 0; i < bytes2.length; i++) {
+          if (bytes2[i] === 0) {
+            break;
+          }
+          stringLength++;
+        }
+        const value = String.fromCharCode(...bytes2.subarray(0, stringLength));
+        this.metadataTags.raw ??= {};
+        this.metadataTags.raw[chunkName] = value;
+        switch (chunkName) {
+          case "INAM":
+          case "TITL":
+            {
+              this.metadataTags.title ??= value;
+            }
+            ;
+            break;
+          case "TIT3":
+            {
+              this.metadataTags.description ??= value;
+            }
+            ;
+            break;
+          case "IART":
+            {
+              this.metadataTags.artist ??= value;
+            }
+            ;
+            break;
+          case "IPRD":
+            {
+              this.metadataTags.album ??= value;
+            }
+            ;
+            break;
+          case "IPRT":
+          case "ITRK":
+          case "TRCK":
+            {
+              const parts = value.split("/");
+              const trackNum = Number.parseInt(parts[0], 10);
+              const tracksTotal = parts[1] && Number.parseInt(parts[1], 10);
+              if (Number.isInteger(trackNum) && trackNum > 0) {
+                this.metadataTags.trackNumber ??= trackNum;
+              }
+              if (tracksTotal && Number.isInteger(tracksTotal) && tracksTotal > 0) {
+                this.metadataTags.tracksTotal ??= tracksTotal;
+              }
+            }
+            ;
+            break;
+          case "ICRD":
+          case "IDIT":
+            {
+              const date = new Date(value);
+              if (!Number.isNaN(date.getTime())) {
+                this.metadataTags.date ??= date;
+              }
+            }
+            ;
+            break;
+          case "YEAR":
+            {
+              const year = Number.parseInt(value, 10);
+              if (Number.isInteger(year) && year > 0) {
+                this.metadataTags.date ??= new Date(year, 0, 1);
+              }
+            }
+            ;
+            break;
+          case "IGNR":
+          case "GENR":
+            {
+              this.metadataTags.genre ??= value;
+            }
+            ;
+            break;
+          case "ICMT":
+          case "CMNT":
+          case "COMM":
+            {
+              this.metadataTags.comment ??= value;
+            }
+            ;
+            break;
+        }
+        currentPos += 8 + chunkSize + (chunkSize & 1);
+      }
+    }
     getCodec() {
       assert(this.audioInfo);
       if (this.audioInfo.format === 7 /* MULAW */) {
@@ -9892,6 +11841,10 @@ ${cue.notes ?? ""}`;
       await this.readMetadata();
       return this.tracks;
     }
+    async getMetadataTags() {
+      await this.readMetadata();
+      return this.metadataTags;
+    }
   };
   var PACKET_SIZE_IN_FRAMES = 2048;
   var WaveAudioTrackBacking = class {
@@ -10059,6 +12012,11 @@ ${cue.notes ?? ""}`;
       this.dataSize = 0;
       this.sampleRate = null;
       this.sampleCount = 0;
+      this.riffSizePos = null;
+      this.dataSizePos = null;
+      this.ds64RiffSizePos = null;
+      this.ds64DataSizePos = null;
+      this.ds64SampleCountPos = null;
       this.format = format;
       this.writer = output._writer;
       this.riffWriter = new RiffWriter(output._writer);
@@ -10072,15 +12030,15 @@ ${cue.notes ?? ""}`;
     async addEncodedVideoPacket() {
       throw new Error("WAVE does not support video.");
     }
-    async addEncodedAudioPacket(track, packet, meta) {
+    async addEncodedAudioPacket(track, packet, meta2) {
       const release = await this.mutex.acquire();
       try {
         if (!this.headerWritten) {
-          validateAudioChunkMetadata(meta);
-          assert(meta);
-          assert(meta.decoderConfig);
-          this.writeHeader(track, meta.decoderConfig);
-          this.sampleRate = meta.decoderConfig.sampleRate;
+          validateAudioChunkMetadata(meta2);
+          assert(meta2);
+          assert(meta2.decoderConfig);
+          this.writeHeader(track, meta2.decoderConfig);
+          this.sampleRate = meta2.decoderConfig.sampleRate;
           this.headerWritten = true;
         }
         this.validateAndNormalizeTimestamp(track, packet.timestamp, packet.type === "key");
@@ -10123,50 +12081,179 @@ ${cue.notes ?? ""}`;
       if (this.isRf64) {
         this.riffWriter.writeU32(4294967295);
       } else {
+        this.riffSizePos = this.writer.getPos();
         this.riffWriter.writeU32(0);
       }
       this.riffWriter.writeAscii("WAVE");
       if (this.isRf64) {
         this.riffWriter.writeAscii("ds64");
         this.riffWriter.writeU32(28);
+        this.ds64RiffSizePos = this.writer.getPos();
         this.riffWriter.writeU64(0);
+        this.ds64DataSizePos = this.writer.getPos();
         this.riffWriter.writeU64(0);
+        this.ds64SampleCountPos = this.writer.getPos();
         this.riffWriter.writeU64(0);
         this.riffWriter.writeU32(0);
       }
-      this.riffWriter.writeAscii("fmt ");
-      this.riffWriter.writeU32(16);
-      this.riffWriter.writeU16(format);
-      this.riffWriter.writeU16(channels);
-      this.riffWriter.writeU32(sampleRate);
-      this.riffWriter.writeU32(sampleRate * blockSize);
-      this.riffWriter.writeU16(blockSize);
-      this.riffWriter.writeU16(8 * pcmInfo.sampleSize);
-      this.riffWriter.writeAscii("data");
-      if (this.isRf64) {
-        this.riffWriter.writeU32(4294967295);
-      } else {
-        this.riffWriter.writeU32(0);
+      this.riffWriter.writeAscii("fmt ");
+      this.riffWriter.writeU32(16);
+      this.riffWriter.writeU16(format);
+      this.riffWriter.writeU16(channels);
+      this.riffWriter.writeU32(sampleRate);
+      this.riffWriter.writeU32(sampleRate * blockSize);
+      this.riffWriter.writeU16(blockSize);
+      this.riffWriter.writeU16(8 * pcmInfo.sampleSize);
+      if (!metadataTagsAreEmpty(this.output._metadataTags)) {
+        this.writeInfoChunk(this.output._metadataTags);
+      }
+      this.riffWriter.writeAscii("data");
+      if (this.isRf64) {
+        this.riffWriter.writeU32(4294967295);
+      } else {
+        this.dataSizePos = this.writer.getPos();
+        this.riffWriter.writeU32(0);
+      }
+      if (this.format._options.onHeader) {
+        const { data, start } = this.writer.stopTrackingWrites();
+        this.format._options.onHeader(data, start);
+      }
+    }
+    writeInfoChunk(metadata) {
+      const startPos = this.writer.getPos();
+      this.riffWriter.writeAscii("LIST");
+      this.riffWriter.writeU32(0);
+      this.riffWriter.writeAscii("INFO");
+      const writtenTags = /* @__PURE__ */ new Set();
+      const writeInfoTag = (tag, value) => {
+        if (!isIso88591Compatible(value)) {
+          console.warn(`Didn't write tag '${tag}' because '${value}' is not ISO 8859-1-compatible.`);
+          return;
+        }
+        const size = value.length + 1;
+        const bytes2 = new Uint8Array(size);
+        for (let i = 0; i < value.length; i++) {
+          bytes2[i] = value.charCodeAt(i);
+        }
+        this.riffWriter.writeAscii(tag);
+        this.riffWriter.writeU32(size);
+        this.writer.write(bytes2);
+        if (size & 1) {
+          this.writer.write(new Uint8Array(1));
+        }
+        writtenTags.add(tag);
+      };
+      for (const { key, value } of keyValueIterator(metadata)) {
+        switch (key) {
+          case "title":
+            {
+              writeInfoTag("INAM", value);
+              writtenTags.add("INAM");
+            }
+            ;
+            break;
+          case "artist":
+            {
+              writeInfoTag("IART", value);
+              writtenTags.add("IART");
+            }
+            ;
+            break;
+          case "album":
+            {
+              writeInfoTag("IPRD", value);
+              writtenTags.add("IPRD");
+            }
+            ;
+            break;
+          case "trackNumber":
+            {
+              const string = metadata.tracksTotal !== void 0 ? `${value}/${metadata.tracksTotal}` : value.toString();
+              writeInfoTag("ITRK", string);
+              writtenTags.add("ITRK");
+            }
+            ;
+            break;
+          case "genre":
+            {
+              writeInfoTag("IGNR", value);
+              writtenTags.add("IGNR");
+            }
+            ;
+            break;
+          case "date":
+            {
+              writeInfoTag("ICRD", value.toISOString().slice(0, 10));
+              writtenTags.add("ICRD");
+            }
+            ;
+            break;
+          case "comment":
+            {
+              writeInfoTag("ICMT", value);
+              writtenTags.add("ICMT");
+            }
+            ;
+            break;
+          case "albumArtist":
+          case "discNumber":
+          case "tracksTotal":
+          case "discsTotal":
+          case "description":
+          case "lyrics":
+          case "images":
+            {
+            }
+            ;
+            break;
+          case "raw":
+            {
+            }
+            ;
+            break;
+          default:
+            assertNever(key);
+        }
+      }
+      if (metadata.raw) {
+        for (const key in metadata.raw) {
+          const value = metadata.raw[key];
+          if (value == null || key.length !== 4 || writtenTags.has(key)) {
+            continue;
+          }
+          if (typeof value === "string") {
+            writeInfoTag(key, value);
+          }
+        }
       }
-      if (this.format._options.onHeader) {
-        const { data, start } = this.writer.stopTrackingWrites();
-        this.format._options.onHeader(data, start);
+      const endPos = this.writer.getPos();
+      const chunkSize = endPos - startPos - 8;
+      this.writer.seek(startPos + 4);
+      this.riffWriter.writeU32(chunkSize);
+      this.writer.seek(endPos);
+      if (chunkSize & 1) {
+        this.writer.write(new Uint8Array(1));
       }
     }
     async finalize() {
       const release = await this.mutex.acquire();
       const endPos = this.writer.getPos();
       if (this.isRf64) {
-        this.writer.seek(20);
+        assert(this.ds64RiffSizePos !== null);
+        this.writer.seek(this.ds64RiffSizePos);
         this.riffWriter.writeU64(endPos - 8);
-        this.writer.seek(28);
+        assert(this.ds64DataSizePos !== null);
+        this.writer.seek(this.ds64DataSizePos);
         this.riffWriter.writeU64(this.dataSize);
-        this.writer.seek(36);
+        assert(this.ds64SampleCountPos !== null);
+        this.writer.seek(this.ds64SampleCountPos);
         this.riffWriter.writeU64(this.sampleCount);
       } else {
-        this.writer.seek(4);
+        assert(this.riffSizePos !== null);
+        this.writer.seek(this.riffSizePos);
         this.riffWriter.writeU32(endPos - 8);
-        this.writer.seek(40);
+        assert(this.dataSizePos !== null);
+        this.writer.seek(this.dataSizePos);
         this.riffWriter.writeU32(this.dataSize);
       }
       this.writer.seek(endPos);
@@ -10235,7 +12322,7 @@ ${cue.notes ?? ""}`;
     }
     /** @internal */
     _createMuxer(output) {
-      return new IsobmffMuxer(output, this);
+      return new IsobmffMuxer2(output, this);
     }
   };
   var Mp4OutputFormat = class extends IsobmffOutputFormat2 {
@@ -11049,18 +13136,18 @@ ${cue.notes ?? ""}`;
      * @returns A Promise that resolves once the output is ready to receive more samples. You should await this Promise
      * to respect writer and encoder backpressure.
      */
-    add(packet, meta) {
+    add(packet, meta2) {
       if (!(packet instanceof EncodedPacket)) {
         throw new TypeError("packet must be an EncodedPacket.");
       }
       if (packet.isMetadataOnly) {
         throw new TypeError("Metadata-only packets cannot be added.");
       }
-      if (meta !== void 0 && (!meta || typeof meta !== "object")) {
+      if (meta2 !== void 0 && (!meta2 || typeof meta2 !== "object")) {
         throw new TypeError("meta, when provided, must be an object.");
       }
       this._ensureValidAdd();
-      return this._connectedTrack.output._muxer.addEncodedVideoPacket(this._connectedTrack, packet, meta);
+      return this._connectedTrack.output._muxer.addEncodedVideoPacket(this._connectedTrack, packet, meta2);
     }
   };
   var VideoEncoderWrapper = class {
@@ -11195,15 +13282,15 @@ ${cue.notes ?? ""}`;
           this.customEncoder = new MatchingCustomEncoder();
           this.customEncoder.codec = this.encodingConfig.codec;
           this.customEncoder.config = encoderConfig;
-          this.customEncoder.onPacket = (packet, meta) => {
+          this.customEncoder.onPacket = (packet, meta2) => {
             if (!(packet instanceof EncodedPacket)) {
               throw new TypeError("The first argument passed to onPacket must be an EncodedPacket.");
             }
-            if (meta !== void 0 && (!meta || typeof meta !== "object")) {
+            if (meta2 !== void 0 && (!meta2 || typeof meta2 !== "object")) {
               throw new TypeError("The second argument passed to onPacket must be an object or undefined.");
             }
-            this.encodingConfig.onEncodedPacket?.(packet, meta);
-            void this.muxer.addEncodedVideoPacket(this.source._connectedTrack, packet, meta);
+            this.encodingConfig.onEncodedPacket?.(packet, meta2);
+            void this.muxer.addEncodedVideoPacket(this.source._connectedTrack, packet, meta2);
           };
           await this.customEncoder.init();
         } else {
@@ -11217,10 +13304,10 @@ ${cue.notes ?? ""}`;
             );
           }
           this.encoder = new VideoEncoder({
-            output: (chunk, meta) => {
+            output: (chunk, meta2) => {
               const packet = EncodedPacket.fromEncodedChunk(chunk);
-              this.encodingConfig.onEncodedPacket?.(packet, meta);
-              void this.muxer.addEncodedVideoPacket(this.source._connectedTrack, packet, meta);
+              this.encodingConfig.onEncodedPacket?.(packet, meta2);
+              void this.muxer.addEncodedVideoPacket(this.source._connectedTrack, packet, meta2);
             },
             error: (error) => {
               error.stack = encoderError.stack;
@@ -11491,18 +13578,18 @@ ${cue.notes ?? ""}`;
      * @returns A Promise that resolves once the output is ready to receive more samples. You should await this Promise
      * to respect writer and encoder backpressure.
      */
-    add(packet, meta) {
+    add(packet, meta2) {
       if (!(packet instanceof EncodedPacket)) {
         throw new TypeError("packet must be an EncodedPacket.");
       }
       if (packet.isMetadataOnly) {
         throw new TypeError("Metadata-only packets cannot be added.");
       }
-      if (meta !== void 0 && (!meta || typeof meta !== "object")) {
+      if (meta2 !== void 0 && (!meta2 || typeof meta2 !== "object")) {
         throw new TypeError("meta, when provided, must be an object.");
       }
       this._ensureValidAdd();
-      return this._connectedTrack.output._muxer.addEncodedAudioPacket(this._connectedTrack, packet, meta);
+      return this._connectedTrack.output._muxer.addEncodedAudioPacket(this._connectedTrack, packet, meta2);
     }
   };
   var AudioEncoderWrapper = class {
@@ -11613,7 +13700,7 @@ ${cue.notes ?? ""}`;
       if (shouldClose) {
         audioSample.close();
       }
-      const meta = {
+      const meta2 = {
         decoderConfig: {
           codec: this.encodingConfig.codec,
           numberOfChannels,
@@ -11630,8 +13717,8 @@ ${cue.notes ?? ""}`;
           timestamp + startFrame / sampleRate,
           frameCount / sampleRate
         );
-        this.encodingConfig.onEncodedPacket?.(packet, meta);
-        await this.muxer.addEncodedAudioPacket(this.source._connectedTrack, packet, meta);
+        this.encodingConfig.onEncodedPacket?.(packet, meta2);
+        await this.muxer.addEncodedAudioPacket(this.source._connectedTrack, packet, meta2);
       }
     }
     ensureEncoder(audioSample) {
@@ -11655,15 +13742,15 @@ ${cue.notes ?? ""}`;
           this.customEncoder = new MatchingCustomEncoder();
           this.customEncoder.codec = this.encodingConfig.codec;
           this.customEncoder.config = encoderConfig;
-          this.customEncoder.onPacket = (packet, meta) => {
+          this.customEncoder.onPacket = (packet, meta2) => {
             if (!(packet instanceof EncodedPacket)) {
               throw new TypeError("The first argument passed to onPacket must be an EncodedPacket.");
             }
-            if (meta !== void 0 && (!meta || typeof meta !== "object")) {
+            if (meta2 !== void 0 && (!meta2 || typeof meta2 !== "object")) {
               throw new TypeError("The second argument passed to onPacket must be an object or undefined.");
             }
-            this.encodingConfig.onEncodedPacket?.(packet, meta);
-            void this.muxer.addEncodedAudioPacket(this.source._connectedTrack, packet, meta);
+            this.encodingConfig.onEncodedPacket?.(packet, meta2);
+            void this.muxer.addEncodedAudioPacket(this.source._connectedTrack, packet, meta2);
           };
           await this.customEncoder.init();
         } else if (PCM_AUDIO_CODECS.includes(this.encodingConfig.codec)) {
@@ -11679,10 +13766,10 @@ ${cue.notes ?? ""}`;
             );
           }
           this.encoder = new AudioEncoder({
-            output: (chunk, meta) => {
+            output: (chunk, meta2) => {
               const packet = EncodedPacket.fromEncodedChunk(chunk);
-              this.encodingConfig.onEncodedPacket?.(packet, meta);
-              void this.muxer.addEncodedAudioPacket(this.source._connectedTrack, packet, meta);
+              this.encodingConfig.onEncodedPacket?.(packet, meta2);
+              void this.muxer.addEncodedAudioPacket(this.source._connectedTrack, packet, meta2);
             },
             error: (error) => {
               error.stack = encoderError.stack;
@@ -12182,6 +14269,8 @@ ${cue.notes ?? ""}`;
       this._finalizePromise = null;
       /** @internal */
       this._mutex = new AsyncMutex();
+      /** @internal */
+      this._metadataTags = {};
       if (!options || typeof options !== "object") {
         throw new TypeError("options must be an object.");
       }
@@ -12235,6 +14324,19 @@ ${cue.notes ?? ""}`;
       validateBaseTrackMetadata(metadata);
       this._addTrack("subtitle", source, metadata);
     }
+    /**
+     * Sets descriptive metadata tags about the media file, such as title, author, date, or cover art. When called
+     * multiple times, only the metadata from the last call will be used.
+     *
+     * Must be called before output is started.
+     */
+    setMetadataTags(tags) {
+      validateMetadataTags(tags);
+      if (this.state !== "pending") {
+        throw new Error("Cannot set metadata tags after output has been started or canceled.");
+      }
+      this._metadataTags = tags;
+    }
     /** @internal */
     _addTrack(type, source, metadata) {
       if (this.state !== "pending") {
@@ -12466,6 +14568,10 @@ ${cue.notes ?? ""}`;
         offset: 0
       };
     }
+    /** @internal */
+    get _supportsRandomAccess() {
+      return true;
+    }
   };
   var BlobSource = class extends Source {
     /**
@@ -12524,6 +14630,10 @@ ${cue.notes ?? ""}`;
       }
       worker.running = false;
     }
+    /** @internal */
+    get _supportsRandomAccess() {
+      return true;
+    }
   };
   var URL_SOURCE_MIN_LOAD_AMOUNT = 0.5 * 2 ** 20;
   var UrlSource = class extends Source {
@@ -12701,6 +14811,10 @@ ${cue.notes ?? ""}`;
         }
       }
     }
+    /** @internal */
+    get _supportsRandomAccess() {
+      return true;
+    }
   };
   var FilePathSource = class extends Source {
     /** Creates a new {@link FilePathSource} backed by the file at the specified file path. */
@@ -12745,6 +14859,10 @@ ${cue.notes ?? ""}`;
     _retrieveSize() {
       return this._streamSource._retrieveSize();
     }
+    /** @internal */
+    get _supportsRandomAccess() {
+      return true;
+    }
   };
   var StreamSource = class extends Source {
     /** Creates a new {@link StreamSource} whose behavior is specified by `options`.  */
@@ -12841,6 +14959,10 @@ ${cue.notes ?? ""}`;
       }
       worker.running = false;
     }
+    /** @internal */
+    get _supportsRandomAccess() {
+      return true;
+    }
   };
   var ReadableStreamSource = class extends Source {
     /** Creates a new {@link ReadableStreamSource} backed by the specified `ReadableStream<Uint8Array>`. */
@@ -13009,6 +15131,10 @@ ${cue.notes ?? ""}`;
       }
       this._pulling = false;
     }
+    /** @internal */
+    get _supportsRandomAccess() {
+      return false;
+    }
   };
   var PREFETCH_PROFILES = {
     none: (start, end) => ({ start, end }),
@@ -13360,6 +15486,129 @@ ${cue.notes ?? ""}`;
   };
 
   // src/isobmff/isobmff-demuxer.ts
+  var UDTA_STRING_KEYS = /* @__PURE__ */ new Set([
+    "@day",
+    "@mak",
+    "@mod",
+    "@swr",
+    "@xyz",
+    "CAME",
+    "CNCV",
+    "CNFV",
+    "CNMN",
+    "FIRM",
+    "FOV\0",
+    "GoPr",
+    "LENS",
+    "PXMN",
+    "SIGM",
+    "SNum",
+    "TAGS",
+    "albm",
+    "albr",
+    "angl",
+    "auth",
+    "ccid",
+    "cdis",
+    "clfn",
+    "clid",
+    "clsf",
+    "cmid",
+    "cmnm",
+    "coll",
+    "cprt",
+    "cver",
+    "cvru",
+    "date",
+    "dscp",
+    "fsid",
+    "gnre",
+    "hinv",
+    "icnu",
+    "info",
+    "infu",
+    "kgtt",
+    "loci",
+    "lrcu",
+    "mcvr",
+    "name",
+    "perf",
+    "pmcc",
+    "reel",
+    "rtng",
+    "scen",
+    "shot",
+    "slno",
+    "thmb",
+    "titl",
+    "tnam",
+    "urat",
+    "uuid",
+    "vndr",
+    "yrrc",
+    "\xA9ART",
+    "\xA9TIM",
+    "\xA9TSC",
+    "\xA9TSZ",
+    "\xA9alb",
+    "\xA9arg",
+    "\xA9ark",
+    "\xA9cmt",
+    "\xA9cok",
+    "\xA9com",
+    "\xA9cpy",
+    "\xA9day",
+    "\xA9dir",
+    "\xA9ed1",
+    "\xA9ed2",
+    "\xA9ed3",
+    "\xA9ed4",
+    "\xA9ed5",
+    "\xA9ed6",
+    "\xA9ed7",
+    "\xA9ed8",
+    "\xA9ed9",
+    "\xA9enc",
+    "\xA9fmt",
+    "\xA9fpt",
+    "\xA9frl",
+    "\xA9fyw",
+    "\xA9gen",
+    "\xA9gpt",
+    "\xA9grl",
+    "\xA9grp",
+    "\xA9gyw",
+    "\xA9inf",
+    "\xA9isr",
+    "\xA9lab",
+    "\xA9lal",
+    "\xA9lyr",
+    "\xA9mak",
+    "\xA9mal",
+    "\xA9mdl",
+    "\xA9mod",
+    "\xA9nam",
+    "\xA9pdk",
+    "\xA9phg",
+    "\xA9prd",
+    "\xA9prf",
+    "\xA9prk",
+    "\xA9prl",
+    "\xA9req",
+    "\xA9snk",
+    "\xA9snm",
+    "\xA9src",
+    "\xA9swf",
+    "\xA9swk",
+    "\xA9swr",
+    "\xA9too",
+    "\xA9trk",
+    "\xA9wrt",
+    "\xA9xsp",
+    "\xA9xyz",
+    "\xA9ysp",
+    "\xA9zsp"
+  ]);
   var IsobmffDemuxer = class extends Demuxer {
     constructor(input) {
       super(input);
@@ -13370,6 +15619,8 @@ ${cue.notes ?? ""}`;
       this.movieTimescale = -1;
       this.movieDurationInTimescale = -1;
       this.isQuickTime = false;
+      this.metadataTags = {};
+      this.currentMetadataKeys = null;
       this.isFragmented = false;
       this.fragmentTrackDefaults = [];
       this.fragments = [];
@@ -13396,6 +15647,10 @@ ${cue.notes ?? ""}`;
         codecStrings: codecStrings.filter(Boolean)
       });
     }
+    async getMetadataTags() {
+      await this.readMetadata();
+      return this.metadataTags;
+    }
     readMetadata() {
       return this.metadataPromise ??= (async () => {
         let currentPos = 0;
@@ -13634,6 +15889,19 @@ ${cue.notes ?? ""}`;
         }
       }
     }
+    // eslint-disable-next-line @stylistic/generator-star-spacing
+    *iterateContiguousBoxes(slice) {
+      const startIndex = slice.filePos;
+      while (slice.filePos - startIndex <= slice.length - MIN_BOX_HEADER_SIZE) {
+        const startPos = slice.filePos;
+        const boxInfo = readBoxHeader(slice);
+        if (!boxInfo) {
+          break;
+        }
+        yield { boxInfo, slice };
+        slice.filePos = startPos + boxInfo.totalSize;
+      }
+    }
     traverseBox(slice) {
       const startPos = slice.filePos;
       const boxInfo = readBoxHeader(slice);
@@ -13648,7 +15916,6 @@ ${cue.notes ?? ""}`;
         case "dinf":
         case "mfra":
         case "edts":
-        case "udta":
           {
             this.readContiguousBoxes(slice.slice(contentStartPos, boxInfo.contentSize));
           }
@@ -13713,7 +15980,9 @@ ${cue.notes ?? ""}`;
         case "tkhd":
           {
             const track = this.currentTrack;
-            assert(track);
+            if (!track) {
+              break;
+            }
             const version = readU8(slice);
             const flags = readU24Be(slice);
             const trackEnabled = (flags & 1) !== 0;
@@ -13754,7 +16023,9 @@ ${cue.notes ?? ""}`;
         case "elst":
           {
             const track = this.currentTrack;
-            assert(track);
+            if (!track) {
+              break;
+            }
             const version = readU8(slice);
             slice.skip(3);
             let relevantEntryFound = false;
@@ -13791,7 +16062,9 @@ ${cue.notes ?? ""}`;
         case "mdhd":
           {
             const track = this.currentTrack;
-            assert(track);
+            if (!track) {
+              break;
+            }
             const version = readU8(slice);
             slice.skip(3);
             if (version === 0) {
@@ -13820,7 +16093,9 @@ ${cue.notes ?? ""}`;
         case "hdlr":
           {
             const track = this.currentTrack;
-            assert(track);
+            if (!track) {
+              break;
+            }
             slice.skip(8);
             const handlerType = readAscii(slice, 4);
             if (handlerType === "vide") {
@@ -13852,7 +16127,9 @@ ${cue.notes ?? ""}`;
         case "stbl":
           {
             const track = this.currentTrack;
-            assert(track);
+            if (!track) {
+              break;
+            }
             track.sampleTableByteOffset = startPos;
             this.readContiguousBoxes(slice.slice(contentStartPos, boxInfo.contentSize));
           }
@@ -13861,7 +16138,9 @@ ${cue.notes ?? ""}`;
         case "stsd":
           {
             const track = this.currentTrack;
-            assert(track);
+            if (!track) {
+              break;
+            }
             if (track.info === null || track.sampleTable) {
               break;
             }
@@ -14017,7 +16296,10 @@ ${cue.notes ?? ""}`;
         case "avcC":
           {
             const track = this.currentTrack;
-            assert(track && track.info);
+            if (!track) {
+              break;
+            }
+            assert(track.info);
             track.info.codecDescription = readBytes(slice, boxInfo.contentSize);
           }
           ;
@@ -14025,7 +16307,10 @@ ${cue.notes ?? ""}`;
         case "hvcC":
           {
             const track = this.currentTrack;
-            assert(track && track.info);
+            if (!track) {
+              break;
+            }
+            assert(track.info);
             track.info.codecDescription = readBytes(slice, boxInfo.contentSize);
           }
           ;
@@ -14033,7 +16318,10 @@ ${cue.notes ?? ""}`;
         case "vpcC":
           {
             const track = this.currentTrack;
-            assert(track && track.info?.type === "video");
+            if (!track) {
+              break;
+            }
+            assert(track.info?.type === "video");
             slice.skip(4);
             const profile = readU8(slice);
             const level = readU8(slice);
@@ -14060,7 +16348,10 @@ ${cue.notes ?? ""}`;
         case "av1C":
           {
             const track = this.currentTrack;
-            assert(track && track.info?.type === "video");
+            if (!track) {
+              break;
+            }
+            assert(track.info?.type === "video");
             slice.skip(1);
             const secondByte = readU8(slice);
             const profile = secondByte >> 5;
@@ -14090,7 +16381,10 @@ ${cue.notes ?? ""}`;
         case "colr":
           {
             const track = this.currentTrack;
-            assert(track && track.info?.type === "video");
+            if (!track) {
+              break;
+            }
+            assert(track.info?.type === "video");
             const colourType = readAscii(slice, 4);
             if (colourType !== "nclx") {
               break;
@@ -14117,7 +16411,10 @@ ${cue.notes ?? ""}`;
         case "esds":
           {
             const track = this.currentTrack;
-            assert(track && track.info?.type === "audio");
+            if (!track) {
+              break;
+            }
+            assert(track.info?.type === "audio");
             slice.skip(4);
             const tag = readU8(slice);
             assert(tag === 3);
@@ -14176,7 +16473,10 @@ ${cue.notes ?? ""}`;
         case "enda":
           {
             const track = this.currentTrack;
-            assert(track && track.info?.type === "audio");
+            if (!track) {
+              break;
+            }
+            assert(track.info?.type === "audio");
             const littleEndian = readU16Be(slice) & 255;
             if (littleEndian) {
               if (track.info.codec === "pcm-s16be") {
@@ -14197,7 +16497,10 @@ ${cue.notes ?? ""}`;
         case "pcmC":
           {
             const track = this.currentTrack;
-            assert(track && track.info?.type === "audio");
+            if (!track) {
+              break;
+            }
+            assert(track.info?.type === "audio");
             slice.skip(1 + 3);
             const formatFlags = readU8(slice);
             const isLittleEndian = Boolean(formatFlags & 1);
@@ -14253,7 +16556,10 @@ ${cue.notes ?? ""}`;
         case "dOps":
           {
             const track = this.currentTrack;
-            assert(track && track.info?.type === "audio");
+            if (!track) {
+              break;
+            }
+            assert(track.info?.type === "audio");
             slice.skip(1);
             const outputChannelCount = readU8(slice);
             const preSkip = readU16Be(slice);
@@ -14286,7 +16592,10 @@ ${cue.notes ?? ""}`;
         case "dfLa":
           {
             const track = this.currentTrack;
-            assert(track && track.info?.type === "audio");
+            if (!track) {
+              break;
+            }
+            assert(track.info?.type === "audio");
             slice.skip(4);
             const BLOCK_TYPE_MASK = 127;
             const LAST_METADATA_BLOCK_FLAG_MASK = 128;
@@ -14324,7 +16633,9 @@ ${cue.notes ?? ""}`;
         case "stts":
           {
             const track = this.currentTrack;
-            assert(track);
+            if (!track) {
+              break;
+            }
             if (!track.sampleTable) {
               break;
             }
@@ -14350,7 +16661,9 @@ ${cue.notes ?? ""}`;
         case "ctts":
           {
             const track = this.currentTrack;
-            assert(track);
+            if (!track) {
+              break;
+            }
             if (!track.sampleTable) {
               break;
             }
@@ -14373,7 +16686,9 @@ ${cue.notes ?? ""}`;
         case "stsz":
           {
             const track = this.currentTrack;
-            assert(track);
+            if (!track) {
+              break;
+            }
             if (!track.sampleTable) {
               break;
             }
@@ -14394,7 +16709,9 @@ ${cue.notes ?? ""}`;
         case "stz2":
           {
             const track = this.currentTrack;
-            assert(track);
+            if (!track) {
+              break;
+            }
             if (!track.sampleTable) {
               break;
             }
@@ -14414,7 +16731,9 @@ ${cue.notes ?? ""}`;
         case "stss":
           {
             const track = this.currentTrack;
-            assert(track);
+            if (!track) {
+              break;
+            }
             if (!track.sampleTable) {
               break;
             }
@@ -14434,7 +16753,9 @@ ${cue.notes ?? ""}`;
         case "stsc":
           {
             const track = this.currentTrack;
-            assert(track);
+            if (!track) {
+              break;
+            }
             if (!track.sampleTable) {
               break;
             }
@@ -14466,7 +16787,9 @@ ${cue.notes ?? ""}`;
         case "stco":
           {
             const track = this.currentTrack;
-            assert(track);
+            if (!track) {
+              break;
+            }
             if (!track.sampleTable) {
               break;
             }
@@ -14482,7 +16805,9 @@ ${cue.notes ?? ""}`;
         case "co64":
           {
             const track = this.currentTrack;
-            assert(track);
+            if (!track) {
+              break;
+            }
             if (!track.sampleTable) {
               break;
             }
@@ -14793,14 +17118,316 @@ ${cue.notes ?? ""}`;
           }
           ;
           break;
-        // These appear in udta:
-        case "\xA9nam":
-        case "name":
+        // Metadata section
+        // https://exiftool.org/TagNames/QuickTime.html
+        // https://mp4workshop.com/about
+        case "udta":
+          {
+            const iterator = this.iterateContiguousBoxes(slice.slice(contentStartPos, boxInfo.contentSize));
+            for (const { boxInfo: boxInfo2, slice: slice2 } of iterator) {
+              if (boxInfo2.name !== "meta" && !this.currentTrack) {
+                const startPos2 = slice2.filePos;
+                this.metadataTags.raw ??= {};
+                if (UDTA_STRING_KEYS.has(boxInfo2.name)) {
+                  this.metadataTags.raw[boxInfo2.name] ??= readMetadataStringShort(slice2);
+                } else {
+                  this.metadataTags.raw[boxInfo2.name] ??= readBytes(slice2, boxInfo2.contentSize);
+                }
+                slice2.filePos = startPos2;
+              }
+              switch (boxInfo2.name) {
+                case "meta":
+                  {
+                    slice2.skip(-boxInfo2.headerSize);
+                    this.traverseBox(slice2);
+                  }
+                  ;
+                  break;
+                case "\xA9nam":
+                case "name":
+                  {
+                    if (this.currentTrack) {
+                      this.currentTrack.name = textDecoder.decode(readBytes(slice2, boxInfo2.contentSize));
+                    } else {
+                      this.metadataTags.title ??= readMetadataStringShort(slice2);
+                    }
+                  }
+                  ;
+                  break;
+                case "\xA9des":
+                  {
+                    if (!this.currentTrack) {
+                      this.metadataTags.description ??= readMetadataStringShort(slice2);
+                    }
+                  }
+                  ;
+                  break;
+                case "\xA9ART":
+                  {
+                    if (!this.currentTrack) {
+                      this.metadataTags.artist ??= readMetadataStringShort(slice2);
+                    }
+                  }
+                  ;
+                  break;
+                case "\xA9alb":
+                  {
+                    if (!this.currentTrack) {
+                      this.metadataTags.album ??= readMetadataStringShort(slice2);
+                    }
+                  }
+                  ;
+                  break;
+                case "albr":
+                  {
+                    if (!this.currentTrack) {
+                      this.metadataTags.albumArtist ??= readMetadataStringShort(slice2);
+                    }
+                  }
+                  ;
+                  break;
+                case "\xA9gen":
+                  {
+                    if (!this.currentTrack) {
+                      this.metadataTags.genre ??= readMetadataStringShort(slice2);
+                    }
+                  }
+                  ;
+                  break;
+                case "\xA9day":
+                  {
+                    if (!this.currentTrack) {
+                      const date = new Date(readMetadataStringShort(slice2));
+                      if (!Number.isNaN(date.getTime())) {
+                        this.metadataTags.date ??= date;
+                      }
+                    }
+                  }
+                  ;
+                  break;
+                case "\xA9cmt":
+                  {
+                    if (!this.currentTrack) {
+                      this.metadataTags.comment ??= readMetadataStringShort(slice2);
+                    }
+                  }
+                  ;
+                  break;
+                case "\xA9lyr":
+                  {
+                    if (!this.currentTrack) {
+                      this.metadataTags.lyrics ??= readMetadataStringShort(slice2);
+                    }
+                  }
+                  ;
+                  break;
+              }
+            }
+          }
+          ;
+          break;
+        case "meta":
+          {
+            if (this.currentTrack) {
+              break;
+            }
+            const word = readU32Be(slice);
+            const isQuickTime = word !== 0;
+            this.currentMetadataKeys = /* @__PURE__ */ new Map();
+            if (isQuickTime) {
+              this.readContiguousBoxes(slice.slice(contentStartPos, boxInfo.contentSize));
+            } else {
+              this.readContiguousBoxes(slice.slice(contentStartPos + 4, boxInfo.contentSize - 4));
+            }
+            this.currentMetadataKeys = null;
+          }
+          ;
+          break;
+        case "keys":
+          {
+            if (!this.currentMetadataKeys) {
+              break;
+            }
+            slice.skip(4);
+            const entryCount = readU32Be(slice);
+            for (let i = 0; i < entryCount; i++) {
+              const keySize = readU32Be(slice);
+              slice.skip(4);
+              const keyName = textDecoder.decode(readBytes(slice, keySize - 8));
+              this.currentMetadataKeys.set(i + 1, keyName);
+            }
+          }
+          ;
+          break;
+        case "ilst":
           {
-            if (!this.currentTrack) {
+            if (!this.currentMetadataKeys) {
               break;
             }
-            this.currentTrack.name = textDecoder.decode(readBytes(slice, boxInfo.contentSize));
+            const iterator = this.iterateContiguousBoxes(slice.slice(contentStartPos, boxInfo.contentSize));
+            for (const { boxInfo: boxInfo2, slice: slice2 } of iterator) {
+              let metadataKey = boxInfo2.name;
+              const nameAsNumber = (metadataKey.charCodeAt(0) << 24) + (metadataKey.charCodeAt(1) << 16) + (metadataKey.charCodeAt(2) << 8) + metadataKey.charCodeAt(3);
+              if (this.currentMetadataKeys.has(nameAsNumber)) {
+                metadataKey = this.currentMetadataKeys.get(nameAsNumber);
+              }
+              const data = readDataBox(slice2);
+              this.metadataTags.raw ??= {};
+              this.metadataTags.raw[metadataKey] ??= data;
+              switch (metadataKey) {
+                case "\xA9nam":
+                case "titl":
+                case "com.apple.quicktime.title":
+                case "title":
+                  {
+                    if (typeof data === "string") {
+                      this.metadataTags.title ??= data;
+                    }
+                  }
+                  ;
+                  break;
+                case "\xA9des":
+                case "desc":
+                case "dscp":
+                case "com.apple.quicktime.description":
+                case "description":
+                  {
+                    if (typeof data === "string") {
+                      this.metadataTags.description ??= data;
+                    }
+                  }
+                  ;
+                  break;
+                case "\xA9ART":
+                case "com.apple.quicktime.artist":
+                case "artist":
+                  {
+                    if (typeof data === "string") {
+                      this.metadataTags.artist ??= data;
+                    }
+                  }
+                  ;
+                  break;
+                case "\xA9alb":
+                case "albm":
+                case "com.apple.quicktime.album":
+                case "album":
+                  {
+                    if (typeof data === "string") {
+                      this.metadataTags.album ??= data;
+                    }
+                  }
+                  ;
+                  break;
+                case "aART":
+                case "album_artist":
+                  {
+                    if (typeof data === "string") {
+                      this.metadataTags.albumArtist ??= data;
+                    }
+                  }
+                  ;
+                  break;
+                case "\xA9cmt":
+                case "com.apple.quicktime.comment":
+                case "comment":
+                  {
+                    if (typeof data === "string") {
+                      this.metadataTags.comment ??= data;
+                    }
+                  }
+                  ;
+                  break;
+                case "\xA9gen":
+                case "gnre":
+                case "com.apple.quicktime.genre":
+                case "genre":
+                  {
+                    if (typeof data === "string") {
+                      this.metadataTags.genre ??= data;
+                    }
+                  }
+                  ;
+                  break;
+                case "\xA9lyr":
+                case "lyrics":
+                  {
+                    if (typeof data === "string") {
+                      this.metadataTags.lyrics ??= data;
+                    }
+                  }
+                  ;
+                  break;
+                case "\xA9day":
+                case "rldt":
+                case "com.apple.quicktime.creationdate":
+                case "date":
+                  {
+                    if (typeof data === "string") {
+                      const date = new Date(data);
+                      if (!Number.isNaN(date.getTime())) {
+                        this.metadataTags.date ??= date;
+                      }
+                    }
+                  }
+                  ;
+                  break;
+                case "covr":
+                case "com.apple.quicktime.artwork":
+                  {
+                    if (data instanceof RichImageData) {
+                      this.metadataTags.images ??= [];
+                      this.metadataTags.images.push({
+                        data: data.data,
+                        kind: "coverFront",
+                        mimeType: data.mimeType
+                      });
+                    } else if (data instanceof Uint8Array) {
+                      this.metadataTags.images ??= [];
+                      this.metadataTags.images.push({
+                        data,
+                        kind: "coverFront",
+                        mimeType: "image/*"
+                      });
+                    }
+                  }
+                  ;
+                  break;
+                case "trkn":
+                  {
+                    if (data instanceof Uint8Array) {
+                      const view2 = toDataView(data);
+                      const trackNumber = view2.getUint16(2, false);
+                      const tracksTotal = view2.getUint16(4, false);
+                      if (trackNumber > 0) {
+                        this.metadataTags.trackNumber ??= trackNumber;
+                      }
+                      if (tracksTotal > 0) {
+                        this.metadataTags.tracksTotal ??= tracksTotal;
+                      }
+                    }
+                  }
+                  ;
+                  break;
+                case "disc":
+                case "disk":
+                  {
+                    if (data instanceof Uint8Array) {
+                      const view2 = toDataView(data);
+                      const discNumber = view2.getUint16(2, false);
+                      const discNumberMax = view2.getUint16(4, false);
+                      if (discNumber > 0) {
+                        this.metadataTags.discNumber ??= discNumber;
+                      }
+                      if (discNumberMax > 0) {
+                        this.metadataTags.discsTotal ??= discNumberMax;
+                      }
+                    }
+                  }
+                  ;
+                  break;
+              }
+            }
           }
           ;
           break;
@@ -15459,6 +18086,9 @@ ${cue.notes ?? ""}`;
       this.currentCluster = null;
       this.currentBlock = null;
       this.currentCueTime = null;
+      this.currentTagTargetIsMovie = true;
+      this.currentSimpleTagName = null;
+      this.currentAttachedFile = null;
       this.isWebM = false;
       this.reader = input._reader;
     }
@@ -15482,6 +18112,23 @@ ${cue.notes ?? ""}`;
         codecStrings: codecStrings.filter(Boolean)
       });
     }
+    async getMetadataTags() {
+      await this.readMetadata();
+      for (const segment of this.segments) {
+        if (!segment.metadataTagsCollected) {
+          if (this.reader.fileSize !== null) {
+            await this.loadSegmentMetadata(segment);
+          } else {
+          }
+          segment.metadataTagsCollected = true;
+        }
+      }
+      let metadataTags = {};
+      for (const segment of this.segments) {
+        metadataTags = { ...metadataTags, ...segment.metadataTags };
+      }
+      return metadataTags;
+    }
     readMetadata() {
       return this.readMetadataPromise ??= (async () => {
         let currentPos = 0;
@@ -15539,6 +18186,8 @@ ${cue.notes ?? ""}`;
         infoSeen: false,
         tracksSeen: false,
         cuesSeen: false,
+        tagsSeen: false,
+        attachmentsSeen: false,
         timestampScale: -1,
         timestampFactor: -1,
         duration: -1,
@@ -15549,7 +18198,9 @@ ${cue.notes ?? ""}`;
         elementEndPos: dataSize === null ? null : segmentDataStart + dataSize,
         clusterSeekStartPos: segmentDataStart,
         clusters: [],
-        clusterLookupMutex: new AsyncMutex()
+        clusterLookupMutex: new AsyncMutex(),
+        metadataTags: {},
+        metadataTagsCollected: false
       };
       this.segments.push(this.currentSegment);
       let currentPos = segmentDataStart;
@@ -15585,6 +18236,18 @@ ${cue.notes ?? ""}`;
           if (slice2) {
             this.readContiguousElements(slice2);
           }
+        } else if (id === 307544935 /* Tags */ || id === 423732329 /* Attachments */) {
+          if (id === 307544935 /* Tags */) {
+            this.currentSegment.tagsSeen = true;
+          } else {
+            this.currentSegment.attachmentsSeen = true;
+          }
+          assertDefinedSize(size);
+          let slice2 = this.reader.requestSlice(dataStartPos, size);
+          if (slice2 instanceof Promise) slice2 = await slice2;
+          if (slice2) {
+            this.readContiguousElements(slice2);
+          }
         } else if (id === 524531317 /* Cluster */) {
           this.currentSegment.clusterSeekStartPos = elementStartPos;
           break;
@@ -15595,8 +18258,8 @@ ${cue.notes ?? ""}`;
           currentPos = dataStartPos + size;
         }
       }
+      this.currentSegment.seekEntries.sort((a, b) => a.segmentPosition - b.segmentPosition);
       if (this.reader.fileSize !== null) {
-        this.currentSegment.seekEntries.sort((a, b) => a.segmentPosition - b.segmentPosition);
         for (const seekEntry of this.currentSegment.seekEntries) {
           const target = METADATA_ELEMENTS.find((x) => x.id === seekEntry.id);
           if (!target) {
@@ -15850,6 +18513,39 @@ ${cue.notes ?? ""}`;
         blockIndex--;
       }
     }
+    async loadSegmentMetadata(segment) {
+      for (const seekEntry of segment.seekEntries) {
+        if (seekEntry.id === 307544935 /* Tags */ && !segment.tagsSeen) {
+        } else if (seekEntry.id === 423732329 /* Attachments */ && !segment.attachmentsSeen) {
+        } else {
+          continue;
+        }
+        let slice = this.reader.requestSliceRange(
+          segment.dataStartPos + seekEntry.segmentPosition,
+          MIN_HEADER_SIZE,
+          MAX_HEADER_SIZE
+        );
+        if (slice instanceof Promise) slice = await slice;
+        if (!slice) continue;
+        const header = readElementHeader(slice);
+        if (!header || header.id !== seekEntry.id) continue;
+        const { size } = header;
+        assertDefinedSize(size);
+        assert(!this.currentSegment);
+        this.currentSegment = segment;
+        let dataSlice = this.reader.requestSlice(slice.filePos, size);
+        if (dataSlice instanceof Promise) dataSlice = await dataSlice;
+        if (dataSlice) {
+          this.readContiguousElements(dataSlice);
+        }
+        this.currentSegment = null;
+        if (seekEntry.id === 307544935 /* Tags */) {
+          segment.tagsSeen = true;
+        } else if (seekEntry.id === 423732329 /* Attachments */) {
+          segment.attachmentsSeen = true;
+        }
+      }
+    }
     readContiguousElements(slice) {
       const startIndex = slice.filePos;
       while (slice.filePos - startIndex <= slice.length - MIN_HEADER_SIZE) {
@@ -16356,10 +19052,230 @@ ${cue.notes ?? ""}`;
           }
           ;
           break;
+        case 29555 /* Tag */:
+          {
+            this.currentTagTargetIsMovie = true;
+            this.readContiguousElements(slice.slice(dataStartPos, size));
+          }
+          ;
+          break;
+        case 25536 /* Targets */:
+          {
+            this.readContiguousElements(slice.slice(dataStartPos, size));
+          }
+          ;
+          break;
+        case 26826 /* TargetTypeValue */:
+          {
+            const targetTypeValue = readUnsignedInt(slice, size);
+            if (targetTypeValue !== 50) {
+              this.currentTagTargetIsMovie = false;
+            }
+          }
+          ;
+          break;
+        case 25541 /* TagTrackUID */:
+        case 25545 /* TagEditionUID */:
+        case 25540 /* TagChapterUID */:
+        case 25542 /* TagAttachmentUID */:
+          {
+            this.currentTagTargetIsMovie = false;
+          }
+          ;
+          break;
+        case 26568 /* SimpleTag */:
+          {
+            if (!this.currentTagTargetIsMovie) break;
+            this.currentSimpleTagName = null;
+            this.readContiguousElements(slice.slice(dataStartPos, size));
+          }
+          ;
+          break;
+        case 17827 /* TagName */:
+          {
+            this.currentSimpleTagName = readUnicodeString(slice, size);
+          }
+          ;
+          break;
+        case 17543 /* TagString */:
+          {
+            if (!this.currentSimpleTagName) break;
+            const value = readUnicodeString(slice, size);
+            this.processTagValue(this.currentSimpleTagName, value);
+          }
+          ;
+          break;
+        case 17541 /* TagBinary */:
+          {
+            if (!this.currentSimpleTagName) break;
+            const value = readBytes(slice, size);
+            this.processTagValue(this.currentSimpleTagName, value);
+          }
+          ;
+          break;
+        case 24999 /* AttachedFile */:
+          {
+            if (!this.currentSegment) break;
+            this.currentAttachedFile = {
+              fileName: null,
+              fileMediaType: null,
+              fileData: null,
+              fileDescription: null
+            };
+            this.readContiguousElements(slice.slice(dataStartPos, size));
+            if (this.currentAttachedFile.fileMediaType?.startsWith("image/") && this.currentAttachedFile.fileData) {
+              const fileName = this.currentAttachedFile.fileName;
+              let kind = "unknown";
+              if (fileName) {
+                const lowerName = fileName.toLowerCase();
+                if (lowerName.startsWith("cover.")) {
+                  kind = "coverFront";
+                } else if (lowerName.startsWith("back.")) {
+                  kind = "coverBack";
+                }
+              }
+              this.currentSegment.metadataTags.images ??= [];
+              this.currentSegment.metadataTags.images.push({
+                data: this.currentAttachedFile.fileData,
+                mimeType: this.currentAttachedFile.fileMediaType,
+                kind,
+                name: this.currentAttachedFile.fileName ?? void 0,
+                description: this.currentAttachedFile.fileDescription ?? void 0
+              });
+            }
+            this.currentAttachedFile = null;
+          }
+          ;
+          break;
+        case 18030 /* FileName */:
+          {
+            if (!this.currentAttachedFile) break;
+            this.currentAttachedFile.fileName = readUnicodeString(slice, size);
+          }
+          ;
+          break;
+        case 18016 /* FileMediaType */:
+          {
+            if (!this.currentAttachedFile) break;
+            this.currentAttachedFile.fileMediaType = readAsciiString(slice, size);
+          }
+          ;
+          break;
+        case 18012 /* FileData */:
+          {
+            if (!this.currentAttachedFile) break;
+            this.currentAttachedFile.fileData = readBytes(slice, size);
+          }
+          ;
+          break;
+        case 18046 /* FileDescription */:
+          {
+            if (!this.currentAttachedFile) break;
+            this.currentAttachedFile.fileDescription = readUnicodeString(slice, size);
+          }
+          ;
+          break;
       }
       slice.filePos = dataStartPos + size;
       return true;
     }
+    processTagValue(name, value) {
+      if (!this.currentSegment?.metadataTags) return;
+      const metadataTags = this.currentSegment.metadataTags;
+      metadataTags.raw ??= {};
+      metadataTags.raw[name] ??= value;
+      if (typeof value === "string") {
+        switch (name.toLowerCase()) {
+          case "title":
+            {
+              metadataTags.title ??= value;
+            }
+            ;
+            break;
+          case "description":
+            {
+              metadataTags.description ??= value;
+            }
+            ;
+            break;
+          case "artist":
+            {
+              metadataTags.artist ??= value;
+            }
+            ;
+            break;
+          case "album":
+            {
+              metadataTags.album ??= value;
+            }
+            ;
+            break;
+          case "album_artist":
+            {
+              metadataTags.albumArtist ??= value;
+            }
+            ;
+            break;
+          case "genre":
+            {
+              metadataTags.genre ??= value;
+            }
+            ;
+            break;
+          case "comment":
+            {
+              metadataTags.comment ??= value;
+            }
+            ;
+            break;
+          case "lyrics":
+            {
+              metadataTags.lyrics ??= value;
+            }
+            ;
+            break;
+          case "date":
+            {
+              const date = new Date(value);
+              if (!Number.isNaN(date.getTime())) {
+                metadataTags.date ??= date;
+              }
+            }
+            ;
+            break;
+          case "track_number":
+          case "part_number":
+            {
+              const parts = value.split("/");
+              const trackNum = Number.parseInt(parts[0], 10);
+              const tracksTotal = parts[1] && Number.parseInt(parts[1], 10);
+              if (Number.isInteger(trackNum) && trackNum > 0) {
+                metadataTags.trackNumber ??= trackNum;
+              }
+              if (tracksTotal && Number.isInteger(tracksTotal) && tracksTotal > 0) {
+                metadataTags.tracksTotal ??= tracksTotal;
+              }
+            }
+            ;
+            break;
+          case "disc_number":
+          case "disc":
+            {
+              const discParts = value.split("/");
+              const discNum = Number.parseInt(discParts[0], 10);
+              const discsTotal = discParts[1] && Number.parseInt(discParts[1], 10);
+              if (Number.isInteger(discNum) && discNum > 0) {
+                metadataTags.discNumber ??= discNum;
+              }
+              if (discsTotal && Number.isInteger(discsTotal) && discsTotal > 0) {
+                metadataTags.discsTotal ??= discsTotal;
+              }
+            }
+            ;
+            break;
+        }
+      }
+    }
   };
   var MatroskaTrackBacking = class {
     constructor(internalTrack) {
@@ -16881,43 +19797,6 @@ ${cue.notes ?? ""}`;
     return result;
   };
 
-  // src/mp3/mp3-reader.ts
-  var readId3 = (slice) => {
-    const tag = readAscii(slice, 3);
-    if (tag !== "ID3") {
-      slice.skip(-3);
-      return null;
-    }
-    slice.skip(3);
-    const size = decodeSynchsafe(readU32Be(slice));
-    return { size };
-  };
-  var readNextFrameHeader = async (reader, startPos, until) => {
-    let currentPos = startPos;
-    while (until === null || currentPos < until) {
-      let slice = reader.requestSlice(currentPos, FRAME_HEADER_SIZE);
-      if (slice instanceof Promise) slice = await slice;
-      if (!slice) break;
-      const word = readU32Be(slice);
-      const result = readFrameHeader(word, reader.fileSize !== null ? reader.fileSize - currentPos : null);
-      if (result.header) {
-        return { header: result.header, startPos: currentPos };
-      }
-      currentPos += result.bytesAdvanced;
-    }
-    return null;
-  };
-  var decodeSynchsafe = (synchsafed) => {
-    let mask = 2130706432;
-    let unsynchsafed = 0;
-    while (mask !== 0) {
-      unsynchsafed >>= 1;
-      unsynchsafed |= synchsafed & mask;
-      mask >>= 8;
-    }
-    return unsynchsafed;
-  };
-
   // src/mp3/mp3-demuxer.ts
   var Mp3Demuxer = class extends Demuxer {
     constructor(input) {
@@ -16926,6 +19805,7 @@ ${cue.notes ?? ""}`;
       this.firstFrameHeader = null;
       this.loadedSamples = [];
       // All samples from the start of the file to lastLoadedPos
+      this.metadataTags = null;
       this.tracks = [];
       this.readingMutex = new AsyncMutex();
       this.lastSampleLoaded = false;
@@ -16938,21 +19818,26 @@ ${cue.notes ?? ""}`;
         while (!this.firstFrameHeader && !this.lastSampleLoaded) {
           await this.advanceReader();
         }
-        assert(this.firstFrameHeader);
+        if (!this.firstFrameHeader) {
+          throw new Error("No valid MP3 frame found.");
+        }
         this.tracks = [new InputAudioTrack(new Mp3AudioTrackBacking(this))];
       })();
     }
     async advanceReader() {
       if (this.lastLoadedPos === 0) {
-        let slice2 = this.reader.requestSlice(0, 10);
-        if (slice2 instanceof Promise) slice2 = await slice2;
-        if (!slice2) {
-          this.lastSampleLoaded = true;
-          return;
-        }
-        const id3Tag = readId3(slice2);
-        if (id3Tag) {
-          this.lastLoadedPos += 10 + id3Tag.size;
+        while (true) {
+          let slice2 = this.reader.requestSlice(this.lastLoadedPos, ID3_V2_HEADER_SIZE);
+          if (slice2 instanceof Promise) slice2 = await slice2;
+          if (!slice2) {
+            this.lastSampleLoaded = true;
+            return;
+          }
+          const id3V2Header = readId3V2Header(slice2);
+          if (!id3V2Header) {
+            break;
+          }
+          this.lastLoadedPos = slice2.filePos + id3V2Header.size;
         }
       }
       const result = await readNextFrameHeader(this.reader, this.lastLoadedPos, this.reader.fileSize);
@@ -16999,6 +19884,45 @@ ${cue.notes ?? ""}`;
       assert(track);
       return track.computeDuration();
     }
+    async getMetadataTags() {
+      const release = await this.readingMutex.acquire();
+      try {
+        await this.readMetadata();
+        if (this.metadataTags) {
+          return this.metadataTags;
+        }
+        this.metadataTags = {};
+        let currentPos = 0;
+        let id3V2HeaderFound = false;
+        while (true) {
+          let headerSlice = this.reader.requestSlice(currentPos, ID3_V2_HEADER_SIZE);
+          if (headerSlice instanceof Promise) headerSlice = await headerSlice;
+          if (!headerSlice) break;
+          const id3V2Header = readId3V2Header(headerSlice);
+          if (!id3V2Header) {
+            break;
+          }
+          id3V2HeaderFound = true;
+          let contentSlice = this.reader.requestSlice(headerSlice.filePos, id3V2Header.size);
+          if (contentSlice instanceof Promise) contentSlice = await contentSlice;
+          if (!contentSlice) break;
+          parseId3V2Tag(contentSlice, id3V2Header, this.metadataTags);
+          currentPos = headerSlice.filePos + id3V2Header.size;
+        }
+        if (!id3V2HeaderFound && this.reader.fileSize !== null && this.reader.fileSize >= ID3_V1_TAG_SIZE) {
+          let slice = this.reader.requestSlice(this.reader.fileSize - ID3_V1_TAG_SIZE, ID3_V1_TAG_SIZE);
+          if (slice instanceof Promise) slice = await slice;
+          assert(slice);
+          const tag = readAscii(slice, 3);
+          if (tag === "TAG") {
+            parseId3V1Tag(slice, this.metadataTags);
+          }
+        }
+        return this.metadataTags;
+      } finally {
+        release();
+      }
+    }
   };
   var Mp3AudioTrackBacking = class {
     constructor(demuxer) {
@@ -17136,6 +20060,7 @@ ${cue.notes ?? ""}`;
       this.metadataPromise = null;
       this.bitstreams = [];
       this.tracks = [];
+      this.metadataTags = {};
       this.reader = input._reader;
     }
     async readMetadata() {
@@ -17256,6 +20181,7 @@ ${cue.notes ?? ""}`;
         ],
         modeBlockflags: parseModesFromVorbisSetupPacket(thirdPacket.data).modeBlockflags
       };
+      this.readVorbisComments(secondPacket.data.subarray(7));
     }
     async readOpusMetadata(firstPacket, bitstream) {
       const nextPacketPosition = await this.findNextPacketStart(firstPacket);
@@ -17278,6 +20204,172 @@ ${cue.notes ?? ""}`;
       bitstream.codecInfo.opusInfo = {
         preSkip: header.preSkip
       };
+      this.readVorbisComments(secondPacket.data.subarray(8));
+    }
+    readVorbisComments(bytes2) {
+      const commentView = toDataView(bytes2);
+      let commentPos = 0;
+      const vendorStringLength = commentView.getUint32(commentPos, true);
+      commentPos += 4;
+      const vendorString = textDecoder.decode(
+        bytes2.subarray(commentPos, commentPos + vendorStringLength)
+      );
+      commentPos += vendorStringLength;
+      if (vendorStringLength > 0) {
+        this.metadataTags.raw ??= {};
+        this.metadataTags.raw["vendor"] ??= vendorString;
+      }
+      const listLength = commentView.getUint32(commentPos, true);
+      commentPos += 4;
+      for (let i = 0; i < listLength; i++) {
+        const stringLength = commentView.getUint32(commentPos, true);
+        commentPos += 4;
+        const string = textDecoder.decode(
+          bytes2.subarray(commentPos, commentPos + stringLength)
+        );
+        commentPos += stringLength;
+        const separatorIndex = string.indexOf("=");
+        if (separatorIndex === -1) {
+          continue;
+        }
+        const key = string.slice(0, separatorIndex).toUpperCase();
+        const value = string.slice(separatorIndex + 1);
+        this.metadataTags.raw ??= {};
+        this.metadataTags.raw[key] ??= value;
+        switch (key) {
+          case "TITLE":
+            {
+              this.metadataTags.title ??= value;
+            }
+            ;
+            break;
+          case "DESCRIPTION":
+            {
+              this.metadataTags.description ??= value;
+            }
+            ;
+            break;
+          case "ARTIST":
+            {
+              this.metadataTags.artist ??= value;
+            }
+            ;
+            break;
+          case "ALBUM":
+            {
+              this.metadataTags.album ??= value;
+            }
+            ;
+            break;
+          case "ALBUMARTIST":
+            {
+              this.metadataTags.albumArtist ??= value;
+            }
+            ;
+            break;
+          case "COMMENT":
+            {
+              this.metadataTags.comment ??= value;
+            }
+            ;
+            break;
+          case "LYRICS":
+            {
+              this.metadataTags.lyrics ??= value;
+            }
+            ;
+            break;
+          case "TRACKNUMBER":
+            {
+              const parts = value.split("/");
+              const trackNum = Number.parseInt(parts[0], 10);
+              const tracksTotal = parts[1] && Number.parseInt(parts[1], 10);
+              if (Number.isInteger(trackNum) && trackNum > 0) {
+                this.metadataTags.trackNumber ??= trackNum;
+              }
+              if (tracksTotal && Number.isInteger(tracksTotal) && tracksTotal > 0) {
+                this.metadataTags.tracksTotal ??= tracksTotal;
+              }
+            }
+            ;
+            break;
+          case "TRACKTOTAL":
+            {
+              const tracksTotal = Number.parseInt(value, 10);
+              if (Number.isInteger(tracksTotal) && tracksTotal > 0) {
+                this.metadataTags.tracksTotal ??= tracksTotal;
+              }
+            }
+            ;
+            break;
+          case "DISCNUMBER":
+            {
+              const parts = value.split("/");
+              const discNum = Number.parseInt(parts[0], 10);
+              const discsTotal = parts[1] && Number.parseInt(parts[1], 10);
+              if (Number.isInteger(discNum) && discNum > 0) {
+                this.metadataTags.discNumber ??= discNum;
+              }
+              if (discsTotal && Number.isInteger(discsTotal) && discsTotal > 0) {
+                this.metadataTags.discsTotal ??= discsTotal;
+              }
+            }
+            ;
+            break;
+          case "DISCTOTAL":
+            {
+              const discsTotal = Number.parseInt(value, 10);
+              if (Number.isInteger(discsTotal) && discsTotal > 0) {
+                this.metadataTags.discsTotal ??= discsTotal;
+              }
+            }
+            ;
+            break;
+          case "DATE":
+            {
+              const date = new Date(value);
+              if (!Number.isNaN(date.getTime())) {
+                this.metadataTags.date ??= date;
+              }
+            }
+            ;
+            break;
+          case "GENRE":
+            {
+              this.metadataTags.genre ??= value;
+            }
+            ;
+            break;
+          case "METADATA_BLOCK_PICTURE":
+            {
+              const decoded = base64ToBytes(value);
+              const view2 = toDataView(decoded);
+              const pictureType = view2.getUint32(0, false);
+              const mediaTypeLength = view2.getUint32(4, false);
+              const mediaType = String.fromCharCode(...decoded.subarray(8, 8 + mediaTypeLength));
+              const descriptionLength = view2.getUint32(8 + mediaTypeLength, false);
+              const description = textDecoder.decode(decoded.subarray(
+                12 + mediaTypeLength,
+                12 + mediaTypeLength + descriptionLength
+              ));
+              const dataLength = view2.getUint32(mediaTypeLength + descriptionLength + 28);
+              const data = decoded.subarray(
+                mediaTypeLength + descriptionLength + 32,
+                mediaTypeLength + descriptionLength + 32 + dataLength
+              );
+              this.metadataTags.images ??= [];
+              this.metadataTags.images.push({
+                data,
+                mimeType: mediaType,
+                kind: pictureType === 3 ? "coverFront" : pictureType === 4 ? "coverBack" : "unknown",
+                name: void 0,
+                description: description || void 0
+              });
+            }
+            ;
+            break;
+        }
+      }
     }
     async readPacket(startPage, startSegmentIndex) {
       assert(startSegmentIndex < startPage.lacingValues.length);
@@ -17384,6 +20476,10 @@ ${cue.notes ?? ""}`;
       const trackDurations = await Promise.all(tracks.map((x) => x.computeDuration()));
       return Math.max(0, ...trackDurations);
     }
+    async getMetadataTags() {
+      await this.readMetadata();
+      return this.metadataTags;
+    }
   };
   var OggAudioTrackBacking = class {
     constructor(bitstream, demuxer) {
@@ -17973,6 +21069,9 @@ ${cue.notes ?? ""}`;
       assert(track);
       return track.computeDuration();
     }
+    async getMetadataTags() {
+      return {};
+    }
   };
   var AdtsAudioTrackBacking = class {
     constructor(demuxer) {
@@ -18274,15 +21373,23 @@ ${cue.notes ?? ""}`;
       if (slice instanceof Promise) slice = await slice;
       if (!slice) return false;
       let currentPos = 0;
-      const id3Tag = readId3(slice);
-      if (id3Tag) {
-        currentPos = slice.filePos + id3Tag.size;
+      let id3V2HeaderFound = false;
+      while (true) {
+        let slice2 = input._reader.requestSlice(currentPos, ID3_V2_HEADER_SIZE);
+        if (slice2 instanceof Promise) slice2 = await slice2;
+        if (!slice2) break;
+        const id3V2Header = readId3V2Header(slice2);
+        if (!id3V2Header) {
+          break;
+        }
+        id3V2HeaderFound = true;
+        currentPos = slice2.filePos + id3V2Header.size;
       }
       const firstResult = await readNextFrameHeader(input._reader, currentPos, currentPos + 4096);
       if (!firstResult) {
         return false;
       }
-      if (id3Tag) {
+      if (id3V2HeaderFound) {
         return true;
       }
       currentPos = firstResult.startPos += firstResult.header.totalSize;
@@ -18485,6 +21592,11 @@ ${cue.notes ?? ""}`;
       const demuxer = await this._getDemuxer();
       return demuxer.getMimeType();
     }
+    /** Returns descriptive metadata tags about the media file, such as title, author, date, or cover art. */
+    async getMetadataTags() {
+      const demuxer = await this._getDemuxer();
+      return demuxer.getMetadataTags();
+    }
   };
 
   // src/conversion.ts
@@ -18626,6 +21738,9 @@ ${cue.notes ?? ""}`;
       if (options.trim?.start !== void 0 && options.trim.end !== void 0 && options.trim.start >= options.trim.end) {
         throw new TypeError("options.trim.start must be less than options.trim.end.");
       }
+      if (options.tags !== void 0 && typeof options.tags !== "function") {
+        throw new TypeError("options.tags, when provided, must be a function.");
+      }
       this._options = options;
       this.input = options.input;
       this.output = options.output;
@@ -18703,6 +21818,21 @@ ${cue.notes ?? ""}`;
       if (unintentionallyDiscardedTracks.length > 0) {
         console.warn("Some tracks had to be discarded from the conversion:", unintentionallyDiscardedTracks);
       }
+      const inputTags = await this.input.getMetadataTags();
+      let outputTags;
+      if (this._options.tags) {
+        const result = await this._options.tags(inputTags);
+        validateMetadataTags(result);
+        outputTags = result;
+      } else {
+        outputTags = inputTags;
+      }
+      const inputAndOutputFormatMatch = (await this.input.getFormat()).mimeType === this.output.format.mimeType;
+      const rawTagsAreUnchanged = inputTags.raw === outputTags.raw;
+      if (inputTags.raw && rawTagsAreUnchanged && !inputAndOutputFormatMatch) {
+        delete outputTags.raw;
+      }
+      this.output.setMetadataTags(outputTags);
     }
     /** Executes the conversion process. Resolves once conversion is complete. */
     async execute() {
@@ -18788,7 +21918,7 @@ ${cue.notes ?? ""}`;
           await this._started;
           const sink = new EncodedPacketSink(track);
           const decoderConfig = await track.getDecoderConfig();
-          const meta = { decoderConfig: decoderConfig ?? void 0 };
+          const meta2 = { decoderConfig: decoderConfig ?? void 0 };
           const endPacket = Number.isFinite(this._endTimestamp) ? await sink.getPacket(this._endTimestamp, { metadataOnly: true }) ?? void 0 : void 0;
           for await (const packet of sink.packets(void 0, endPacket, { verifyKeyPackets: true })) {
             if (this._synchronizer.shouldWait(track.id, packet.timestamp)) {
@@ -18797,7 +21927,7 @@ ${cue.notes ?? ""}`;
             if (this._canceled) {
               return;
             }
-            await source.add(packet, meta);
+            await source.add(packet, meta2);
             this._reportProgress(track.id, packet.timestamp + packet.duration);
           }
           source.close();
@@ -19027,7 +22157,7 @@ ${cue.notes ?? ""}`;
           await this._started;
           const sink = new EncodedPacketSink(track);
           const decoderConfig = await track.getDecoderConfig();
-          const meta = { decoderConfig: decoderConfig ?? void 0 };
+          const meta2 = { decoderConfig: decoderConfig ?? void 0 };
           const endPacket = Number.isFinite(this._endTimestamp) ? await sink.getPacket(this._endTimestamp, { metadataOnly: true }) ?? void 0 : void 0;
           for await (const packet of sink.packets(void 0, endPacket)) {
             if (this._synchronizer.shouldWait(track.id, packet.timestamp)) {
@@ -19036,7 +22166,7 @@ ${cue.notes ?? ""}`;
             if (this._canceled) {
               return;
             }
-            await source.add(packet, meta);
+            await source.add(packet, meta2);
             this._reportProgress(track.id, packet.timestamp + packet.duration);
           }
           source.close();