@remotion/media-parser 4.0.237 → 4.0.239

package/dist/esm/index.mjs

@@ -106,6 +106,38 @@ var fetchReader = {
 };
 
 // src/aac-codecprivate.ts
+var getSampleRateFromSampleFrequencyIndex = (samplingFrequencyIndex) => {
+  switch (samplingFrequencyIndex) {
+    case 0:
+      return 96000;
+    case 1:
+      return 88200;
+    case 2:
+      return 64000;
+    case 3:
+      return 48000;
+    case 4:
+      return 44100;
+    case 5:
+      return 32000;
+    case 6:
+      return 24000;
+    case 7:
+      return 22050;
+    case 8:
+      return 16000;
+    case 9:
+      return 12000;
+    case 10:
+      return 11025;
+    case 11:
+      return 8000;
+    case 12:
+      return 7350;
+    default:
+      throw new Error(`Unexpected sampling frequency index ${samplingFrequencyIndex}`);
+  }
+};
 var getConfigForSampleRate = (sampleRate) => {
   if (sampleRate === 96000) {
     return 0;
@@ -175,44 +207,35 @@ var parseAacCodecPrivate = (bytes) => {
   const audioObjectType = parseInt(bits.slice(0, 5), 2);
   const samplingFrequencyIndex = parseInt(bits.slice(5, 9), 2);
   const channelConfiguration = parseInt(bits.slice(9, 13), 2);
-  const sampleRate = (() => {
-    switch (samplingFrequencyIndex) {
-      case 0:
-        return 96000;
-      case 1:
-        return 88200;
-      case 2:
-        return 64000;
-      case 3:
-        return 48000;
-      case 4:
-        return 44100;
-      case 5:
-        return 32000;
-      case 6:
-        return 24000;
-      case 7:
-        return 22050;
-      case 8:
-        return 16000;
-      case 9:
-        return 12000;
-      case 10:
-        return 11025;
-      case 11:
-        return 8000;
-      case 12:
-        return 7350;
-      default:
-        throw new Error(`Unexpected sampling frequency index ${samplingFrequencyIndex}`);
-    }
-  })();
+  const sampleRate = getSampleRateFromSampleFrequencyIndex(samplingFrequencyIndex);
   return {
     audioObjectType,
     sampleRate,
     channelConfiguration
   };
 };
+var mapAudioObjectTypeToCodecString = (audioObjectType) => {
+  switch (audioObjectType) {
+    case 1:
+      return "mp4a.40.2";
+    case 2:
+      return "mp4a.40.5";
+    case 3:
+      return "mp4a.40.29";
+    case 4:
+      return "mp4a.40.1";
+    case 5:
+      return "mp4a.40.3";
+    case 6:
+      return "mp4a.40.4";
+    case 17:
+      return "mp4a.40.17";
+    case 23:
+      return "mp4a.40.23";
+    default:
+      throw new Error(`Unexpected audio object type ${audioObjectType}`);
+  }
+};
 
 // src/create/event-emitter.ts
 class IoEventEmitter {
@@ -1343,7 +1366,7 @@ var createIsoBaseMediaFtyp = ({
 };
 
 // src/version.ts
-var VERSION = "4.0.237";
+var VERSION = "4.0.239";
 
 // src/create/iso-base-media/create-ilst.ts
 var createIlst = (items) => {
@@ -1872,6 +1895,9 @@ var createStsz = (samplePositions) => {
 
 // src/create/iso-base-media/trak/mdia/minf/stbl/create-stts.ts
 var makeEntry2 = (entry) => {
+  if (entry.sampleOffset < 0) {
+    throw new Error("negative sample offset in stts " + entry.sampleOffset);
+  }
   return combineUint8Arrays([
     numberTo32BitUIntOrInt(entry.sampleCount),
     numberTo32BitUIntOrInt(entry.sampleOffset)
@@ -1923,10 +1949,11 @@ var createStbl = ({
   codecSpecificData,
   isVideo
 }) => {
+  const sorted = samplePositions.slice().sort((a, b) => a.dts - b.dts);
   return addSize(combineUint8Arrays([
     stringsToUint8Array("stbl"),
     createStsdData(codecSpecificData),
-    createSttsAtom(samplePositions),
+    createSttsAtom(sorted),
     isVideo ? createStss(samplePositions) : null,
     createCttsBox(samplePositions),
     createStsc(samplePositions),
@@ -2119,6 +2146,7 @@ var createPaddedMoovAtom = ({
 };
 
 // src/create/iso-base-media/create-iso-base-media.ts
+var CONTAINER_TIMESCALE = 1000;
 var createIsoBaseMedia = async ({
   writer,
   onBytesProgress,
@@ -2134,23 +2162,25 @@ var createIsoBaseMedia = async ({
   });
   const w = await writer.createContent({ filename, mimeType: "video/mp4" });
   await w.write(header);
-  let durationInUnits = 0;
+  let globalDurationInUnits = 0;
+  const lowestTrackTimestamps = {};
+  const trackDurations = {};
   const currentTracks = [];
   const samplePositions = [];
   const sampleChunkIndices = [];
   const moovOffset = w.getWrittenByteCount();
   const getPaddedMoovAtom = () => {
     return createPaddedMoovAtom({
-      durationInUnits,
+      durationInUnits: globalDurationInUnits,
       trackInfo: currentTracks.map((track) => {
         return {
           track,
-          durationInUnits,
+          durationInUnits: trackDurations[track.trackNumber] ?? 0,
           samplePositions: samplePositions[track.trackNumber] ?? [],
           timescale: track.timescale
         };
       }),
-      timescale: 1000
+      timescale: CONTAINER_TIMESCALE
     });
   };
   await w.write(getPaddedMoovAtom());
@@ -2169,10 +2199,6 @@ var createIsoBaseMedia = async ({
     await w.updateDataAt(moovOffset, getPaddedMoovAtom());
     onBytesProgress(w.getWrittenByteCount());
   };
-  const updateDuration = (newDuration) => {
-    durationInUnits = newDuration;
-    onMillisecondsProgress(newDuration);
-  };
   const addCodecPrivateToTrack = ({
     trackNumber: trackNumber2,
     codecPrivate: codecPrivate2
@@ -2188,19 +2214,35 @@ var createIsoBaseMedia = async ({
     chunk,
     trackNumber: trackNumber2,
     isVideo,
-    timescale,
     codecPrivate: codecPrivate2
   }) => {
     const position = w.getWrittenByteCount();
     await w.write(chunk.data);
     mdatSize += chunk.data.length;
     onBytesProgress(w.getWrittenByteCount());
+    progressTracker.setPossibleLowestTimestamp(Math.min(chunk.timestamp, chunk.cts ?? Infinity, chunk.dts ?? Infinity));
     progressTracker.updateTrackProgress(trackNumber2, chunk.timestamp);
     if (codecPrivate2) {
       addCodecPrivateToTrack({ trackNumber: trackNumber2, codecPrivate: codecPrivate2 });
     }
-    const newDuration = Math.round((chunk.timestamp + (chunk.duration ?? 0)) / 1000);
-    updateDuration(newDuration);
+    const currentTrack = currentTracks.find((t) => t.trackNumber === trackNumber2);
+    if (!currentTrack) {
+      throw new Error(`Tried to add sample to track ${trackNumber2}, but it doesn't exist`);
+    }
+    if (!lowestTrackTimestamps[trackNumber2] || chunk.timestamp < lowestTrackTimestamps[trackNumber2]) {
+      lowestTrackTimestamps[trackNumber2] = chunk.timestamp;
+    }
+    if (typeof lowestTrackTimestamps[trackNumber2] !== "number") {
+      throw new Error(`Tried to add sample to track ${trackNumber2}, but it has no timestamp`);
+    }
+    const newDurationInMicroSeconds = chunk.timestamp + (chunk.duration ?? 0) - lowestTrackTimestamps[trackNumber2];
+    const newDurationInTrackTimeUnits = Math.round(newDurationInMicroSeconds / (1e6 / currentTrack.timescale));
+    trackDurations[trackNumber2] = newDurationInTrackTimeUnits;
+    const newDurationInMilliseconds = Math.round(newDurationInMicroSeconds / 1e6 * CONTAINER_TIMESCALE);
+    if (newDurationInMilliseconds > globalDurationInUnits) {
+      globalDurationInUnits = newDurationInMilliseconds;
+      onMillisecondsProgress(newDurationInMilliseconds);
+    }
     if (!samplePositions[trackNumber2]) {
       samplePositions[trackNumber2] = [];
     }
@@ -2218,9 +2260,9 @@ var createIsoBaseMedia = async ({
       isKeyframe: chunk.type === "key",
       offset: position,
       chunk: sampleChunkIndices[trackNumber2],
-      cts: Math.round(chunk.cts / (1e6 / timescale)),
-      dts: Math.round(chunk.dts / (1e6 / timescale)),
-      duration: Math.round((chunk.duration ?? 0) / (1e6 / timescale)),
+      cts: Math.round(chunk.cts / 1e6 * currentTrack.timescale),
+      dts: Math.round(chunk.dts / 1e6 * currentTrack.timescale),
+      duration: Math.round((chunk.duration ?? 0) / 1e6 * currentTrack.timescale),
       size: chunk.data.length
     };
     lastChunkWasVideo = isVideo;
@@ -2240,13 +2282,12 @@ var createIsoBaseMedia = async ({
     remove: async () => {
       await w.remove();
     },
-    addSample: ({ chunk, trackNumber: trackNumber2, isVideo, timescale, codecPrivate: codecPrivate2 }) => {
+    addSample: ({ chunk, trackNumber: trackNumber2, isVideo, codecPrivate: codecPrivate2 }) => {
       operationProm.current = operationProm.current.then(() => {
         return addSample({
           chunk,
           trackNumber: trackNumber2,
           isVideo,
-          timescale,
           codecPrivate: codecPrivate2
         });
       });
@@ -3318,20 +3359,37 @@ var withResolversAndWaitForReturn = () => {
 var makeProgressTracker = () => {
   const trackNumberProgresses = {};
   const eventEmitter = new IoEventEmitter;
-  const calculateSmallestProgress = () => {
-    const progressValues = Object.values(trackNumberProgresses);
-    if (progressValues.length === 0) {
-      return 0;
+  let startingTimestamp = null;
+  const setPossibleLowestTimestamp = (timestamp) => {
+    if (startingTimestamp === null) {
+      startingTimestamp = timestamp;
+    } else {
+      startingTimestamp = Math.min(startingTimestamp, timestamp);
     }
+  };
+  const getStartingTimestamp = () => {
+    if (startingTimestamp === null) {
+      throw new Error("No starting timestamp");
+    }
+    return startingTimestamp;
+  };
+  const calculateSmallestProgress = () => {
+    const progressValues = Object.values(trackNumberProgresses).map((p) => {
+      if (p !== null) {
+        return p;
+      }
+      if (startingTimestamp === null) {
+        throw new Error("No progress values to calculate smallest progress from");
+      }
+      return startingTimestamp;
+    });
     return Math.min(...progressValues);
   };
   return {
     registerTrack: (trackNumber2) => {
-      trackNumberProgresses[trackNumber2] = 0;
-    },
-    getSmallestProgress: () => {
-      return calculateSmallestProgress();
+      trackNumberProgresses[trackNumber2] = null;
     },
+    getSmallestProgress: calculateSmallestProgress,
     updateTrackProgress: (trackNumber2, progress) => {
       if (trackNumberProgresses[trackNumber2] === undefined) {
         throw new Error(`Tried to update progress for a track that was not registered: ${trackNumber2}`);
@@ -3349,7 +3407,9 @@ var makeProgressTracker = () => {
       };
       eventEmitter.addEventListener("processed", on);
       return promise;
-    }
+    },
+    getStartingTimestamp,
+    setPossibleLowestTimestamp
   };
 };
 
@@ -3819,6 +3879,9 @@ var getMetadata = (structure) => {
   if (structure.type === "riff") {
     return getMetadataFromRiff(structure);
   }
+  if (structure.type === "transport-stream") {
+    return [];
+  }
   return getMetadataFromIsoBase(structure);
 };
 
@@ -3944,6 +4007,9 @@ var getFps = (segments) => {
   if (segments.type === "matroska") {
     return null;
   }
+  if (segments.type === "transport-stream") {
+    return null;
+  }
   throw new Error("Cannot get fps, not implemented");
 };
 var hasFps = (boxes) => {
@@ -3951,6 +4017,9 @@ var hasFps = (boxes) => {
     if (boxes.type === "matroska") {
       return true;
     }
+    if (boxes.type === "transport-stream") {
+      return true;
+    }
     return getFps(boxes) !== null;
   } catch {
     return false;
@@ -4278,6 +4347,17 @@ var getDisplayAspectRatio = ({
   return reduceFraction(num, den);
 };
 
+// src/boxes/avc/color.ts
+var getMatrixCoefficientsFromIndex = (index) => {
+  return index === 1 ? "bt709" : index === 5 ? "bt470bg" : index === 6 ? "smpte170m" : index === 9 ? "bt2020" : null;
+};
+var getTransferCharacteristicsFromIndex = (index) => {
+  return index === 1 ? "bt709" : index === 6 ? "smpte170m" : index === 13 ? "iec61966-2-1" : index === 18 ? "arib-std-b67" : null;
+};
+var getPrimariesFromIndex = (index) => {
+  return index === 1 ? "bt709" : index === 5 ? "bt470bg" : index === 6 ? "smpte170m" : index === 9 ? "bt2020" : null;
+};
+
 // src/buffer-iterator.ts
 class OffsetCounter {
   #offset;
@@ -4474,6 +4554,9 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
   const isMp3 = () => {
     return matchesPattern(mpegPattern)(data.subarray(0, 4));
   };
+  const isTransportStream = () => {
+    return data[0] === 71;
+  };
   const removeBytesRead = () => {
     if (!discardAllowed) {
       return;
@@ -4510,6 +4593,20 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
       removeBytesRead();
     }
   };
+  const readExpGolomb = () => {
+    if (!bitReadingMode) {
+      throw new Error("Not in bit reading mode");
+    }
+    let zerosCount = 0;
+    while (getBits(1) === 0) {
+      zerosCount++;
+    }
+    let suffix = 0;
+    for (let i = 0;i < zerosCount; i++) {
+      suffix = suffix << 1 | getBits(1);
+    }
+    return (1 << zerosCount) - 1 + suffix;
+  };
   const peekB = (length) => {
     console.log([...getSlice(length)].map((b) => b.toString(16).padStart(2, "0")));
     counter.decrement(length);
@@ -4532,9 +4629,12 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
   let bitIndex = 0;
   const stopReadingBits = () => {
     bitIndex = 0;
+    bitReadingMode = false;
   };
   let byteToShift = 0;
+  let bitReadingMode = false;
   const startReadingBits = () => {
+    bitReadingMode = true;
     byteToShift = getUint8();
   };
   const getBits = (bits) => {
@@ -4739,7 +4839,9 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
     isMp3,
     disallowDiscard,
     allowDiscard,
-    startBox
+    startBox,
+    isTransportStream,
+    readExpGolomb
   };
 };
 
@@ -4806,114 +4908,9 @@ var parseAv1PrivateData = (data, colrAtom) => {
 };
 
 // src/get-video-codec.ts
-var getVideoCodecFromIsoTrak = (trakBox) => {
-  const stsdBox = getStsdBox(trakBox);
-  if (stsdBox && stsdBox.type === "stsd-box") {
-    const videoSample = stsdBox.samples.find((s) => s.type === "video");
-    if (videoSample && videoSample.type === "video") {
-      if (videoSample.format === "hvc1") {
-        return "h265";
-      }
-      if (videoSample.format === "avc1") {
-        return "h264";
-      }
-      if (videoSample.format === "av01") {
-        return "av1";
-      }
-      if (videoSample.format === "ap4h") {
-        return "prores";
-      }
-      if (videoSample.format === "ap4x") {
-        return "prores";
-      }
-      if (videoSample.format === "apch") {
-        return "prores";
-      }
-      if (videoSample.format === "apcn") {
-        return "prores";
-      }
-      if (videoSample.format === "apcs") {
-        return "prores";
-      }
-      if (videoSample.format === "apco") {
-        return "prores";
-      }
-      if (videoSample.format === "aprh") {
-        return "prores";
-      }
-      if (videoSample.format === "aprn") {
-        return "prores";
-      }
-    }
-  }
-  throw new Error("Could not find video codec");
-};
-var getVideoCodecFromMatroska = (boxes) => {
-  const mainSegment = boxes.find((b) => b.type === "Segment");
-  if (!mainSegment || mainSegment.type !== "Segment") {
-    return null;
-  }
-  const tracksSegment = mainSegment.value.find((b) => b.type === "Tracks");
-  if (!tracksSegment || tracksSegment.type !== "Tracks") {
-    return null;
-  }
-  for (const track of tracksSegment.value) {
-    if (track.type === "TrackEntry") {
-      const trackType2 = track.value.find((b) => b.type === "CodecID");
-      if (trackType2 && trackType2.type === "CodecID") {
-        if (trackType2.value === "V_VP8") {
-          return "vp8";
-        }
-        if (trackType2.value === "V_VP9") {
-          return "vp9";
-        }
-        if (trackType2.value === "V_AV1") {
-          return "av1";
-        }
-        if (trackType2.value === "V_MPEG4/ISO/AVC") {
-          return "h264";
-        }
-        if (trackType2.value === "V_MPEGH/ISO/HEVC") {
-          return "h265";
-        }
-      }
-    }
-  }
-  throw new Error("Could not find video codec");
-};
-var getVideoCodecFromAvi = (structure) => {
-  const strl = getStrlBoxes(structure);
-  for (const s of strl) {
-    const strh = getStrhBox(s.children);
-    if (!strh) {
-      throw new Error("No strh box");
-    }
-    if (strh.fccType === "auds") {
-      continue;
-    }
-    if (strh.handler === "H264") {
-      return "h264";
-    }
-  }
-  throw new Error("Unsupported codec");
-};
-var getVideoCodec = (boxes) => {
-  if (boxes.type === "iso-base-media") {
-    const moovBox = getMoovBox(boxes.boxes);
-    if (moovBox) {
-      const trakBox = getTraks(moovBox).filter((t) => trakBoxContainsVideo(t))[0];
-      if (trakBox) {
-        return getVideoCodecFromIsoTrak(trakBox);
-      }
-    }
-  }
-  if (boxes.type === "riff") {
-    return getVideoCodecFromAvi(boxes);
-  }
-  if (boxes.type === "matroska") {
-    return getVideoCodecFromMatroska(boxes.boxes);
-  }
-  return null;
+var getVideoCodec = (boxes, state) => {
+  const track = getTracks(boxes, state);
+  return track.videoTracks[0]?.codecWithoutConfig ?? null;
 };
 var hasVideoCodec = (boxes, state) => {
   return hasTracks(boxes, state);
@@ -4951,9 +4948,9 @@ var getIsoBmColrConfig = (trakBox) => {
   }
   return {
     fullRange: colrAtom.fullRangeFlag,
-    matrixCoefficients: colrAtom.matrixIndex === 1 ? "bt709" : colrAtom.matrixIndex === 5 ? "bt470bg" : colrAtom.matrixIndex === 6 ? "smpte170m" : colrAtom.matrixIndex === 9 ? "bt2020" : null,
-    primaries: colrAtom.primaries === 1 ? "bt709" : colrAtom.primaries === 5 ? "bt470bg" : colrAtom.primaries === 6 ? "smpte170m" : colrAtom.primaries === 9 ? "bt2020" : null,
-    transferCharacteristics: colrAtom.transfer === 1 ? "bt709" : colrAtom.transfer === 6 ? "smpte170m" : colrAtom.transfer === 13 ? "iec61966-2-1" : colrAtom.transfer === 18 ? "arib-std-b67" : null
+    matrixCoefficients: getMatrixCoefficientsFromIndex(colrAtom.matrixIndex),
+    primaries: getPrimariesFromIndex(colrAtom.primaries),
+    transferCharacteristics: getTransferCharacteristicsFromIndex(colrAtom.transfer)
   };
 };
 var getVideoCodecString = (trakBox) => {
@@ -4998,6 +4995,50 @@ var getActualDecoderParameters = ({
   };
 };
 
+// src/boxes/iso-base-media/get-video-codec-from-iso-track.ts
+var getVideoCodecFromIsoTrak = (trakBox) => {
+  const stsdBox = getStsdBox(trakBox);
+  if (stsdBox && stsdBox.type === "stsd-box") {
+    const videoSample = stsdBox.samples.find((s) => s.type === "video");
+    if (videoSample && videoSample.type === "video") {
+      if (videoSample.format === "hvc1") {
+        return "h265";
+      }
+      if (videoSample.format === "avc1") {
+        return "h264";
+      }
+      if (videoSample.format === "av01") {
+        return "av1";
+      }
+      if (videoSample.format === "ap4h") {
+        return "prores";
+      }
+      if (videoSample.format === "ap4x") {
+        return "prores";
+      }
+      if (videoSample.format === "apch") {
+        return "prores";
+      }
+      if (videoSample.format === "apcn") {
+        return "prores";
+      }
+      if (videoSample.format === "apcs") {
+        return "prores";
+      }
+      if (videoSample.format === "apco") {
+        return "prores";
+      }
+      if (videoSample.format === "aprh") {
+        return "prores";
+      }
+      if (videoSample.format === "aprn") {
+        return "prores";
+      }
+    }
+  }
+  throw new Error("Could not find video codec");
+};
+
 // src/boxes/iso-base-media/make-track.ts
 var makeBaseMediaTrack = (trakBox) => {
   const tkhdBox = getTkhdBox(trakBox);
@@ -5095,6 +5136,30 @@ var makeBaseMediaTrack = (trakBox) => {
   return track;
 };
 
+// src/boxes/avc/codec-private.ts
+var getAvccBoxContent = (avc1Profile) => {
+  return combineUint8Arrays([
+    new Uint8Array([
+      1,
+      avc1Profile.sps.spsData.level,
+      avc1Profile.sps.spsData.compatibility,
+      avc1Profile.sps.spsData.profile,
+      255,
+      225
+    ]),
+    serializeUint16(avc1Profile.sps.sps.length),
+    avc1Profile.sps.sps,
+    new Uint8Array([1]),
+    serializeUint16(avc1Profile.pps.pps.length),
+    avc1Profile.pps.pps
+  ]);
+};
+
+// src/boxes/avc/codec-string.ts
+var getCodecStringFromSpsAndPps = (sps) => {
+  return `avc1.${sps.spsData.profile.toString(16).padStart(2, "0")}${sps.spsData.compatibility.toString(16).padStart(2, "0")}${sps.spsData.level.toString(16).padStart(2, "0")}`;
+};
+
 // src/add-avc-profile-to-track.ts
 var addAvcProfileToTrack = (track, avc1Profile) => {
   if (avc1Profile === null) {
@@ -5102,22 +5167,8 @@ var addAvcProfileToTrack = (track, avc1Profile) => {
   }
   return {
     ...track,
-    codec: `avc1.${avc1Profile.sps.profile.toString(16).padStart(2, "0")}${avc1Profile.sps.compatibility.toString(16).padStart(2, "0")}${avc1Profile.sps.level.toString(16).padStart(2, "0")}`,
-    codecPrivate: combineUint8Arrays([
-      new Uint8Array([
-        1,
-        avc1Profile.sps.level,
-        avc1Profile.sps.compatibility,
-        avc1Profile.sps.profile,
-        255,
-        225
-      ]),
-      serializeUint16(avc1Profile.sps.sps.length),
-      avc1Profile.sps.sps,
-      new Uint8Array([1]),
-      serializeUint16(avc1Profile.pps.pps.length),
-      avc1Profile.pps.pps
-    ])
+    codec: getCodecStringFromSpsAndPps(avc1Profile.sps),
+    codecPrivate: getAvccBoxContent(avc1Profile)
   };
 };
 
@@ -5229,6 +5280,57 @@ var hasAllTracksFromAvi = (structure, state) => {
   }
 };
 
+// src/boxes/transport-stream/traversal.ts
+var findProgramAssociationTableOrThrow = (structure) => {
+  const box = structure.boxes.find((b) => b.type === "transport-stream-pat-box");
+  if (!box) {
+    throw new Error("No PAT box found");
+  }
+  return box;
+};
+var findProgramMapTableOrThrow = (structure) => {
+  const box = structure.boxes.find((b) => b.type === "transport-stream-pmt-box");
+  if (!box) {
+    throw new Error("No PMT box found");
+  }
+  return box;
+};
+var getProgramForId = (structure, packetIdentifier) => {
+  const box = findProgramAssociationTableOrThrow(structure);
+  const entry = box.pat.find((e) => e.programMapIdentifier === packetIdentifier);
+  return entry ?? null;
+};
+var getStreamForId = (structure, packetIdentifier) => {
+  const box = findProgramMapTableOrThrow(structure);
+  const entry = box.streams.find((e) => e.pid === packetIdentifier);
+  return entry ?? null;
+};
+
+// src/boxes/transport-stream/get-tracks.ts
+var getTracksFromTransportStream = (structure, parserState) => {
+  const programMapTable = findProgramMapTableOrThrow(structure);
+  const parserTracks = parserState.tracks.getTracks();
+  const mapped = programMapTable.streams.map((stream) => {
+    return parserTracks.find((track) => track.trackId === stream.pid);
+  }).filter(truthy);
+  if (mapped.length !== programMapTable.streams.length) {
+    throw new Error("Not all tracks found");
+  }
+  return {
+    videoTracks: mapped.filter((track) => track.type === "video"),
+    audioTracks: mapped.filter((track) => track.type === "audio"),
+    otherTracks: []
+  };
+};
+var hasAllTracksFromTransportStream = (structure, parserState) => {
+  try {
+    getTracksFromTransportStream(structure, parserState);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
 // src/make-hvc1-codec-strings.ts
 var getHvc1CodecString = (data) => {
   const configurationVersion = data.getUint8();
@@ -5629,7 +5731,10 @@ var hasTracks = (structure, state) => {
   if (structure.type === "riff") {
     return hasAllTracksFromAvi(structure, state);
   }
-  throw new Error("Unknown container");
+  if (structure.type === "transport-stream") {
+    return hasAllTracksFromTransportStream(structure, state);
+  }
+  throw new Error("Unknown container " + structure);
 };
 var getTracksFromMa = (segments, state) => {
   const videoTracks = [];
@@ -5697,7 +5802,10 @@ var getTracks = (segments, state) => {
   if (segments.type === "riff") {
     return getTracksFromAvi(segments, state);
   }
-  throw new Error("Unknown container");
+  if (segments.type === "transport-stream") {
+    return getTracksFromTransportStream(segments, state);
+  }
+  throw new Error(`Unknown container${segments}`);
 };
 
 // src/get-container.ts
@@ -5708,6 +5816,9 @@ var getContainer = (segments) => {
   if (segments.type === "matroska") {
     return "webm";
   }
+  if (segments.type === "transport-stream") {
+    return "transport-stream";
+  }
   if (segments.type === "riff") {
     if (isRiffAvi(segments)) {
       return "avi";
@@ -6036,7 +6147,10 @@ var getDuration = (structure, parserState) => {
   if (structure.type === "riff") {
     return getDurationFromAvi(structure);
   }
-  throw new Error("Has no duration");
+  if (structure.type === "transport-stream") {
+    return null;
+  }
+  throw new Error("Has no duration " + structure);
 };
 var hasDuration = (structure, parserState) => {
   return hasTracks(structure, parserState);
@@ -6124,7 +6238,7 @@ var emitAvailableInfo = ({
     }
     if (key === "videoCodec") {
       if (returnValue.videoCodec === undefined && hasInfo.videoCodec && parseResult) {
-        const videoCodec = getVideoCodec(parseResult.segments);
+        const videoCodec = getVideoCodec(parseResult.segments, state);
         moreFields.onVideoCodec?.(videoCodec);
         returnValue.videoCodec = videoCodec;
       }
@@ -6260,29 +6374,35 @@ var hasAllInfo = ({
 
 // src/register-track.ts
 var registerTrack = async ({
-  state,
   options,
-  track
+  track,
+  container
 }) => {
-  if (track.type === "video" && options.onVideoTrack) {
-    const callback = await options.onVideoTrack(track);
-    await state.registerVideoSampleCallback(track.trackId, callback ?? null);
+  if (track.type === "video") {
+    options.parserState.tracks.addTrack(track);
+    if (options.onVideoTrack) {
+      const callback = await options.onVideoTrack({ track, container });
+      await options.parserState.registerVideoSampleCallback(track.trackId, callback ?? null);
+    }
   }
-  if (track.type === "audio" && options.onAudioTrack) {
-    const callback = await options.onAudioTrack(track);
-    await state.registerAudioSampleCallback(track.trackId, callback ?? null);
+  if (track.type === "audio") {
+    options.parserState.tracks.addTrack(track);
+    if (options.onAudioTrack) {
+      const callback = await options.onAudioTrack({ track, container });
+      await options.parserState.registerAudioSampleCallback(track.trackId, callback ?? null);
+    }
   }
 };
 var registerVideoTrackWhenProfileIsAvailable = ({
   options,
-  state,
-  track
+  track,
+  container
 }) => {
-  state.registerOnAvcProfileCallback(async (profile) => {
+  options.parserState.registerOnAvcProfileCallback(async (profile) => {
     await registerTrack({
       options,
-      state,
-      track: addAvcProfileToTrack(track, profile)
+      track: addAvcProfileToTrack(track, profile),
+      container
     });
   });
 };
@@ -6445,6 +6565,20 @@ var parseFtyp = ({
   };
 };
 
+// src/convert-audio-or-video-sample.ts
+var convertAudioOrVideoSampleToWebCodecsTimestamps = (sample, timescale2) => {
+  const { cts, dts, timestamp } = sample;
+  return {
+    cts: cts * 1e6 / timescale2,
+    dts: dts * 1e6 / timescale2,
+    timestamp: timestamp * 1e6 / timescale2,
+    duration: (sample.duration ?? 0) * 1e6 / timescale2,
+    data: sample.data,
+    trackId: sample.trackId,
+    type: sample.type
+  };
+};
+
 // src/boxes/iso-base-media/mdat/mdat.ts
 var parseMdat = async ({
   data,
@@ -6518,31 +6652,28 @@ var parseMdat = async ({
       break;
     }
     const bytes = data.getSlice(samplesWithIndex.samplePosition.size);
-    const timestamp = samplesWithIndex.samplePosition.cts * 1e6 / samplesWithIndex.track.timescale;
-    const duration2 = samplesWithIndex.samplePosition.duration * 1e6 / samplesWithIndex.track.timescale;
-    const cts = samplesWithIndex.samplePosition.cts * 1e6 / samplesWithIndex.track.timescale;
-    const dts = samplesWithIndex.samplePosition.dts * 1e6 / samplesWithIndex.track.timescale;
+    const { cts, dts, duration: duration2 } = samplesWithIndex.samplePosition;
     if (samplesWithIndex.track.type === "audio") {
-      await options.parserState.onAudioSample(samplesWithIndex.track.trackId, {
+      await options.parserState.onAudioSample(samplesWithIndex.track.trackId, convertAudioOrVideoSampleToWebCodecsTimestamps({
         data: bytes,
-        timestamp,
+        timestamp: cts,
         duration: duration2,
         cts,
         dts,
         trackId: samplesWithIndex.track.trackId,
         type: samplesWithIndex.samplePosition.isKeyframe ? "key" : "delta"
-      });
+      }, samplesWithIndex.track.timescale));
     }
     if (samplesWithIndex.track.type === "video") {
-      await options.parserState.onVideoSample(samplesWithIndex.track.trackId, {
+      await options.parserState.onVideoSample(samplesWithIndex.track.trackId, convertAudioOrVideoSampleToWebCodecsTimestamps({
         data: bytes,
-        timestamp,
+        timestamp: cts,
         duration: duration2,
         cts,
         dts,
         trackId: samplesWithIndex.track.trackId,
         type: samplesWithIndex.samplePosition.isKeyframe ? "key" : "delta"
-      });
+      }, samplesWithIndex.track.timescale));
     }
     const remaining = size - (data.counter.getOffset() - fileOffset);
     data.removeBytesRead();
@@ -8230,8 +8361,8 @@ var processBox = async ({
     if (transformedTrack) {
       await registerTrack({
         options,
-        state: options.parserState,
-        track: transformedTrack
+        track: transformedTrack,
+        container: "mp4"
       });
     }
     return {
@@ -8554,15 +8685,164 @@ var isMoviAtom = (iterator, ckId) => {
   return listType === "movi";
 };
 
+// src/boxes/avc/key.ts
+var getKeyFrameOrDeltaFromAvcInfo = (infos) => {
+  const keyOrDelta = infos.find((i) => i.type === "keyframe" || i.type === "delta-frame");
+  if (!keyOrDelta) {
+    throw new Error("expected avc to contain info about key or delta");
+  }
+  return keyOrDelta.type === "keyframe" ? "key" : "delta";
+};
+
 // src/boxes/avc/parse-avc.ts
+var Extended_SAR = 255;
+var readVuiParameters = (iterator) => {
+  let sar_width = null;
+  let sar_height = null;
+  let overscan_appropriate_flag = null;
+  let video_format = null;
+  let video_full_range_flag = null;
+  let colour_primaries = null;
+  let transfer_characteristics = null;
+  let matrix_coefficients = null;
+  let chroma_sample_loc_type_top_field = null;
+  let chroma_sample_loc_type_bottom_field = null;
+  const aspect_ratio_info_present_flag = iterator.getBits(1);
+  if (aspect_ratio_info_present_flag) {
+    const aspect_ratio_idc = iterator.getBits(8);
+    if (aspect_ratio_idc === Extended_SAR) {
+      sar_width = iterator.getBits(16);
+      sar_height = iterator.getBits(16);
+    }
+  }
+  const overscan_info_present_flag = iterator.getBits(1);
+  if (overscan_info_present_flag) {
+    overscan_appropriate_flag = iterator.getBits(1);
+  }
+  const video_signal_type_present_flag = iterator.getBits(1);
+  if (video_signal_type_present_flag) {
+    video_format = iterator.getBits(3);
+    video_full_range_flag = Boolean(iterator.getBits(1));
+    const colour_description_present_flag = iterator.getBits(1);
+    if (colour_description_present_flag) {
+      colour_primaries = iterator.getBits(8);
+      transfer_characteristics = iterator.getBits(8);
+      matrix_coefficients = iterator.getBits(8);
+    }
+  }
+  const chroma_loc_info_present_flag = iterator.getBits(1);
+  if (chroma_loc_info_present_flag) {
+    chroma_sample_loc_type_top_field = iterator.readExpGolomb();
+    chroma_sample_loc_type_bottom_field = iterator.readExpGolomb();
+  }
+  return {
+    sar_width,
+    sar_height,
+    overscan_appropriate_flag,
+    chroma_sample_loc_type_bottom_field,
+    chroma_sample_loc_type_top_field,
+    colour_primaries,
+    matrix_coefficients,
+    transfer_characteristics,
+    video_format,
+    video_full_range_flag
+  };
+};
 var readSps = (iterator) => {
   const profile = iterator.getUint8();
   const compatibility = iterator.getUint8();
   const level = iterator.getUint8();
+  iterator.startReadingBits();
+  const seq_parameter_set_id = iterator.readExpGolomb();
+  let separate_colour_plane_flag = null;
+  let bit_depth_luma_minus8 = null;
+  let bit_depth_chroma_minus8 = null;
+  let qpprime_y_zero_transform_bypass_flag = null;
+  let log2_max_frame_num_minus4 = null;
+  let log2_max_pic_order_cnt_lsb_minus4 = null;
+  let max_num_ref_frames = null;
+  let gaps_in_frame_num_value_allowed_flag = null;
+  let mb_adaptive_frame_field_flag = null;
+  let direct_8x8_inference_flag = null;
+  let frame_crop_left_offset = null;
+  let frame_crop_right_offset = null;
+  let frame_crop_top_offset = null;
+  let frame_crop_bottom_offset = null;
+  let vui_parameters = null;
+  if (!(profile === 100 || profile === 110 || profile === 122 || profile === 244 || profile === 44 || profile === 83 || profile === 86 || profile === 118 || profile === 128 || profile === 138 || profile === 139 || profile === 134 || profile === 135)) {
+    throw new Error("Invalid profile");
+  }
+  const chromaFormat = iterator.readExpGolomb();
+  if (chromaFormat === 3) {
+    separate_colour_plane_flag = iterator.getBits(1);
+  }
+  bit_depth_luma_minus8 = iterator.readExpGolomb();
+  bit_depth_chroma_minus8 = iterator.readExpGolomb();
+  qpprime_y_zero_transform_bypass_flag = iterator.getBits(1);
+  const seq_scaling_matrix_present_flag = iterator.getBits(1);
+  const seq_scaling_list_present_flag = [];
+  if (seq_scaling_matrix_present_flag) {
+    for (let i = 0;i < (chromaFormat !== 3 ? 8 : 12); i++) {
+      seq_scaling_list_present_flag[i] = iterator.getBits(1);
+      if (seq_scaling_list_present_flag[i]) {
+        if (i < 6) {
+          throw new Error("Not implemented");
+        } else {
+          throw new Error("Not implemented");
+        }
+      }
+    }
+  }
+  log2_max_frame_num_minus4 = iterator.readExpGolomb();
+  const pic_order_cnt_type = iterator.readExpGolomb();
+  if (pic_order_cnt_type === 0) {
+    log2_max_pic_order_cnt_lsb_minus4 = iterator.readExpGolomb();
+  } else if (pic_order_cnt_type === 1) {
+    throw new Error("pic_order_cnt_type = 1 not implemented");
+  }
+  max_num_ref_frames = iterator.readExpGolomb();
+  gaps_in_frame_num_value_allowed_flag = iterator.getBits(1);
+  const pic_width_in_mbs_minus1 = iterator.readExpGolomb();
+  const pic_height_in_map_units_minus1 = iterator.readExpGolomb();
+  const frame_mbs_only_flag = iterator.getBits(1);
+  if (!frame_mbs_only_flag) {
+    mb_adaptive_frame_field_flag = iterator.getBits(1);
+  }
+  direct_8x8_inference_flag = iterator.getBits(1);
+  const frame_cropping_flag = iterator.getBits(1);
+  if (frame_cropping_flag) {
+    frame_crop_left_offset = iterator.readExpGolomb();
+    frame_crop_right_offset = iterator.readExpGolomb();
+    frame_crop_top_offset = iterator.readExpGolomb();
+    frame_crop_bottom_offset = iterator.readExpGolomb();
+  }
+  const vui_parameters_present_flag = iterator.getBits(1);
+  if (vui_parameters_present_flag) {
+    vui_parameters = readVuiParameters(iterator);
+  }
+  iterator.stopReadingBits();
   return {
     profile,
     compatibility,
-    level
+    level,
+    bit_depth_chroma_minus8,
+    bit_depth_luma_minus8,
+    gaps_in_frame_num_value_allowed_flag,
+    log2_max_frame_num_minus4,
+    log2_max_pic_order_cnt_lsb_minus4,
+    max_num_ref_frames,
+    pic_height_in_map_units_minus1,
+    pic_width_in_mbs_minus1,
+    qpprime_y_zero_transform_bypass_flag,
+    separate_colour_plane_flag,
+    seq_parameter_set_id,
+    direct_8x8_inference_flag,
+    frame_crop_bottom_offset,
+    frame_crop_left_offset,
+    frame_crop_right_offset,
+    frame_crop_top_offset,
+    mb_adaptive_frame_field_flag,
+    vui_parameters
   };
 };
 var findEnd = (buffer) => {
@@ -8590,11 +8870,9 @@ var inspect = (buffer) => {
   if (type === 7) {
     const end = findEnd(buffer);
     const data = readSps(iterator);
-    const sps = buffer.slice(1, end === null ? Infinity : end);
+    const sps = buffer.slice(0, end === null ? Infinity : end);
     return {
-      level: data.level,
-      profile: data.profile,
-      compatibility: data.compatibility,
+      spsData: data,
       sps,
       type: "avc-profile"
     };
@@ -8673,29 +8951,26 @@ var handleChunk = async ({
     const samplesPerSecond = strh.rate / strh.scale;
     const nthSample = options.parserState.getSamplesForTrack(trackId);
     const timeInSec = nthSample / samplesPerSecond;
-    const timestamp = Math.floor(timeInSec * MEDIA_PARSER_RIFF_TIMESCALE);
-    const duration2 = Math.floor(1 / samplesPerSecond * MEDIA_PARSER_RIFF_TIMESCALE);
+    const timestamp = Math.floor(timeInSec);
+    const duration2 = Math.floor(1 / samplesPerSecond);
     const data = iterator.getSlice(ckSize);
     const infos = parseAvc(data);
-    const keyOrDelta = infos.find((i) => i.type === "keyframe" || i.type === "delta-frame");
-    if (!keyOrDelta) {
-      throw new Error("expected avc to contain info about key or delta");
-    }
+    const keyOrDelta = getKeyFrameOrDeltaFromAvcInfo(infos);
     const avcProfile = infos.find((i) => i.type === "avc-profile");
     const ppsProfile = infos.find((i) => i.type === "avc-pps");
     if (avcProfile && ppsProfile) {
       await options.parserState.onProfile({ pps: ppsProfile, sps: avcProfile });
       options.parserState.tracks.setIsDone();
     }
-    await options.parserState.onVideoSample(trackId, {
+    await options.parserState.onVideoSample(trackId, convertAudioOrVideoSampleToWebCodecsTimestamps({
       cts: timestamp,
       dts: timestamp,
       data,
       duration: duration2,
       timestamp,
       trackId,
-      type: keyOrDelta.type === "keyframe" ? "key" : "delta"
-    });
+      type: keyOrDelta
+    }, 1));
     return;
   }
   const audioChunk = ckId.match(/^([0-9]{2})wb$/);
@@ -8705,9 +8980,9 @@ var handleChunk = async ({
     const samplesPerSecond = strh.rate / strh.scale;
     const nthSample = options.parserState.getSamplesForTrack(trackId);
     const timeInSec = nthSample / samplesPerSecond;
-    const timestamp = timeInSec * MEDIA_PARSER_RIFF_TIMESCALE;
-    const duration2 = 1 / samplesPerSecond * MEDIA_PARSER_RIFF_TIMESCALE;
-    await options.parserState.onAudioSample(trackId, {
+    const timestamp = timeInSec;
+    const duration2 = 1 / samplesPerSecond;
+    await options.parserState.onAudioSample(trackId, convertAudioOrVideoSampleToWebCodecsTimestamps({
       cts: timestamp,
       dts: timestamp,
       data: iterator.getSlice(ckSize),
@@ -8715,7 +8990,7 @@ var handleChunk = async ({
       timestamp,
       trackId,
       type: "key"
-    });
+    }, 1));
   }
 };
 var parseMovi = async ({
@@ -9201,8 +9476,8 @@ var parseRiffBody = async ({
         });
         await registerTrack({
           options,
-          state: options.parserState,
-          track: audioTrack
+          track: audioTrack,
+          container: "avi"
         });
       }
       if (options.onVideoTrack && strf.type === "strf-box-video") {
@@ -9213,8 +9488,8 @@ var parseRiffBody = async ({
         });
         registerVideoTrackWhenProfileIsAvailable({
           options,
-          state: options.parserState,
-          track: videoTrack
+          track: videoTrack,
+          container: "avi"
         });
       }
       options.nextTrackIndex++;
@@ -9250,15 +9525,758 @@ var parseRiff = ({
   return parseRiffBody({ iterator, structure, maxOffset: Infinity, options });
 };
 
-// src/boxes/webm/segments/block-simple-block-flags.ts
-var parseBlockFlags = (iterator, type) => {
-  if (type === matroskaElements.Block) {
-    iterator.startReadingBits();
-    iterator.getBits(4);
-    const invisible = Boolean(iterator.getBits(1));
-    const lacing = iterator.getBits(2);
-    iterator.getBits(1);
-    iterator.stopReadingBits();
+// src/boxes/transport-stream/next-pes-header-store.ts
+var makeNextPesHeaderStore = () => {
+  let nextPesHeader = null;
+  return {
+    setNextPesHeader: (pesHeader) => {
+      nextPesHeader = pesHeader;
+    },
+    getNextPesHeader: () => {
+      if (!nextPesHeader) {
+        throw new Error("No next PES header found");
+      }
+      return nextPesHeader;
+    }
+  };
+};
+
+// src/boxes/transport-stream/discard-rest-of-packet.ts
+var discardRestOfPacket = (iterator) => {
+  const next188 = 188 - iterator.counter.getOffset() % 188;
+  iterator.discard(next188);
+};
+var getRestOfPacket = (iterator) => {
+  const next188 = 188 - iterator.counter.getOffset() % 188;
+  return iterator.getSlice(next188);
+};
+
+// src/boxes/transport-stream/parse-pat.ts
+var parsePatTable = (iterator, tableId) => {
+  iterator.getUint16();
+  iterator.startReadingBits();
+  iterator.getBits(7);
+  iterator.getBits(1);
+  const sectionNumber = iterator.getBits(8);
+  const lastSectionNumber = iterator.getBits(8);
+  if (tableId !== 0) {
+    throw new Error("Invalid table ID: " + tableId);
+  }
+  const tables = [];
+  for (let i = sectionNumber;i <= lastSectionNumber; i++) {
+    const programNumber = iterator.getBits(16);
+    iterator.getBits(3);
+    const programMapIdentifier = iterator.getBits(13);
+    tables.push({
+      type: "transport-stream-program-association-table",
+      programNumber,
+      programMapIdentifier
+    });
+  }
+  iterator.stopReadingBits();
+  return {
+    type: "transport-stream-pat-box",
+    tableId: tableId.toString(16),
+    pat: tables
+  };
+};
+var parsePat = (iterator) => {
+  iterator.startReadingBits();
+  const tableId = iterator.getBits(8);
+  iterator.getBits(1);
+  iterator.getBits(1);
+  iterator.getBits(4);
+  const sectionLength = iterator.getBits(10);
+  if (sectionLength > 1021) {
+    throw new Error("Invalid section length");
+  }
+  iterator.stopReadingBits();
+  const tables = parsePatTable(iterator, tableId);
+  discardRestOfPacket(iterator);
+  return tables;
+};
+
+// src/boxes/transport-stream/parse-pes.ts
+var parsePes = (iterator) => {
+  const ident = iterator.getUint24();
+  if (ident !== 1) {
+    throw new Error(`Unexpected PES packet start code: ${ident.toString(16)}`);
+  }
+  const streamId = iterator.getUint8();
+  iterator.getUint16();
+  iterator.startReadingBits();
+  const markerBits = iterator.getBits(2);
+  if (markerBits !== 2) {
+    throw new Error(`Invalid marker bits: ${markerBits}`);
+  }
+  const scrambled = iterator.getBits(2);
+  if (scrambled !== 0) {
+    throw new Error(`Only supporting non-scrambled streams`);
+  }
+  const priority = iterator.getBits(1);
+  iterator.getBits(1);
+  iterator.getBits(1);
+  iterator.getBits(1);
+  const ptsPresent = iterator.getBits(1);
+  const dtsPresent = iterator.getBits(1);
+  if (!ptsPresent && dtsPresent) {
+    throw new Error(`DTS is present but not PTS, this is not allowed in the spec`);
+  }
+  iterator.getBits(1);
+  iterator.getBits(1);
+  iterator.getBits(1);
+  iterator.getBits(1);
+  iterator.getBits(1);
+  iterator.getBits(1);
+  const pesHeaderLength = iterator.getBits(8);
+  const offset = iterator.counter.getOffset();
+  let pts = null;
+  if (!ptsPresent) {
+    throw new Error(`PTS is required`);
+  }
+  const fourBits = iterator.getBits(4);
+  if (fourBits !== 3 && fourBits !== 2) {
+    throw new Error(`Invalid PTS marker bits: ${fourBits}`);
+  }
+  const pts1 = iterator.getBits(3);
+  iterator.getBits(1);
+  const pts2 = iterator.getBits(15);
+  iterator.getBits(1);
+  const pts3 = iterator.getBits(15);
+  iterator.getBits(1);
+  pts = pts1 << 30 | pts2 << 15 | pts3;
+  let dts = null;
+  if (dtsPresent) {
+    const _fourBits = iterator.getBits(4);
+    if (_fourBits !== 1) {
+      throw new Error(`Invalid DTS marker bits: ${_fourBits}`);
+    }
+    const dts1 = iterator.getBits(3);
+    iterator.getBits(1);
+    const dts2 = iterator.getBits(15);
+    iterator.getBits(1);
+    const dts3 = iterator.getBits(15);
+    iterator.getBits(1);
+    dts = dts1 << 30 | dts2 << 15 | dts3;
+  }
+  iterator.stopReadingBits();
+  iterator.discard(pesHeaderLength - (iterator.counter.getOffset() - offset));
+  const packet = {
+    dts,
+    pts,
+    streamId,
+    priority
+  };
+  return packet;
+};
+
+// src/boxes/transport-stream/parse-pmt.ts
+var parsePmtTable = ({
+  iterator,
+  tableId,
+  sectionLength
+}) => {
+  const start = iterator.counter.getOffset();
+  iterator.getUint16();
+  iterator.startReadingBits();
+  iterator.getBits(7);
+  iterator.getBits(1);
+  const sectionNumber = iterator.getBits(8);
+  const lastSectionNumber = iterator.getBits(8);
+  const tables = [];
+  for (let i = sectionNumber;i <= lastSectionNumber; i++) {
+    iterator.getBits(3);
+    iterator.getBits(13);
+    iterator.getBits(4);
+    const programInfoLength = iterator.getBits(12);
+    const streams = [];
+    while (true) {
+      const streamType = iterator.getBits(8);
+      iterator.getBits(3);
+      const elementaryPid = iterator.getBits(13);
+      iterator.getBits(4);
+      const esInfoLength = iterator.getBits(12);
+      iterator.getBits(esInfoLength * 8);
+      streams.push({ streamType, pid: elementaryPid });
+      iterator.getBits(programInfoLength * 8);
+      const remaining = sectionLength - (iterator.counter.getOffset() - start);
+      if (remaining <= 4) {
+        break;
+      }
+    }
+    tables.push({
+      type: "transport-stream-program-map-table",
+      streams
+    });
+  }
+  if (tables.length !== 1) {
+    throw new Error("Does not PMT table with more than 1 entry, uncommon");
+  }
+  iterator.stopReadingBits();
+  return {
+    type: "transport-stream-pmt-box",
+    tableId,
+    streams: tables[0].streams
+  };
+};
+var parsePmt = (iterator) => {
+  iterator.startReadingBits();
+  const tableId = iterator.getBits(8);
+  iterator.getBits(1);
+  iterator.getBits(1);
+  iterator.getBits(4);
+  const sectionLength = iterator.getBits(10);
+  if (sectionLength > 1021) {
+    throw new Error("Invalid section length");
+  }
+  iterator.stopReadingBits();
+  const tables = parsePmtTable({ iterator, tableId, sectionLength });
+  discardRestOfPacket(iterator);
+  return tables;
+};
+
+// src/boxes/transport-stream/adts-header.ts
+var readAdtsHeader = (buffer) => {
+  if (buffer.byteLength < 9) {
+    return null;
+  }
+  const iterator = getArrayBufferIterator(buffer, buffer.byteLength);
+  iterator.startReadingBits();
+  const bits = iterator.getBits(12);
+  if (bits !== 4095) {
+    throw new Error("Invalid ADTS header ");
+  }
+  const id = iterator.getBits(1);
+  if (id !== 0) {
+    throw new Error("Only supporting MPEG-4 for .ts");
+  }
+  const layer = iterator.getBits(2);
+  if (layer !== 0) {
+    throw new Error("Only supporting layer 0 for .ts");
+  }
+  const protectionAbsent = iterator.getBits(1);
+  const audioObjectType = iterator.getBits(2);
+  const samplingFrequencyIndex = iterator.getBits(4);
+  const sampleRate = getSampleRateFromSampleFrequencyIndex(samplingFrequencyIndex);
+  iterator.getBits(1);
+  const channelConfiguration = iterator.getBits(3);
+  const codecPrivate2 = createAacCodecPrivate({
+    audioObjectType,
+    sampleRate,
+    channelConfiguration
+  });
+  iterator.getBits(1);
+  iterator.getBits(1);
+  iterator.getBits(1);
+  iterator.getBits(1);
+  const frameLength = iterator.getBits(13);
+  iterator.getBits(11);
+  iterator.getBits(2);
+  if (!protectionAbsent) {
+    iterator.getBits(16);
+  }
+  iterator.stopReadingBits();
+  iterator.destroy();
+  return {
+    frameLength,
+    codecPrivate: codecPrivate2,
+    channelConfiguration,
+    sampleRate,
+    audioObjectType
+  };
+};
+
+// src/boxes/transport-stream/find-separator.ts
+function findSubarrayIndex(array, subarray) {
+  const subarrayLength = subarray.length;
+  const arrayLength = array.length;
+  for (let i = 0;i <= arrayLength - subarrayLength; i++) {
+    let match = true;
+    for (let j = 0;j < subarrayLength; j++) {
+      if (array[i + j] !== subarray[j]) {
+        match = false;
+        break;
+      }
+    }
+    if (match) {
+      if (subarray[i - 1] === 0) {
+        i--;
+      }
+      return i;
+    }
+  }
+  return -1;
+}
+var findNextSeparator = (restOfPacket, transportStreamEntry) => {
+  if (transportStreamEntry.streamType === 27) {
+    return findSubarrayIndex(restOfPacket, new Uint8Array([0, 0, 1, 9]));
+  }
+  throw new Error(`Unsupported stream ID ${transportStreamEntry.streamType}`);
+};
+
+// src/boxes/avc/interpret-sps.ts
+var getDimensionsFromSps = (sps) => {
+  const height = sps.pic_height_in_map_units_minus1;
+  const width = sps.pic_width_in_mbs_minus1;
+  return {
+    height: (height + 1) * 16,
+    width: (width + 1) * 16
+  };
+};
+var getSampleAspectRatioFromSps = (sps) => {
+  if (sps.vui_parameters?.sar_height && sps.vui_parameters.sar_width) {
+    return {
+      width: sps.vui_parameters.sar_width,
+      height: sps.vui_parameters.sar_height
+    };
+  }
+  return {
+    width: 1,
+    height: 1
+  };
+};
+var getVideoColorFromSps = (sps) => {
+  const matrixCoefficients2 = sps.vui_parameters?.matrix_coefficients;
+  const transferCharacteristics2 = sps.vui_parameters?.transfer_characteristics;
+  const colorPrimaries = sps.vui_parameters?.colour_primaries;
+  return {
+    matrixCoefficients: matrixCoefficients2 ? getMatrixCoefficientsFromIndex(matrixCoefficients2) : null,
+    transferCharacteristics: transferCharacteristics2 ? getTransferCharacteristicsFromIndex(transferCharacteristics2) : null,
+    primaries: colorPrimaries ? getPrimariesFromIndex(colorPrimaries) : null,
+    fullRange: sps.vui_parameters?.video_full_range_flag ?? null
+  };
+};
+
+// src/boxes/avc/sps-and-pps.ts
+var getSpsAndPps = (infos) => {
+  const avcProfile = infos.find((i) => i.type === "avc-profile");
+  const ppsProfile = infos.find((i) => i.type === "avc-pps");
+  if (!avcProfile || !ppsProfile) {
+    throw new Error("Expected avcProfile and ppsProfile");
+  }
+  return { pps: ppsProfile, sps: avcProfile };
+};
+
+// src/boxes/transport-stream/handle-avc-packet.ts
+var MPEG_TIMESCALE = 90000;
+var handleAvcPacket = async ({
+  streamBuffer,
+  programId,
+  options
+}) => {
+  const avc = parseAvc(streamBuffer.buffer);
+  const isTrackRegistered = options.parserState.tracks.getTracks().find((t) => {
+    return t.trackId === programId;
+  });
+  if (!isTrackRegistered) {
+    const spsAndPps = getSpsAndPps(avc);
+    const dimensions = getDimensionsFromSps(spsAndPps.sps.spsData);
+    const sampleAspectRatio = getSampleAspectRatioFromSps(spsAndPps.sps.spsData);
+    const track = {
+      rotation: 0,
+      trackId: programId,
+      type: "video",
+      timescale: MPEG_TIMESCALE,
+      codec: getCodecStringFromSpsAndPps(spsAndPps.sps),
+      codecPrivate: getAvccBoxContent(spsAndPps),
+      fps: null,
+      codedWidth: dimensions.width,
+      codedHeight: dimensions.height,
+      height: dimensions.height,
+      width: dimensions.width,
+      displayAspectWidth: dimensions.width,
+      displayAspectHeight: dimensions.height,
+      trakBox: null,
+      codecWithoutConfig: "h264",
+      description: undefined,
+      sampleAspectRatio: {
+        denominator: sampleAspectRatio.height,
+        numerator: sampleAspectRatio.width
+      },
+      color: getVideoColorFromSps(spsAndPps.sps.spsData)
+    };
+    await registerTrack({ track, options, container: "transport-stream" });
+  }
+  const sample = {
+    cts: streamBuffer.pesHeader.pts,
+    dts: streamBuffer.pesHeader.dts ?? streamBuffer.pesHeader.pts,
+    timestamp: streamBuffer.pesHeader.pts,
+    duration: undefined,
+    data: new Uint8Array(streamBuffer.buffer),
+    trackId: programId,
+    type: getKeyFrameOrDeltaFromAvcInfo(avc)
+  };
+  await options.parserState.onVideoSample(programId, convertAudioOrVideoSampleToWebCodecsTimestamps(sample, MPEG_TIMESCALE));
+};
+
+// src/boxes/transport-stream/handle-aac-packet.ts
+var handleAacPacket = async ({
+  streamBuffer,
+  options,
+  programId
+}) => {
+  const adtsHeader = readAdtsHeader(streamBuffer.buffer);
+  if (!adtsHeader) {
+    throw new Error("Invalid ADTS header - too short");
+  }
+  const { channelConfiguration, codecPrivate: codecPrivate2, sampleRate, audioObjectType } = adtsHeader;
+  const isTrackRegistered = options.parserState.tracks.getTracks().find((t) => {
+    return t.trackId === programId;
+  });
+  if (!isTrackRegistered) {
+    const track = {
+      type: "audio",
+      codecPrivate: codecPrivate2,
+      trackId: programId,
+      trakBox: null,
+      timescale: MPEG_TIMESCALE,
+      codecWithoutConfig: "aac",
+      codec: mapAudioObjectTypeToCodecString(audioObjectType),
+      description: undefined,
+      numberOfChannels: channelConfiguration,
+      sampleRate
+    };
+    await registerTrack({
+      track,
+      options,
+      container: "transport-stream"
+    });
+  }
+  const sample = {
+    cts: streamBuffer.pesHeader.pts,
+    dts: streamBuffer.pesHeader.dts ?? streamBuffer.pesHeader.pts,
+    timestamp: streamBuffer.pesHeader.pts,
+    duration: undefined,
+    data: new Uint8Array(streamBuffer.buffer),
+    trackId: programId,
+    type: "key"
+  };
+  await options.parserState.onAudioSample(programId, convertAudioOrVideoSampleToWebCodecsTimestamps(sample, MPEG_TIMESCALE));
+};
+
+// src/boxes/transport-stream/process-stream-buffers.ts
+var processStreamBuffer = async ({
+  streamBuffer,
+  options,
+  programId,
+  structure
+}) => {
+  const stream = getStreamForId(structure, programId);
+  if (!stream) {
+    throw new Error("No stream found");
+  }
+  if (stream.streamType === 27) {
+    await handleAvcPacket({ programId, streamBuffer, options });
+  } else if (stream.streamType === 15) {
+    await handleAacPacket({ streamBuffer, options, programId });
+  }
+  if (!options.parserState.tracks.hasAllTracks()) {
+    const tracksRegistered = options.parserState.tracks.getTracks().length;
+    const { streams } = findProgramMapTableOrThrow(structure);
+    if (streams.length === tracksRegistered) {
+      options.parserState.tracks.setIsDone();
+    }
+  }
+};
+var processFinalStreamBuffers = async ({
+  streamBufferMap,
+  parserContext,
+  structure
+}) => {
+  for (const [programId, buffer] of streamBufferMap) {
+    if (buffer.buffer.byteLength > 0) {
+      await processStreamBuffer({
+        streamBuffer: buffer,
+        options: parserContext,
+        programId,
+        structure
+      });
+      streamBufferMap.delete(programId);
+    }
+  }
+};
+
+// src/boxes/transport-stream/parse-stream-packet.ts
+var parseAdtsStream = async ({
+  restOfPacket,
+  transportStreamEntry,
+  streamBuffers,
+  nextPesHeader,
+  options,
+  structure
+}) => {
+  const streamBuffer = streamBuffers.get(transportStreamEntry.pid);
+  if (!streamBuffer) {
+    streamBuffers.set(transportStreamEntry.pid, {
+      buffer: restOfPacket,
+      pesHeader: nextPesHeader
+    });
+    return;
+  }
+  const expectedLength = readAdtsHeader(streamBuffer.buffer)?.frameLength ?? null;
+  const bytesToTake = expectedLength ? Math.min(restOfPacket.length, expectedLength - streamBuffer.buffer.byteLength) : restOfPacket.length;
+  streamBuffer.buffer = combineUint8Arrays([
+    streamBuffer.buffer,
+    restOfPacket.slice(0, bytesToTake)
+  ]);
+  if (expectedLength === streamBuffer.buffer.byteLength) {
+    await processStreamBuffer({
+      streamBuffer,
+      programId: transportStreamEntry.pid,
+      options,
+      structure
+    });
+    const rest = restOfPacket.slice(bytesToTake);
+    streamBuffers.set(transportStreamEntry.pid, {
+      buffer: rest,
+      pesHeader: nextPesHeader
+    });
+  }
+};
+var parseAvcStream = async ({
+  restOfPacket,
+  transportStreamEntry,
+  streamBuffers,
+  nextPesHeader,
+  programId,
+  parserContext,
+  structure
+}) => {
+  const indexOfSeparator = findNextSeparator(restOfPacket, transportStreamEntry);
+  const streamBuffer = streamBuffers.get(transportStreamEntry.pid);
+  if (indexOfSeparator === -1) {
+    if (streamBuffer) {
+      streamBuffer.buffer = combineUint8Arrays([
+        streamBuffer.buffer,
+        restOfPacket
+      ]);
+      return;
+    }
+    streamBuffers.set(programId, {
+      pesHeader: nextPesHeader,
+      buffer: restOfPacket
+    });
+    return;
+  }
+  if (streamBuffer) {
+    const packet = restOfPacket.slice(0, indexOfSeparator);
+    streamBuffer.buffer = combineUint8Arrays([streamBuffer.buffer, packet]);
+    await processStreamBuffer({
+      options: parserContext,
+      streamBuffer,
+      programId,
+      structure
+    });
+    const rest = restOfPacket.slice(indexOfSeparator);
+    streamBuffers.set(programId, {
+      pesHeader: nextPesHeader,
+      buffer: rest
+    });
+    return;
+  }
+  if (indexOfSeparator !== 0) {
+    throw new Error("No stream buffer found but new separator is not at the beginning");
+  }
+  streamBuffers.set(programId, {
+    pesHeader: nextPesHeader,
+    buffer: restOfPacket.slice(indexOfSeparator)
+  });
+};
+var parseStream = ({
+  iterator,
+  transportStreamEntry,
+  streamBuffers,
+  parserContext,
+  programId,
+  structure,
+  nextPesHeader
+}) => {
+  const restOfPacket = getRestOfPacket(iterator);
+  if (transportStreamEntry.streamType === 27) {
+    return parseAvcStream({
+      restOfPacket,
+      transportStreamEntry,
+      streamBuffers,
+      nextPesHeader,
+      parserContext,
+      programId,
+      structure
+    });
+  }
+  if (transportStreamEntry.streamType === 15) {
+    return parseAdtsStream({
+      restOfPacket,
+      transportStreamEntry,
+      streamBuffers,
+      nextPesHeader,
+      options: parserContext,
+      structure
+    });
+  }
+  throw new Error(`Unsupported stream type ${transportStreamEntry.streamType}`);
+};
+
+// src/boxes/transport-stream/parse-packet.ts
+var parsePacket = async ({
+  iterator,
+  structure,
+  streamBuffers,
+  parserContext,
+  nextPesHeaderStore
+}) => {
+  const offset = iterator.counter.getOffset();
+  const syncByte = iterator.getUint8();
+  if (syncByte !== 71) {
+    throw new Error("Invalid sync byte");
+  }
+  iterator.startReadingBits();
+  iterator.getBits(1);
+  const payloadUnitStartIndicator = iterator.getBits(1);
+  iterator.getBits(1);
+  const programId = iterator.getBits(13);
+  iterator.getBits(2);
+  const adaptationFieldControl1 = iterator.getBits(1);
+  iterator.getBits(1);
+  iterator.getBits(4);
+  iterator.stopReadingBits();
+  if (adaptationFieldControl1 === 1) {
+    iterator.startReadingBits();
+    const adaptationFieldLength = iterator.getBits(8);
+    const headerOffset = iterator.counter.getOffset();
+    if (adaptationFieldLength > 0) {
+      iterator.getBits(1);
+      iterator.getBits(1);
+      iterator.getBits(1);
+      iterator.getBits(1);
+      iterator.getBits(1);
+      iterator.getBits(1);
+      iterator.getBits(1);
+      iterator.getBits(1);
+    }
+    const remaining = adaptationFieldLength - (iterator.counter.getOffset() - headerOffset);
+    iterator.stopReadingBits();
+    const toDiscard = Math.max(0, remaining);
+    iterator.discard(toDiscard);
+  }
+  const read = iterator.counter.getOffset() - offset;
+  if (read === 188) {
+    return Promise.resolve(null);
+  }
+  const pat = structure.boxes.find((b) => b.type === "transport-stream-pmt-box");
+  const isPes = payloadUnitStartIndicator && pat?.streams.find((e) => e.pid === programId);
+  if (isPes) {
+    const packetPes = parsePes(iterator);
+    nextPesHeaderStore.setNextPesHeader(packetPes);
+  } else if (payloadUnitStartIndicator === 1) {
+    iterator.getUint8();
+  }
+  if (programId === 0) {
+    return Promise.resolve(parsePat(iterator));
+  }
+  const program = getProgramForId(structure, programId);
+  if (program) {
+    const pmt = parsePmt(iterator);
+    return Promise.resolve(pmt);
+  }
+  const stream = getStreamForId(structure, programId);
+  if (stream) {
+    await parseStream({
+      iterator,
+      transportStreamEntry: stream,
+      streamBuffers,
+      nextPesHeader: nextPesHeaderStore.getNextPesHeader(),
+      parserContext,
+      programId,
+      structure
+    });
+    return Promise.resolve(null);
+  }
+  throw new Error("Unknown packet identifier");
+};
+
+// src/boxes/transport-stream/parse-transport-stream.ts
+var parseTransportStream = async ({
+  iterator,
+  parserContext,
+  structure,
+  streamBuffers,
+  fields,
+  nextPesHeaderStore
+}) => {
+  if (iterator.bytesRemaining() === 0) {
+    await processFinalStreamBuffers({
+      streamBufferMap: streamBuffers,
+      parserContext,
+      structure
+    });
+    return Promise.resolve({
+      status: "done",
+      segments: structure
+    });
+  }
+  while (true) {
+    if (hasAllInfo({
+      fields,
+      state: parserContext.parserState,
+      structure
+    })) {
+      break;
+    }
+    if (iterator.bytesRemaining() < 188) {
+      return Promise.resolve({
+        status: "incomplete",
+        segments: structure,
+        skipTo: null,
+        continueParsing: () => {
+          return parseTransportStream({
+            iterator,
+            parserContext,
+            structure,
+            streamBuffers,
+            fields,
+            nextPesHeaderStore
+          });
+        }
+      });
+    }
+    const packet = await parsePacket({
+      iterator,
+      structure,
+      streamBuffers,
+      parserContext,
+      nextPesHeaderStore
+    });
+    if (packet) {
+      structure.boxes.push(packet);
+      break;
+    }
+  }
+  return Promise.resolve({
+    segments: structure,
+    status: "incomplete",
+    continueParsing() {
+      return parseTransportStream({
+        iterator,
+        parserContext,
+        structure,
+        streamBuffers,
+        fields,
+        nextPesHeaderStore
+      });
+    },
+    skipTo: null
+  });
+};
+
+// src/boxes/webm/segments/block-simple-block-flags.ts
+var parseBlockFlags = (iterator, type) => {
+  if (type === matroskaElements.Block) {
+    iterator.startReadingBits();
+    iterator.getBits(4);
+    const invisible = Boolean(iterator.getBits(1));
+    const lacing = iterator.getBits(2);
+    iterator.getBits(1);
+    iterator.stopReadingBits();
     return {
       invisible,
       lacing,
@@ -9456,9 +10474,9 @@ var postprocessEbml = async ({
     });
     if (track) {
       await registerTrack({
-        state: parserContext.parserState,
         options: parserContext,
-        track
+        track,
+        container: "webm"
       });
     }
   }
@@ -9928,6 +10946,19 @@ var parseVideo = ({
     Log.verbose(logLevel, "Detected Matroska container");
     return parseWebm({ counter: iterator, parserContext: options, fields });
   }
+  if (iterator.isTransportStream()) {
+    return parseTransportStream({
+      iterator,
+      parserContext: options,
+      structure: {
+        type: "transport-stream",
+        boxes: []
+      },
+      streamBuffers: new Map,
+      fields,
+      nextPesHeaderStore: makeNextPesHeaderStore()
+    });
+  }
   if (iterator.isMp3()) {
     return Promise.reject(new Error("MP3 files are not yet supported"));
   }
@@ -9971,12 +11002,17 @@ var makeCanSkipTracksState = ({
 
 // src/state/has-tracks-section.ts
 var makeTracksSectionState = (canSkipTracksState) => {
+  const tracks2 = [];
   let doneWithTracks = false;
   return {
     hasAllTracks: () => doneWithTracks,
     setIsDone: () => {
       doneWithTracks = true;
     },
+    addTrack: (track) => {
+      tracks2.push(track);
+    },
+    getTracks: () => tracks2,
     ensureHasTracksAtEnd: () => {
       if (canSkipTracksState.canSkipTracks()) {
         return;
@@ -10199,10 +11235,10 @@ var parseMedia = async ({
   };
   triggerInfoEmit();
   while (parseResult === null || parseResult.status === "incomplete") {
-    if (signal?.aborted) {
-      throw new Error("Aborted");
-    }
     while (true) {
+      if (signal?.aborted) {
+        throw new Error("Aborted");
+      }
       const result = await currentReader.reader.read();
       if (iterator) {
         if (!result.done) {