@remotion/media-parser 4.0.229 → 4.0.231

package/dist/esm/index.mjs

@@ -1021,7 +1021,1111 @@ var combineUint8Arrays = (arrays) => {
   return result;
 };
 
-// src/create/cluster-segment.ts
+// src/log.ts
+var logLevels = ["trace", "verbose", "info", "warn", "error"];
+var getNumberForLogLevel = (level) => {
+  return logLevels.indexOf(level);
+};
+var isEqualOrBelowLogLevel = (currentLevel, level) => {
+  return getNumberForLogLevel(currentLevel) <= getNumberForLogLevel(level);
+};
+var Log = {
+  trace: (logLevel, ...args) => {
+    if (isEqualOrBelowLogLevel(logLevel, "trace")) {
+      return console.log(...args);
+    }
+  },
+  verbose: (logLevel, ...args) => {
+    if (isEqualOrBelowLogLevel(logLevel, "verbose")) {
+      return console.log(...args);
+    }
+  },
+  info: (logLevel, ...args) => {
+    if (isEqualOrBelowLogLevel(logLevel, "info")) {
+      return console.log(...args);
+    }
+  },
+  warn: (logLevel, ...args) => {
+    if (isEqualOrBelowLogLevel(logLevel, "warn")) {
+      return console.warn(...args);
+    }
+  },
+  error: (...args) => {
+    return console.error(...args);
+  }
+};
+
+// src/create/iso-base-media/primitives.ts
+var stringsToUint8Array = (str) => {
+  return new TextEncoder().encode(str);
+};
+var numberTo32BitUIntOrInt = (num) => {
+  return new Uint8Array([
+    num >> 24 & 255,
+    num >> 16 & 255,
+    num >> 8 & 255,
+    num & 255
+  ]);
+};
+var numberTo32BitUIntOrIntLeading128 = (num) => {
+  const arr = [
+    num >> 24 & 255,
+    num >> 16 & 255,
+    num >> 8 & 255,
+    num & 255
+  ];
+  for (const i in arr) {
+    if (arr[i] === 0) {
+      arr[i] = 128;
+    } else {
+      break;
+    }
+  }
+  return new Uint8Array(arr);
+};
+var numberTo16BitUIntOrInt = (num) => {
+  return new Uint8Array([num >> 8 & 255, num & 255]);
+};
+var setFixedPointSignedOrUnsigned1616Number = (num) => {
+  const val = Math.round(num * 2 ** 16);
+  return numberTo32BitUIntOrInt(val);
+};
+var setFixedPointSigned230Number = (num) => {
+  const val = Math.round(num * 2 ** 30);
+  return numberTo32BitUIntOrInt(val);
+};
+var addSize = (arr) => {
+  return combineUint8Arrays([numberTo32BitUIntOrInt(arr.length + 4), arr]);
+};
+var addLeading128Size = (arr) => {
+  return combineUint8Arrays([
+    numberTo32BitUIntOrIntLeading128(arr.length),
+    arr
+  ]);
+};
+var floatTo16Point1632Bit = (number) => {
+  const fixedNumber = Number(number.toFixed(2));
+  const result = new Uint8Array(4);
+  const tens = Math.floor(fixedNumber / 10);
+  const ones = Math.floor(fixedNumber % 10);
+  const tenths = Math.floor(fixedNumber * 10 % 10);
+  const hundredths = Math.floor(fixedNumber * 100 % 10);
+  result[0] = tens;
+  result[1] = ones;
+  result[2] = tenths;
+  result[3] = hundredths;
+  return result;
+};
+var floatTo16Point16_16Bit = (number) => {
+  const fixedNumber = Number(number.toFixed(2));
+  const result = new Uint8Array(2);
+  const ones = Math.floor(fixedNumber % 10);
+  const tenths = Math.floor(fixedNumber * 10 % 10);
+  result[0] = ones;
+  result[1] = tenths;
+  return result;
+};
+var serializeMatrix = (matrix) => {
+  return combineUint8Arrays([
+    setFixedPointSignedOrUnsigned1616Number(matrix[0]),
+    setFixedPointSignedOrUnsigned1616Number(matrix[1]),
+    setFixedPointSigned230Number(matrix[2]),
+    setFixedPointSignedOrUnsigned1616Number(matrix[3]),
+    setFixedPointSignedOrUnsigned1616Number(matrix[4]),
+    setFixedPointSigned230Number(matrix[5]),
+    setFixedPointSignedOrUnsigned1616Number(matrix[6]),
+    setFixedPointSignedOrUnsigned1616Number(matrix[7]),
+    setFixedPointSigned230Number(matrix[8])
+  ]);
+};
+var stringToPascalString = (str) => {
+  const buffer = new Uint8Array(32);
+  for (let i = 0;i < Math.min(str.length, 32); i++) {
+    buffer[i] = str.charCodeAt(i);
+  }
+  return buffer;
+};
+var padIsoBaseMediaBytes = (data, totalLength) => {
+  if (data.length - 8 > totalLength) {
+    throw new Error(`Data is longer than the total length: ${data.length - 8} > ${totalLength}`);
+  }
+  if (data.length - 8 === totalLength) {
+    return data;
+  }
+  return combineUint8Arrays([
+    data,
+    addSize(combineUint8Arrays([
+      stringsToUint8Array("free"),
+      new Uint8Array(totalLength - (data.length - 8))
+    ]))
+  ]);
+};
+var IDENTITY_MATRIX = [1, 0, 0, 0, 1, 0, 0, 0, 1];
+
+// src/create/iso-base-media/create-ftyp.ts
+var createFtyp = ({
+  majorBrand,
+  minorBrand,
+  compatibleBrands
+}) => {
+  const type = stringsToUint8Array("ftyp");
+  const majorBrandArr = stringsToUint8Array(majorBrand);
+  const minorBrandArr = numberTo32BitUIntOrInt(minorBrand);
+  const compatibleBrandsArr = combineUint8Arrays(compatibleBrands.map((b) => stringsToUint8Array(b)));
+  return addSize(combineUint8Arrays([
+    type,
+    majorBrandArr,
+    minorBrandArr,
+    compatibleBrandsArr
+  ]));
+};
+var createIsoBaseMediaFtyp = ({
+  majorBrand,
+  minorBrand,
+  compatibleBrands
+}) => {
+  return createFtyp({ compatibleBrands, majorBrand, minorBrand });
+};
+
+// src/create/iso-base-media/create-ilst.ts
+var createIlst = (items) => {
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("ilst"),
+    ...items
+  ]));
+};
+
+// src/create/iso-base-media/create-moov.ts
+var createMoov = ({
+  mvhd,
+  traks,
+  udta
+}) => {
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("moov"),
+    mvhd,
+    ...traks,
+    udta
+  ]));
+};
+
+// src/boxes/iso-base-media/to-date.ts
+var toUnixTimestamp = (value) => {
+  if (value === 0) {
+    return null;
+  }
+  const baseDate = new Date("1904-01-01T00:00:00Z");
+  return Math.floor(value + baseDate.getTime() / 1000) * 1000;
+};
+var fromUnixTimestamp = (value) => {
+  if (value === null) {
+    return 0;
+  }
+  const baseDate = new Date("1904-01-01T00:00:00Z");
+  return Math.floor(value / 1000 - baseDate.getTime() / 1000);
+};
+
+// src/create/iso-base-media/create-mvhd.ts
+var createMvhd = ({
+  timescale,
+  durationInUnits,
+  rate,
+  volume,
+  nextTrackId,
+  matrix,
+  creationTime,
+  modificationTime
+}) => {
+  if (matrix.length !== 9) {
+    throw new Error("Matrix must be 9 elements long");
+  }
+  const content = combineUint8Arrays([
+    stringsToUint8Array("mvhd"),
+    new Uint8Array([0]),
+    new Uint8Array([0, 0, 0]),
+    creationTime === null ? numberTo32BitUIntOrInt(0) : numberTo32BitUIntOrInt(fromUnixTimestamp(creationTime)),
+    modificationTime === null ? numberTo32BitUIntOrInt(0) : numberTo32BitUIntOrInt(fromUnixTimestamp(modificationTime)),
+    numberTo32BitUIntOrInt(timescale),
+    numberTo32BitUIntOrInt(durationInUnits),
+    floatTo16Point1632Bit(rate),
+    floatTo16Point16_16Bit(volume),
+    new Uint8Array([0, 0]),
+    new Uint8Array([0, 0, 0, 0]),
+    new Uint8Array([0, 0, 0, 0]),
+    serializeMatrix(matrix),
+    combineUint8Arrays(new Array(6).fill(new Uint8Array([0, 0, 0, 0]))),
+    numberTo32BitUIntOrInt(nextTrackId)
+  ]);
+  return addSize(content);
+};
+
+// src/create/iso-base-media/create-udta.ts
+var createUdta = (children) => {
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("udta"),
+    children
+  ]));
+};
+
+// src/create/iso-base-media/ilst/create-cmt.ts
+var createCmt = (comment) => {
+  return addSize(combineUint8Arrays([
+    new Uint8Array([169, 99, 109, 116]),
+    addSize(combineUint8Arrays([
+      stringsToUint8Array("data"),
+      new Uint8Array([0, 0]),
+      new Uint8Array([0, 1]),
+      new Uint8Array([0, 0]),
+      new Uint8Array([0, 0]),
+      stringsToUint8Array(comment)
+    ]))
+  ]));
+};
+
+// src/create/iso-base-media/ilst/create-too.ts
+var createToo = (value) => {
+  return addSize(combineUint8Arrays([
+    new Uint8Array([169, 116, 111, 111]),
+    addSize(combineUint8Arrays([
+      new Uint8Array([100, 97, 116, 97]),
+      new Uint8Array([0, 0]),
+      new Uint8Array([0, 1]),
+      new Uint8Array([0, 0]),
+      new Uint8Array([0, 0]),
+      stringsToUint8Array(value)
+    ]))
+  ]));
+};
+
+// src/create/iso-base-media/trak/mdia/minf/stbl/stsd/create-avcc.ts
+var createAvccBox = (privateData) => {
+  if (!privateData) {
+    throw new Error("privateData is required");
+  }
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("avcC"),
+    privateData
+  ]));
+};
+
+// src/create/iso-base-media/trak/mdia/minf/stbl/stsd/create-pasp.ts
+var createPasp = (x, y) => {
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("pasp"),
+    numberTo32BitUIntOrInt(x),
+    numberTo32BitUIntOrInt(y)
+  ]));
+};
+
+// src/create/iso-base-media/codec-specific/avc1.ts
+var createAvc1Data = ({
+  avccBox,
+  pasp,
+  width,
+  height,
+  horizontalResolution,
+  verticalResolution,
+  compressorName,
+  depth
+}) => {
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("avc1"),
+    new Uint8Array([0, 0, 0, 0, 0, 0]),
+    new Uint8Array([0, 1]),
+    new Uint8Array([0, 0]),
+    new Uint8Array([0, 0]),
+    new Uint8Array([0, 0, 0, 0]),
+    new Uint8Array([0, 0, 0, 0]),
+    new Uint8Array([0, 0, 0, 0]),
+    numberTo16BitUIntOrInt(width),
+    numberTo16BitUIntOrInt(height),
+    setFixedPointSignedOrUnsigned1616Number(horizontalResolution),
+    setFixedPointSignedOrUnsigned1616Number(verticalResolution),
+    new Uint8Array([0, 0, 0, 0]),
+    numberTo16BitUIntOrInt(1),
+    stringToPascalString(compressorName),
+    numberTo16BitUIntOrInt(depth),
+    numberTo16BitUIntOrInt(-1),
+    avccBox,
+    pasp
+  ]));
+};
+
+// src/create/iso-base-media/codec-specific/mp4a.ts
+var createMp4a = ({
+  sampleRate,
+  channelCount,
+  avgBitrate,
+  maxBitrate,
+  codecPrivate: codecPrivate2
+}) => {
+  if (!codecPrivate2) {
+    throw new Error("Need codecPrivate for mp4a");
+  }
+  const esdsAtom = addSize(combineUint8Arrays([
+    stringsToUint8Array("esds"),
+    new Uint8Array([0]),
+    new Uint8Array([0, 0, 0]),
+    new Uint8Array([3]),
+    addLeading128Size(combineUint8Arrays([
+      numberTo16BitUIntOrInt(2),
+      new Uint8Array([0]),
+      new Uint8Array([4]),
+      addLeading128Size(combineUint8Arrays([
+        new Uint8Array([64]),
+        new Uint8Array([21]),
+        new Uint8Array([0, 0, 0]),
+        numberTo32BitUIntOrInt(maxBitrate),
+        numberTo32BitUIntOrInt(avgBitrate),
+        new Uint8Array([5]),
+        addLeading128Size(codecPrivate2)
+      ])),
+      new Uint8Array([6]),
+      addLeading128Size(new Uint8Array([2]))
+    ]))
+  ]));
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("mp4a"),
+    new Uint8Array([0, 0, 0, 0, 0, 0]),
+    numberTo16BitUIntOrInt(1),
+    numberTo16BitUIntOrInt(0),
+    numberTo16BitUIntOrInt(0),
+    new Uint8Array([0, 0, 0, 0]),
+    numberTo16BitUIntOrInt(channelCount),
+    numberTo16BitUIntOrInt(16),
+    numberTo16BitUIntOrInt(0),
+    numberTo16BitUIntOrInt(0),
+    setFixedPointSignedOrUnsigned1616Number(sampleRate),
+    esdsAtom
+  ]));
+};
+
+// src/create/iso-base-media/codec-specific/create-codec-specific-data.ts
+var createCodecSpecificData = (track) => {
+  if (track.type === "video") {
+    return createAvc1Data({
+      avccBox: createAvccBox(track.codecPrivate),
+      compressorName: "WebCodecs",
+      depth: 24,
+      horizontalResolution: 72,
+      verticalResolution: 72,
+      height: track.height,
+      width: track.width,
+      pasp: createPasp(1, 1),
+      type: "avc1-data"
+    });
+  }
+  if (track.type === "audio") {
+    return createMp4a({
+      type: "mp4a-data",
+      avgBitrate: 128 * 1024,
+      maxBitrate: 128 * 1024,
+      channelCount: track.numberOfChannels,
+      sampleRate: track.sampleRate,
+      codecPrivate: track.codecPrivate
+    });
+  }
+  throw new Error("Unsupported codec specific data " + track);
+};
+
+// src/create/iso-base-media/create-mdia.ts
+var createMdia = ({
+  mdhd,
+  hdlr,
+  minf
+}) => {
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("mdia"),
+    mdhd,
+    hdlr,
+    minf
+  ]));
+};
+
+// src/truthy.ts
+function truthy(value) {
+  return Boolean(value);
+}
+
+// src/create/iso-base-media/create-trak.ts
+var createTrak = ({
+  tkhd,
+  mdia
+}) => {
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("trak"),
+    tkhd,
+    mdia
+  ].filter(truthy)));
+};
+
+// src/create/iso-base-media/mdia/create-mdhd.ts
+var createMdhd = ({
+  creationTime,
+  modificationTime,
+  timescale,
+  duration: duration2
+}) => {
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("mdhd"),
+    new Uint8Array([0]),
+    new Uint8Array([0, 0, 0]),
+    creationTime === null ? numberTo32BitUIntOrInt(0) : numberTo32BitUIntOrInt(fromUnixTimestamp(creationTime)),
+    modificationTime === null ? numberTo32BitUIntOrInt(0) : numberTo32BitUIntOrInt(fromUnixTimestamp(modificationTime)),
+    numberTo32BitUIntOrInt(timescale),
+    numberTo32BitUIntOrInt(Math.round(duration2 / 1000 * timescale)),
+    new Uint8Array([85, 196]),
+    new Uint8Array([0, 0])
+  ]));
+};
+
+// src/create/iso-base-media/trak/create-tkhd.ts
+var TKHD_FLAGS = {
+  TRACK_ENABLED: 1,
+  TRACK_IN_MOVIE: 2,
+  TRACK_IN_PREVIEW: 4,
+  TRACK_IN_POSTER: 8
+};
+var createTkhdForAudio = ({
+  creationTime,
+  modificationTime,
+  flags,
+  trackId,
+  duration: duration2,
+  volume,
+  timescale
+}) => {
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("tkhd"),
+    new Uint8Array([0]),
+    new Uint8Array([0, 0, flags]),
+    creationTime === null ? numberTo32BitUIntOrInt(0) : numberTo32BitUIntOrInt(fromUnixTimestamp(creationTime)),
+    modificationTime === null ? numberTo32BitUIntOrInt(0) : numberTo32BitUIntOrInt(fromUnixTimestamp(modificationTime)),
+    numberTo32BitUIntOrInt(trackId),
+    new Uint8Array([0, 0, 0, 0]),
+    numberTo32BitUIntOrInt(Math.round(duration2 / 1000 * timescale)),
+    new Uint8Array([0, 0, 0, 0]),
+    new Uint8Array([0, 0, 0, 0]),
+    new Uint8Array([0, 0]),
+    new Uint8Array([0, 1]),
+    floatTo16Point16_16Bit(volume),
+    new Uint8Array([0, 0]),
+    serializeMatrix(IDENTITY_MATRIX),
+    setFixedPointSignedOrUnsigned1616Number(0),
+    setFixedPointSignedOrUnsigned1616Number(0)
+  ]));
+};
+var createTkhdForVideo = ({
+  creationTime,
+  modificationTime,
+  duration: duration2,
+  trackId,
+  volume,
+  matrix,
+  width,
+  height,
+  flags,
+  timescale
+}) => {
+  const content = combineUint8Arrays([
+    stringsToUint8Array("tkhd"),
+    new Uint8Array([0]),
+    new Uint8Array([0, 0, flags]),
+    creationTime === null ? numberTo32BitUIntOrInt(0) : numberTo32BitUIntOrInt(fromUnixTimestamp(creationTime)),
+    modificationTime === null ? numberTo32BitUIntOrInt(0) : numberTo32BitUIntOrInt(fromUnixTimestamp(modificationTime)),
+    numberTo32BitUIntOrInt(trackId),
+    new Uint8Array([0, 0, 0, 0]),
+    numberTo32BitUIntOrInt(duration2 / 1000 * timescale),
+    new Uint8Array([0, 0, 0, 0]),
+    new Uint8Array([0, 0, 0, 0]),
+    new Uint8Array([0, 0]),
+    new Uint8Array([0, 0]),
+    floatTo16Point16_16Bit(volume),
+    new Uint8Array([0, 0]),
+    serializeMatrix(matrix),
+    setFixedPointSignedOrUnsigned1616Number(width),
+    setFixedPointSignedOrUnsigned1616Number(height)
+  ]);
+  return addSize(content);
+};
+
+// src/create/iso-base-media/trak/mdia/minf/create-dinf.ts
+var createDinf = () => {
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("dinf"),
+    addSize(combineUint8Arrays([
+      stringsToUint8Array("dref"),
+      new Uint8Array([0]),
+      new Uint8Array([0, 0, 0]),
+      new Uint8Array([0, 0, 0, 1]),
+      addSize(combineUint8Arrays([
+        stringsToUint8Array("url "),
+        new Uint8Array([0]),
+        new Uint8Array([0, 0, 1])
+      ]))
+    ]))
+  ]));
+};
+
+// src/create/iso-base-media/trak/mdia/create-minf.ts
+var createMinf = ({
+  vmhdAtom,
+  stblAtom
+}) => {
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("minf"),
+    vmhdAtom,
+    createDinf(),
+    stblAtom
+  ]));
+};
+
+// src/create/iso-base-media/trak/mdia/minf/create-smhd.ts
+var createSmhd = () => {
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("smhd"),
+    new Uint8Array([0]),
+    new Uint8Array([0, 0, 0]),
+    new Uint8Array([0, 0]),
+    new Uint8Array([0, 0])
+  ]));
+};
+
+// src/create/iso-base-media/trak/mdia/minf/stbl/create-ctts.ts
+var makeEntry = (entry) => {
+  return combineUint8Arrays([
+    numberTo32BitUIntOrInt(entry.sampleCount),
+    numberTo32BitUIntOrInt(entry.sampleOffset)
+  ]);
+};
+var createCttsBox = (samplePositions) => {
+  const offsets = samplePositions.map((s) => s.cts - s.dts);
+  const entries = [];
+  let lastOffset = null;
+  for (const offset of offsets) {
+    if (lastOffset === offset) {
+      entries[entries.length - 1].sampleCount++;
+    } else {
+      entries.push({
+        sampleCount: 1,
+        sampleOffset: offset
+      });
+    }
+    lastOffset = offset;
+  }
+  const needsCtts = entries.length > 0 && entries.some((e) => e.sampleOffset !== 0);
+  if (!needsCtts) {
+    return null;
+  }
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("ctts"),
+    new Uint8Array([0]),
+    new Uint8Array([0, 0, 0]),
+    numberTo32BitUIntOrInt(entries.length),
+    ...entries.map((e) => makeEntry(e))
+  ]));
+};
+
+// src/create/iso-base-media/trak/mdia/minf/stbl/create-stco.ts
+var createStcoAtom = (samplePositions) => {
+  const chunkOffsets = [];
+  let lastChunk;
+  for (const sample of samplePositions) {
+    if (lastChunk !== sample.chunk) {
+      chunkOffsets.push(sample.offset);
+    }
+    lastChunk = sample.chunk;
+  }
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("stco"),
+    new Uint8Array([0]),
+    new Uint8Array([0, 0, 0]),
+    numberTo32BitUIntOrInt(chunkOffsets.length),
+    ...chunkOffsets.map((offset) => numberTo32BitUIntOrInt(offset))
+  ]));
+};
+
+// src/create/iso-base-media/trak/mdia/minf/stbl/create-stsc.ts
+var createEntry = (entry) => {
+  return combineUint8Arrays([
+    numberTo32BitUIntOrInt(entry.firstChunk),
+    numberTo32BitUIntOrInt(entry.samplesPerChunk),
+    numberTo32BitUIntOrInt(entry.sampleDescriptionIndex)
+  ]);
+};
+var createStsc = (samplePositions) => {
+  const entries = [];
+  const deduplicateLastEntry = () => {
+    const lastEntry = entries[entries.length - 1];
+    const secondToLastEntry = entries[entries.length - 2];
+    if (lastEntry && secondToLastEntry && lastEntry.samplesPerChunk === secondToLastEntry.samplesPerChunk && lastEntry.sampleDescriptionIndex === secondToLastEntry.sampleDescriptionIndex) {
+      const lastIndex = entries.length - 1;
+      entries.length = lastIndex;
+    }
+  };
+  let lastChunk;
+  for (const samplePosition of samplePositions) {
+    if (samplePosition.chunk === lastChunk) {
+      entries[entries.length - 1].samplesPerChunk++;
+    } else {
+      deduplicateLastEntry();
+      entries.push({
+        firstChunk: samplePosition.chunk,
+        samplesPerChunk: 1,
+        sampleDescriptionIndex: 1
+      });
+      lastChunk = samplePosition.chunk;
+    }
+  }
+  deduplicateLastEntry();
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("stsc"),
+    new Uint8Array([0]),
+    new Uint8Array([0, 0, 0]),
+    numberTo32BitUIntOrInt(entries.length),
+    ...entries.map((e) => createEntry(e))
+  ]));
+};
+
+// src/create/iso-base-media/trak/mdia/minf/stbl/create-stss.ts
+var createStss = (samplePositions) => {
+  const samples = samplePositions.map((sample, i) => [sample.isKeyframe, i]).filter((s) => s[0]).map((s) => s[1] + 1);
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("stss"),
+    new Uint8Array([0]),
+    new Uint8Array([0, 0, 0]),
+    numberTo32BitUIntOrInt(samples.length),
+    ...samples.map((sample) => numberTo32BitUIntOrInt(sample))
+  ]));
+};
+
+// src/create/iso-base-media/trak/mdia/minf/stbl/create-stsz.ts
+var createStsz = (samplePositions) => {
+  const sampleSizes = samplePositions.map((samplePosition) => samplePosition.size);
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("stsz"),
+    new Uint8Array([0]),
+    new Uint8Array([0, 0, 0]),
+    numberTo32BitUIntOrInt(0),
+    numberTo32BitUIntOrInt(sampleSizes.length),
+    ...sampleSizes.map((size) => numberTo32BitUIntOrInt(size))
+  ]));
+};
+
+// src/create/iso-base-media/trak/mdia/minf/stbl/create-stts.ts
+var makeEntry2 = (entry) => {
+  return combineUint8Arrays([
+    numberTo32BitUIntOrInt(entry.sampleCount),
+    numberTo32BitUIntOrInt(entry.sampleOffset)
+  ]);
+};
+var createSttsAtom = (samplePositions) => {
+  let lastDuration = null;
+  const durations = samplePositions.map((_, i, a) => {
+    if (a[i].duration === undefined || a[i].duration === 0) {
+      return (a[i + 1]?.dts ?? a[i].dts) - a[i].dts;
+    }
+    return a[i].duration;
+  });
+  const entries = [];
+  for (const duration2 of durations) {
+    if (duration2 === lastDuration) {
+      entries[entries.length - 1].sampleCount++;
+    } else {
+      entries.push({
+        sampleCount: 1,
+        sampleOffset: duration2
+      });
+    }
+    lastDuration = duration2;
+  }
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("stts"),
+    new Uint8Array([0]),
+    new Uint8Array([0, 0, 0]),
+    numberTo32BitUIntOrInt(entries.length),
+    ...entries.map((e) => makeEntry2(e))
+  ]));
+};
+
+// src/create/iso-base-media/trak/mdia/minf/stbl/stsd/create-avc1.ts
+var createStsdData = (codecSpecificData) => {
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("stsd"),
+    new Uint8Array([0]),
+    new Uint8Array([0, 0, 0]),
+    new Uint8Array([0, 0, 0, 1]),
+    codecSpecificData
+  ]));
+};
+
+// src/create/iso-base-media/trak/mdia/minf/create-stbl.ts
+var createStbl = ({
+  samplePositions,
+  codecSpecificData,
+  isVideo
+}) => {
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("stbl"),
+    createStsdData(codecSpecificData),
+    createSttsAtom(samplePositions),
+    isVideo ? createStss(samplePositions) : null,
+    createCttsBox(samplePositions),
+    createStsc(samplePositions),
+    createStsz(samplePositions),
+    createStcoAtom(samplePositions),
+    isVideo ? null : new Uint8Array([
+      0,
+      0,
+      0,
+      26,
+      115,
+      103,
+      112,
+      100,
+      1,
+      0,
+      0,
+      0,
+      114,
+      111,
+      108,
+      108,
+      0,
+      0,
+      0,
+      2,
+      0,
+      0,
+      0,
+      1,
+      255,
+      255,
+      0,
+      0,
+      0,
+      28,
+      115,
+      98,
+      103,
+      112,
+      0,
+      0,
+      0,
+      0,
+      114,
+      111,
+      108,
+      108,
+      0,
+      0,
+      0,
+      1,
+      0,
+      0,
+      10,
+      25,
+      0,
+      0,
+      0,
+      1
+    ])
+  ].filter(truthy)));
+};
+
+// src/create/iso-base-media/trak/mdia/minf/create-vmhd.ts
+var createVmhd = () => {
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("vmhd"),
+    new Uint8Array([0]),
+    new Uint8Array([0, 0, 1]),
+    new Uint8Array([0, 0]),
+    new Uint8Array([0, 0, 0, 0, 0, 0])
+  ]));
+};
+
+// src/create/iso-base-media/udta/meta/create-hdlr.ts
+var createHdlr = (type) => {
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("hdlr"),
+    new Uint8Array([0]),
+    new Uint8Array([0, 0, 0]),
+    new Uint8Array([0, 0, 0, 0]),
+    stringsToUint8Array(type === "mdir" ? "mdir" : type === "video" ? "vide" : "soun"),
+    type === "mdir" ? numberTo32BitUIntOrInt(1634758764) : new Uint8Array([0, 0, 0, 0]),
+    new Uint8Array([0, 0, 0, 0]),
+    new Uint8Array([0, 0, 0, 0]),
+    stringsToUint8Array(type === "mdir" ? "\0" : type === "video" ? "VideoHandler\0" : "SoundHandler\0")
+  ]));
+};
+
+// src/create/iso-base-media/serialize-track.ts
+var serializeTrack = ({
+  track,
+  durationInUnits,
+  samplePositions,
+  timescale
+}) => {
+  if (track.codec !== "h264" && track.codec !== "aac") {
+    throw new Error("Currently only H.264 and AAC is supported");
+  }
+  return createTrak({
+    tkhd: track.codec === "aac" ? createTkhdForAudio({
+      creationTime: Date.now(),
+      flags: TKHD_FLAGS.TRACK_ENABLED | TKHD_FLAGS.TRACK_IN_MOVIE,
+      modificationTime: Date.now(),
+      duration: durationInUnits,
+      trackId: track.trackNumber,
+      volume: 1,
+      timescale
+    }) : track.type === "video" ? createTkhdForVideo({
+      creationTime: Date.now(),
+      modificationTime: Date.now(),
+      duration: durationInUnits,
+      flags: TKHD_FLAGS.TRACK_ENABLED | TKHD_FLAGS.TRACK_IN_MOVIE,
+      height: track.height,
+      width: track.width,
+      matrix: IDENTITY_MATRIX,
+      trackId: track.trackNumber,
+      volume: 0,
+      timescale
+    }) : new Uint8Array(stringsToUint8Array("wrong")),
+    mdia: createMdia({
+      mdhd: createMdhd({
+        creationTime: null,
+        modificationTime: null,
+        duration: durationInUnits,
+        timescale: track.timescale
+      }),
+      hdlr: track.type === "video" ? createHdlr("video") : createHdlr("audio"),
+      minf: createMinf({
+        stblAtom: createStbl({
+          samplePositions,
+          isVideo: track.type === "video",
+          codecSpecificData: createCodecSpecificData(track)
+        }),
+        vmhdAtom: track.type === "audio" ? createSmhd() : createVmhd()
+      })
+    })
+  });
+};
+
+// src/create/iso-base-media/udta/create-meta.ts
+var createMeta = ({
+  hdlr,
+  ilst
+}) => {
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("meta"),
+    new Uint8Array([0]),
+    new Uint8Array([0, 0, 0]),
+    hdlr,
+    ilst
+  ]));
+};
+
+// src/create/iso-base-media/mp4-header.ts
+var HEADER_LENGTH = 1024000;
+var createPaddedMoovAtom = ({
+  durationInUnits,
+  trackInfo,
+  timescale
+}) => {
+  return padIsoBaseMediaBytes(createMoov({
+    mvhd: createMvhd({
+      timescale,
+      durationInUnits,
+      matrix: IDENTITY_MATRIX,
+      nextTrackId: trackInfo.map((t) => t.track.trackNumber).reduce((a, b) => Math.max(a, b), 0) + 1,
+      rate: 1,
+      volume: 1,
+      creationTime: Date.now(),
+      modificationTime: Date.now()
+    }),
+    traks: trackInfo.map((track) => {
+      return serializeTrack({
+        timescale,
+        track: track.track,
+        durationInUnits,
+        samplePositions: track.samplePositions
+      });
+    }),
+    udta: createUdta(createMeta({
+      hdlr: createHdlr("mdir"),
+      ilst: createIlst([
+        createToo("WebCodecs"),
+        createCmt("Made with @remotion/webcodecs")
+      ])
+    }))
+  }), HEADER_LENGTH);
+};
+
+// src/create/iso-base-media/create-iso-base-media.ts
+var createIsoBaseMedia = async ({
+  writer,
+  onBytesProgress,
+  onMillisecondsProgress,
+  logLevel,
+  filename
+}) => {
+  const header = createIsoBaseMediaFtyp({
+    compatibleBrands: ["isom", "iso2", "avc1", "mp42"],
+    majorBrand: "isom",
+    minorBrand: 512
+  });
+  const w = await writer.createContent({ filename, mimeType: "video/mp4" });
+  await w.write(header);
+  let durationInUnits = 0;
+  const currentTracks = [];
+  const samplePositions = [];
+  const sampleChunkIndices = [];
+  const moovOffset = w.getWrittenByteCount();
+  const getPaddedMoovAtom = () => {
+    return createPaddedMoovAtom({
+      durationInUnits,
+      trackInfo: currentTracks.map((track) => {
+        return {
+          track,
+          durationInUnits,
+          samplePositions: samplePositions[track.trackNumber] ?? [],
+          timescale: track.timescale
+        };
+      }),
+      timescale: 1000
+    });
+  };
+  await w.write(getPaddedMoovAtom());
+  let mdatSize = 8;
+  const mdatSizeOffset = w.getWrittenByteCount();
+  await w.write(combineUint8Arrays([
+    numberTo32BitUIntOrInt(mdatSize),
+    stringsToUint8Array("mdat")
+  ]));
+  const updateMdatSize = async () => {
+    await w.updateDataAt(mdatSizeOffset, numberTo32BitUIntOrInt(mdatSize));
+    onBytesProgress(w.getWrittenByteCount());
+  };
+  const operationProm = { current: Promise.resolve() };
+  const updateMoov = async () => {
+    await w.updateDataAt(moovOffset, getPaddedMoovAtom());
+    onBytesProgress(w.getWrittenByteCount());
+  };
+  const updateDuration = (newDuration) => {
+    durationInUnits = newDuration;
+    onMillisecondsProgress(newDuration);
+  };
+  const addCodecPrivateToTrack = ({
+    trackNumber: trackNumber2,
+    codecPrivate: codecPrivate2
+  }) => {
+    currentTracks.forEach((track) => {
+      if (track.trackNumber === trackNumber2) {
+        track.codecPrivate = codecPrivate2;
+      }
+    });
+  };
+  let lastChunkWasVideo = false;
+  const addSample = async ({
+    chunk,
+    trackNumber: trackNumber2,
+    isVideo,
+    timescale,
+    codecPrivate: codecPrivate2
+  }) => {
+    const position = w.getWrittenByteCount();
+    await w.write(chunk.data);
+    mdatSize += chunk.data.length;
+    onBytesProgress(w.getWrittenByteCount());
+    if (codecPrivate2) {
+      addCodecPrivateToTrack({ trackNumber: trackNumber2, codecPrivate: codecPrivate2 });
+    }
+    const newDuration = Math.round((chunk.timestamp + (chunk.duration ?? 0)) / 1000);
+    updateDuration(newDuration);
+    if (!samplePositions[trackNumber2]) {
+      samplePositions[trackNumber2] = [];
+    }
+    if (typeof sampleChunkIndices[trackNumber2] === "undefined") {
+      sampleChunkIndices[trackNumber2] = 0;
+    }
+    if (isVideo && chunk.type === "key") {
+      sampleChunkIndices[trackNumber2]++;
+    } else if (!isVideo && samplePositions[trackNumber2].length % 22 === 0) {
+      sampleChunkIndices[trackNumber2]++;
+    } else if (lastChunkWasVideo !== isVideo) {
+      sampleChunkIndices[trackNumber2]++;
+    }
+    const samplePositionToAdd = {
+      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)),
+      size: chunk.data.length
+    };
+    lastChunkWasVideo = isVideo;
+    samplePositions[trackNumber2].push(samplePositionToAdd);
+  };
+  const addTrack = (track) => {
+    const trackNumber2 = currentTracks.length + 1;
+    currentTracks.push({ ...track, trackNumber: trackNumber2 });
+    return Promise.resolve({ trackNumber: trackNumber2 });
+  };
+  const waitForFinishPromises = [];
+  return {
+    save: () => {
+      return w.save();
+    },
+    remove: async () => {
+      await w.remove();
+    },
+    addSample: ({ chunk, trackNumber: trackNumber2, isVideo, timescale, codecPrivate: codecPrivate2 }) => {
+      operationProm.current = operationProm.current.then(() => {
+        return addSample({
+          chunk,
+          trackNumber: trackNumber2,
+          isVideo,
+          timescale,
+          codecPrivate: codecPrivate2
+        });
+      });
+      return operationProm.current;
+    },
+    addTrack: (track) => {
+      operationProm.current = operationProm.current.then(() => addTrack(track));
+      return operationProm.current;
+    },
+    updateTrackSampleRate: ({ sampleRate, trackNumber: trackNumber2 }) => {
+      currentTracks.forEach((track) => {
+        if (track.trackNumber === trackNumber2) {
+          if (track.type !== "audio") {
+            throw new Error(`Tried to update sample rate of track ${trackNumber2}, but it's not an audio track`);
+          }
+          track.sampleRate = sampleRate;
+        }
+      });
+    },
+    addWaitForFinishPromise: (promise) => {
+      waitForFinishPromises.push(promise);
+    },
+    async waitForFinish() {
+      Log.verbose(logLevel, "All write operations queued. Waiting for finish...");
+      await Promise.all(waitForFinishPromises.map((p) => p()));
+      Log.verbose(logLevel, "Cleanup tasks executed");
+      await operationProm.current;
+      await updateMoov();
+      await updateMdatSize();
+      Log.verbose(logLevel, "All write operations done. Waiting for finish...");
+      await w.waitForFinish();
+    },
+    updateDuration: (duration2) => {
+      operationProm.current = operationProm.current.then(() => updateDuration(duration2));
+      return operationProm.current;
+    }
+  };
+};
+
+// src/create/matroska/cluster-segment.ts
 var CLUSTER_MIN_VINT_WIDTH = 8;
 var createClusterSegment = (timestamp) => {
   return makeMatroskaBytes({
@@ -1062,32 +2166,36 @@ var makeSimpleBlock = ({
   ]);
 };
 
-// src/create/timescale.ts
-var CREATE_TIME_SCALE = 1e6;
-
-// src/create/cluster.ts
+// src/create/matroska/cluster.ts
 var maxClusterTimestamp = 2 ** 15;
-var timestampToClusterTimestamp = (timestamp) => {
-  return Math.round(timestamp / CREATE_TIME_SCALE * 1000);
+var timestampToClusterTimestamp = (timestamp, timescale) => {
+  return Math.round(timestamp / timescale * 1000);
 };
 var canFitInCluster = ({
   clusterStartTimestamp,
-  chunk
+  chunk,
+  timescale
 }) => {
-  const timecodeRelativeToCluster = timestampToClusterTimestamp(chunk.timestamp) - timestampToClusterTimestamp(clusterStartTimestamp);
+  const timecodeRelativeToCluster = timestampToClusterTimestamp(chunk.timestamp, timescale) - timestampToClusterTimestamp(clusterStartTimestamp, timescale);
   if (timecodeRelativeToCluster < 0) {
     throw new Error(`timecodeRelativeToCluster is negative`);
   }
   return timecodeRelativeToCluster <= maxClusterTimestamp;
 };
-var makeCluster = async (w, clusterStartTimestamp) => {
-  const cluster = createClusterSegment(timestampToClusterTimestamp(clusterStartTimestamp));
-  const clusterVIntPosition = w.getWrittenByteCount() + cluster.offsets.offset + matroskaToHex(matroskaElements.Cluster).byteLength;
+var makeCluster = async ({
+  writer,
+  clusterStartTimestamp,
+  timescale,
+  logLevel
+}) => {
+  Log.verbose(logLevel, `Making new Matroska cluster with timestamp ${clusterStartTimestamp}`);
+  const cluster = createClusterSegment(timestampToClusterTimestamp(clusterStartTimestamp, timescale));
+  const clusterVIntPosition = writer.getWrittenByteCount() + cluster.offsets.offset + matroskaToHex(matroskaElements.Cluster).byteLength;
   let clusterSize = cluster.bytes.byteLength - matroskaToHex(matroskaElements.Cluster).byteLength - CLUSTER_MIN_VINT_WIDTH;
-  await w.write(cluster.bytes);
+  await writer.write(cluster.bytes);
   const addSample = async (chunk, trackNumber2) => {
-    const timecodeRelativeToCluster = timestampToClusterTimestamp(chunk.timestamp) - timestampToClusterTimestamp(clusterStartTimestamp);
-    if (!canFitInCluster({ clusterStartTimestamp, chunk })) {
+    const timecodeRelativeToCluster = timestampToClusterTimestamp(chunk.timestamp, timescale) - timestampToClusterTimestamp(clusterStartTimestamp, timescale);
+    if (!canFitInCluster({ clusterStartTimestamp, chunk, timescale })) {
       throw new Error(`timecodeRelativeToCluster is too big: ${timecodeRelativeToCluster} > ${maxClusterTimestamp}`);
     }
     const keyframe = chunk.type === "key";
@@ -1100,8 +2208,8 @@ var makeCluster = async (w, clusterStartTimestamp) => {
       timecodeRelativeToCluster
     });
     clusterSize += simpleBlock2.byteLength;
-    await w.updateDataAt(clusterVIntPosition, getVariableInt(clusterSize, CLUSTER_MIN_VINT_WIDTH));
-    await w.write(simpleBlock2);
+    await writer.updateDataAt(clusterVIntPosition, getVariableInt(clusterSize, CLUSTER_MIN_VINT_WIDTH));
+    await writer.write(simpleBlock2);
     return { timecodeRelativeToCluster };
   };
   const shouldMakeNewCluster = ({
@@ -1109,13 +2217,15 @@ var makeCluster = async (w, clusterStartTimestamp) => {
     chunk,
     newT
   }) => {
-    const newTimestamp = timestampToClusterTimestamp(newT);
-    const oldTimestamp = timestampToClusterTimestamp(clusterStartTimestamp);
+    const newTimestamp = timestampToClusterTimestamp(newT, timescale);
+    const oldTimestamp = timestampToClusterTimestamp(clusterStartTimestamp, timescale);
     const canFit = canFitInCluster({
       chunk,
-      clusterStartTimestamp
+      clusterStartTimestamp,
+      timescale
     });
     if (!canFit) {
+      Log.verbose(logLevel, `Cannot fit ${chunk.timestamp} in cluster ${clusterStartTimestamp}. Creating new cluster`);
       return true;
     }
     const keyframe = chunk.type === "key";
@@ -1128,7 +2238,7 @@ var makeCluster = async (w, clusterStartTimestamp) => {
   };
 };
 
-// src/create/make-duration-with-padding.ts
+// src/create/matroska/make-duration-with-padding.ts
 var makeDurationWithPadding = (newDuration) => {
   return makeMatroskaBytes({
     type: "Duration",
@@ -1140,7 +2250,7 @@ var makeDurationWithPadding = (newDuration) => {
   });
 };
 
-// src/create/matroska-cues.ts
+// src/create/matroska/matroska-cues.ts
 var createMatroskaCues = (cues) => {
   return makeMatroskaBytes({
     type: "Cues",
@@ -1186,7 +2296,7 @@ var createMatroskaCues = (cues) => {
   });
 };
 
-// src/create/matroska-header.ts
+// src/create/matroska/matroska-header.ts
 var makeMatroskaHeader = () => {
   return makeMatroskaBytes({
     type: "Header",
@@ -1249,7 +2359,7 @@ var makeMatroskaHeader = () => {
   });
 };
 
-// src/create/matroska-info.ts
+// src/create/matroska/matroska-info.ts
 var makeMatroskaInfo = ({ timescale }) => {
   return makeMatroskaBytes({
     type: "Info",
@@ -1278,7 +2388,7 @@ var makeMatroskaInfo = ({ timescale }) => {
   });
 };
 
-// src/create/matroska-seek.ts
+// src/create/matroska/matroska-seek.ts
 var createMatroskaSeekHead = (seeks) => {
   return padMatroskaBytes(makeMatroskaBytes({
     type: "SeekHead",
@@ -1307,7 +2417,7 @@ var createMatroskaSeekHead = (seeks) => {
   }), 200);
 };
 
-// src/create/matroska-segment.ts
+// src/create/matroska/matroska-segment.ts
 var MATROSKA_SEGMENT_MIN_VINT_WIDTH = 8;
 var createMatroskaSegment = (children) => {
   return makeMatroskaBytes({
@@ -1317,11 +2427,6 @@ var createMatroskaSegment = (children) => {
   });
 };
 
-// src/truthy.ts
-function truthy(value) {
-  return Boolean(value);
-}
-
 // src/boxes/webm/traversal.ts
 var getMainSegment = (segments) => {
   return segments.find((s) => s.type === "Segment");
@@ -1584,7 +2689,7 @@ var makeMatroskaColorBytes = ({
   });
 };
 
-// src/create/matroska-trackentry.ts
+// src/create/matroska/matroska-trackentry.ts
 var makeMatroskaVideoBytes = ({
   color: color2,
   width,
@@ -1824,24 +2929,31 @@ var makeMatroskaVideoTrackEntryBytes = ({
   });
 };
 var makeMatroskaTracks = (tracks2) => {
+  const bytesArr = tracks2.map((t) => {
+    const bytes = t.type === "video" ? makeMatroskaVideoTrackEntryBytes(t) : makeMatroskaAudioTrackEntryBytes(t);
+    return bytes;
+  });
   return padMatroskaBytes(makeMatroskaBytes({
     type: "Tracks",
-    value: tracks2,
+    value: bytesArr,
     minVintWidth: null
   }), 500);
 };
 
-// src/create/create-media.ts
-var createMedia = async ({
+// src/create/matroska/create-matroska-media.ts
+var timescale = 1e6;
+var createMatroskaMedia = async ({
   writer,
   onBytesProgress,
-  onMillisecondsProgress
+  onMillisecondsProgress,
+  filename,
+  logLevel
 }) => {
   const header = makeMatroskaHeader();
-  const w = await writer.createContent();
+  const w = await writer.createContent({ filename, mimeType: "video/webm" });
   await w.write(header.bytes);
   const matroskaInfo = makeMatroskaInfo({
-    timescale: CREATE_TIME_SCALE
+    timescale
   });
   const currentTracks = [];
   const seeks = [];
@@ -1890,7 +3002,12 @@ var createMedia = async ({
   };
   await w.write(matroskaSegment.bytes);
   const clusterOffset = w.getWrittenByteCount();
-  let currentCluster = await makeCluster(w, 0);
+  let currentCluster = await makeCluster({
+    writer: w,
+    clusterStartTimestamp: 0,
+    timescale,
+    logLevel
+  });
   seeks.push({
     hexString: matroskaElements.Cluster,
     byte: clusterOffset - seekHeadOffset
@@ -1898,9 +3015,14 @@ var createMedia = async ({
   const trackNumberProgresses = {};
   const getClusterOrMakeNew = async ({
     chunk,
-    isVideo
+    isVideo,
+    trackNumber: trackNumber2
   }) => {
-    const smallestProgress = Math.min(...Object.values(trackNumberProgresses));
+    const trackProgressValues = Object.values(trackNumberProgresses);
+    const smallestProgress = trackProgressValues.length === 0 ? 0 : Math.min(...trackProgressValues);
+    if (chunk.type === "key") {
+      trackNumberProgresses[trackNumber2] = chunk.timestamp;
+    }
     if (!currentCluster.shouldMakeNewCluster({
       newT: smallestProgress,
       isVideo,
@@ -1908,7 +3030,12 @@ var createMedia = async ({
     })) {
       return { cluster: currentCluster, isNew: false, smallestProgress };
     }
-    currentCluster = await makeCluster(w, smallestProgress);
+    currentCluster = await makeCluster({
+      writer: w,
+      clusterStartTimestamp: smallestProgress,
+      timescale,
+      logLevel
+    });
     return { cluster: currentCluster, isNew: true, smallestProgress };
   };
   const updateDuration = async (newDuration) => {
@@ -1916,11 +3043,15 @@ var createMedia = async ({
     await w.updateDataAt(durationOffset, blocks.bytes);
     onBytesProgress(w.getWrittenByteCount());
   };
-  const addSample = async (chunk, trackNumber2, isVideo) => {
-    trackNumberProgresses[trackNumber2] = chunk.timestamp;
+  const addSample = async ({
+    chunk,
+    trackNumber: trackNumber2,
+    isVideo
+  }) => {
     const { cluster, isNew, smallestProgress } = await getClusterOrMakeNew({
       chunk,
-      isVideo
+      isVideo,
+      trackNumber: trackNumber2
     });
     const newDuration = Math.round((chunk.timestamp + (chunk.duration ?? 0)) / 1000);
     await updateDuration(newDuration);
@@ -1928,7 +3059,7 @@ var createMedia = async ({
     if (isNew) {
       const newCluster = w.getWrittenByteCount();
       cues.push({
-        time: timestampToClusterTimestamp(smallestProgress) + timecodeRelativeToCluster,
+        time: timestampToClusterTimestamp(smallestProgress, timescale) + timecodeRelativeToCluster,
         clusterPosition: newCluster - seekHeadOffset,
         trackNumber: trackNumber2
       });
@@ -1944,79 +3075,53 @@ var createMedia = async ({
   const operationProm = { current: Promise.resolve() };
   const waitForFinishPromises = [];
   return {
-    save: async () => {
-      const file = await w.save();
-      return file;
+    updateTrackSampleRate: ({ sampleRate, trackNumber: trackNumber2 }) => {
+      currentTracks.forEach((track) => {
+        if (track.trackNumber === trackNumber2) {
+          if (track.type !== "audio") {
+            throw new Error("track is not audio");
+          }
+          track.sampleRate = sampleRate;
+        }
+      });
+    },
+    save: () => {
+      return w.save();
     },
     remove: async () => {
       await w.remove();
     },
-    addSample: (chunk, trackNumber2, isVideo) => {
-      operationProm.current = operationProm.current.then(() => addSample(chunk, trackNumber2, isVideo));
+    addSample: ({ chunk, trackNumber: trackNumber2, isVideo }) => {
+      operationProm.current = operationProm.current.then(() => addSample({ chunk, trackNumber: trackNumber2, isVideo }));
       return operationProm.current;
     },
     updateDuration: (duration2) => {
       operationProm.current = operationProm.current.then(() => updateDuration(duration2));
       return operationProm.current;
-    },
-    addTrack: (track) => {
-      const trackNumber2 = currentTracks.length + 1;
-      const bytes = track.type === "video" ? makeMatroskaVideoTrackEntryBytes({ ...track, trackNumber: trackNumber2 }) : makeMatroskaAudioTrackEntryBytes({ ...track, trackNumber: trackNumber2 });
-      operationProm.current = operationProm.current.then(() => addTrack(bytes));
-      trackNumbers.push(trackNumber2);
-      return operationProm.current.then(() => ({ trackNumber: trackNumber2 }));
-    },
-    addWaitForFinishPromise: (promise) => {
-      waitForFinishPromises.push(promise);
-    },
-    async waitForFinish() {
-      await Promise.all(waitForFinishPromises.map((p) => p()));
-      await operationProm.current;
-      seeks.push({
-        hexString: matroskaElements.Cues,
-        byte: w.getWrittenByteCount() - seekHeadOffset
-      });
-      await updateSeekWrite();
-      await w.write(createMatroskaCues(cues).bytes);
-      await w.waitForFinish();
-      const segmentSize = w.getWrittenByteCount() - segmentOffset - matroskaToHex(matroskaElements.Segment).byteLength - MATROSKA_SEGMENT_MIN_VINT_WIDTH;
-      await updateSegmentSize(segmentSize);
-    }
-  };
-};
-
-// src/log.ts
-var logLevels = ["trace", "verbose", "info", "warn", "error"];
-var getNumberForLogLevel = (level) => {
-  return logLevels.indexOf(level);
-};
-var isEqualOrBelowLogLevel = (currentLevel, level) => {
-  return getNumberForLogLevel(currentLevel) <= getNumberForLogLevel(level);
-};
-var Log = {
-  trace: (logLevel, ...args) => {
-    if (isEqualOrBelowLogLevel(logLevel, "trace")) {
-      return console.log(...args);
-    }
-  },
-  verbose: (logLevel, ...args) => {
-    if (isEqualOrBelowLogLevel(logLevel, "verbose")) {
-      return console.log(...args);
-    }
-  },
-  info: (logLevel, ...args) => {
-    if (isEqualOrBelowLogLevel(logLevel, "info")) {
-      return console.log(...args);
-    }
-  },
-  warn: (logLevel, ...args) => {
-    if (isEqualOrBelowLogLevel(logLevel, "warn")) {
-      return console.warn(...args);
+    },
+    addTrack: (track) => {
+      const trackNumber2 = currentTracks.length + 1;
+      operationProm.current = operationProm.current.then(() => addTrack({ ...track, trackNumber: trackNumber2 }));
+      trackNumbers.push(trackNumber2);
+      return operationProm.current.then(() => ({ trackNumber: trackNumber2 }));
+    },
+    addWaitForFinishPromise: (promise) => {
+      waitForFinishPromises.push(promise);
+    },
+    async waitForFinish() {
+      await Promise.all(waitForFinishPromises.map((p) => p()));
+      await operationProm.current;
+      seeks.push({
+        hexString: matroskaElements.Cues,
+        byte: w.getWrittenByteCount() - seekHeadOffset
+      });
+      await updateSeekWrite();
+      await w.write(createMatroskaCues(cues).bytes);
+      await w.waitForFinish();
+      const segmentSize = w.getWrittenByteCount() - segmentOffset - matroskaToHex(matroskaElements.Segment).byteLength - MATROSKA_SEGMENT_MIN_VINT_WIDTH;
+      await updateSegmentSize(segmentSize);
     }
-  },
-  error: (...args) => {
-    return console.error(...args);
-  }
+  };
 };
 
 // src/boxes/iso-base-media/traversal.ts
@@ -2053,135 +3158,373 @@ var getMdiaBox = (trakBox) => {
   if (!mdiaBox || mdiaBox.type !== "regular-box") {
     return null;
   }
-  return mdiaBox;
+  return mdiaBox;
+};
+var getMdhdBox = (trakBox) => {
+  const mdiaBox = getMdiaBox(trakBox);
+  if (!mdiaBox) {
+    return null;
+  }
+  const mdhdBox = mdiaBox.children.find((c) => c.type === "mdhd-box");
+  return mdhdBox;
+};
+var getStblBox = (trakBox) => {
+  const mdiaBox = getMdiaBox(trakBox);
+  if (!mdiaBox) {
+    return null;
+  }
+  const minfBox = mdiaBox.children.find((s) => s.type === "regular-box" && s.boxType === "minf");
+  if (!minfBox || minfBox.type !== "regular-box") {
+    return null;
+  }
+  const stblBox = minfBox.children.find((s) => s.type === "regular-box" && s.boxType === "stbl");
+  if (!stblBox || stblBox.type !== "regular-box") {
+    return null;
+  }
+  return stblBox;
+};
+var getStsdBox = (trakBox) => {
+  const stblBox = getStblBox(trakBox);
+  if (!stblBox || stblBox.type !== "regular-box") {
+    return null;
+  }
+  const stsdBox = stblBox.children.find((s) => s.type === "stsd-box");
+  return stsdBox;
+};
+var getVideoDescriptors = (trakBox) => {
+  const stsdBox = getStsdBox(trakBox);
+  if (!stsdBox) {
+    return null;
+  }
+  const descriptors = stsdBox.samples.map((s) => {
+    return s.type === "video" ? s.descriptors.map((d) => {
+      return d.type === "avcc-box" ? d.privateData : d.type === "hvcc-box" ? d.privateData : null;
+    }) : [];
+  });
+  return descriptors.flat(1).filter(Boolean)[0] ?? null;
+};
+var getStcoBox = (trakBox) => {
+  const stblBox = getStblBox(trakBox);
+  if (!stblBox || stblBox.type !== "regular-box") {
+    return null;
+  }
+  const stcoBox = stblBox.children.find((s) => s.type === "stco-box");
+  return stcoBox;
+};
+var getSttsBox = (trakBox) => {
+  const stblBox = getStblBox(trakBox);
+  if (!stblBox || stblBox.type !== "regular-box") {
+    return null;
+  }
+  const sttsBox = stblBox.children.find((s) => s.type === "stts-box");
+  return sttsBox;
+};
+var getCttsBox = (trakBox) => {
+  const stblBox = getStblBox(trakBox);
+  if (!stblBox || stblBox.type !== "regular-box") {
+    return null;
+  }
+  const cttsBox = stblBox.children.find((s) => s.type === "ctts-box");
+  return cttsBox;
+};
+var getStszBox = (trakBox) => {
+  const stblBox = getStblBox(trakBox);
+  if (!stblBox || stblBox.type !== "regular-box") {
+    return null;
+  }
+  const stszBox = stblBox.children.find((s) => s.type === "stsz-box");
+  return stszBox;
+};
+var getStscBox = (trakBox) => {
+  const stblBox = getStblBox(trakBox);
+  if (!stblBox || stblBox.type !== "regular-box") {
+    return null;
+  }
+  const stcoBox = stblBox.children.find((b) => b.type === "stsc-box");
+  return stcoBox;
+};
+var getStssBox = (trakBox) => {
+  const stblBox = getStblBox(trakBox);
+  if (!stblBox || stblBox.type !== "regular-box") {
+    return null;
+  }
+  const stssBox = stblBox.children.find((b) => b.type === "stss-box");
+  return stssBox;
+};
+var getTfdtBox = (segment) => {
+  if (segment.type !== "regular-box" || segment.boxType !== "traf") {
+    throw new Error("Expected traf-box");
+  }
+  const tfhdBox = segment.children.find((c) => c.type === "tfdt-box");
+  if (!tfhdBox || tfhdBox.type !== "tfdt-box") {
+    throw new Error("Expected tfhd-box");
+  }
+  return tfhdBox;
+};
+var getTfhdBox = (segment) => {
+  if (segment.type !== "regular-box" || segment.boxType !== "traf") {
+    throw new Error("Expected traf-box");
+  }
+  const tfhdBox = segment.children.find((c) => c.type === "tfhd-box");
+  if (!tfhdBox || tfhdBox.type !== "tfhd-box") {
+    throw new Error("Expected tfhd-box");
+  }
+  return tfhdBox;
+};
+var getTrunBoxes = (segment) => {
+  if (segment.type !== "regular-box" || segment.boxType !== "traf") {
+    throw new Error("Expected traf-box");
+  }
+  const trunBoxes = segment.children.filter((c) => c.type === "trun-box");
+  return trunBoxes;
+};
+var getMdatBox = (anySegment) => {
+  const mdat = anySegment.find((b) => b.type === "mdat-box");
+  if (!mdat) {
+    return null;
+  }
+  if (mdat.type !== "mdat-box") {
+    throw new Error("Expected mdat-box");
+  }
+  return mdat;
+};
+
+// src/get-sample-positions.ts
+var getSamplePositions = ({
+  stcoBox,
+  stszBox,
+  stscBox,
+  stssBox,
+  sttsBox,
+  cttsBox
+}) => {
+  const sttsDeltas = [];
+  for (const distribution of sttsBox.sampleDistribution) {
+    for (let i = 0;i < distribution.sampleCount; i++) {
+      sttsDeltas.push(distribution.sampleDelta);
+    }
+  }
+  const cttsEntries = [];
+  for (const entry of cttsBox?.entries ?? [
+    { sampleCount: sttsDeltas.length, sampleOffset: 0 }
+  ]) {
+    for (let i = 0;i < entry.sampleCount; i++) {
+      cttsEntries.push(entry.sampleOffset);
+    }
+  }
+  let dts = 0;
+  const chunks = stcoBox.entries;
+  const samples = [];
+  let samplesPerChunk = 1;
+  for (let i = 0;i < chunks.length; i++) {
+    const hasEntry = stscBox.entries.find((entry) => entry.firstChunk === i + 1);
+    if (hasEntry) {
+      samplesPerChunk = hasEntry.samplesPerChunk;
+    }
+    let offsetInThisChunk = 0;
+    for (let j = 0;j < samplesPerChunk; j++) {
+      const size = stszBox.countType === "fixed" ? stszBox.sampleSize : stszBox.entries[samples.length];
+      const isKeyframe = stssBox ? stssBox.sampleNumber.includes(samples.length + 1) : true;
+      const delta = sttsDeltas[samples.length];
+      const ctsOffset = cttsEntries[samples.length];
+      const cts = dts + ctsOffset;
+      samples.push({
+        offset: Number(chunks[i]) + offsetInThisChunk,
+        size,
+        isKeyframe,
+        dts,
+        cts,
+        duration: delta,
+        chunk: i
+      });
+      dts += delta;
+      offsetInThisChunk += size;
+    }
+  }
+  return samples;
+};
+
+// src/samples-from-moof.ts
+var getSamplesFromTraf = (trafSegment, moofOffset) => {
+  if (trafSegment.type !== "regular-box" || trafSegment.boxType !== "traf") {
+    throw new Error("Expected traf-box");
+  }
+  const tfhdBox = getTfhdBox(trafSegment);
+  const defaultSampleDuration = tfhdBox?.defaultSampleDuration ?? null;
+  const defaultSampleSize = tfhdBox?.defaultSampleSize ?? null;
+  const defaultSampleFlags = tfhdBox?.defaultSampleFlags ?? null;
+  const tfdtBox = getTfdtBox(trafSegment);
+  const trunBoxes = getTrunBoxes(trafSegment);
+  let time = 0;
+  let offset = 0;
+  let dataOffset = 0;
+  const samples = [];
+  for (const trunBox of trunBoxes) {
+    let i = -1;
+    if (trunBox.dataOffset) {
+      dataOffset = trunBox.dataOffset;
+      offset = 0;
+    }
+    for (const sample of trunBox.samples) {
+      i++;
+      const duration2 = sample.sampleDuration ?? defaultSampleDuration;
+      if (duration2 === null) {
+        throw new Error("Expected duration");
+      }
+      const size = sample.sampleSize ?? defaultSampleSize;
+      if (size === null) {
+        throw new Error("Expected size");
+      }
+      const isFirstSample = i === 0;
+      const sampleFlags = sample.sampleFlags ? sample.sampleFlags : isFirstSample && trunBox.firstSampleFlags !== null ? trunBox.firstSampleFlags : defaultSampleFlags;
+      if (sampleFlags === null) {
+        throw new Error("Expected sample flags");
+      }
+      const keyframe = !(sampleFlags >> 16 & 1);
+      const dts = time + (tfdtBox?.baseMediaDecodeTime ?? 0);
+      const samplePosition = {
+        offset: offset + (moofOffset ?? 0) + (dataOffset ?? 0),
+        dts,
+        cts: dts,
+        duration: duration2,
+        isKeyframe: keyframe,
+        size,
+        chunk: 0
+      };
+      samples.push(samplePosition);
+      offset += size;
+      time += duration2;
+    }
+  }
+  return samples;
 };
-var getMdhdBox = (trakBox) => {
-  const mdiaBox = getMdiaBox(trakBox);
-  if (!mdiaBox) {
-    return null;
+var getSamplesFromMoof = ({
+  moofBox,
+  trackId
+}) => {
+  if (moofBox.type !== "regular-box") {
+    throw new Error("Expected moof-box");
   }
-  const mdhdBox = mdiaBox.children.find((c) => c.type === "mdhd-box");
-  return mdhdBox;
+  const trafs = moofBox.children.filter((c) => c.type === "regular-box" && c.boxType === "traf");
+  const mapped = trafs.map((traf) => {
+    const tfhdBox = getTfhdBox(traf);
+    return tfhdBox?.trackId === trackId ? getSamplesFromTraf(traf, moofBox.offset) : [];
+  });
+  return mapped.flat(1);
 };
-var getStblBox = (trakBox) => {
-  const mdiaBox = getMdiaBox(trakBox);
-  if (!mdiaBox) {
-    return null;
+
+// src/boxes/iso-base-media/get-sample-positions-from-track.ts
+var getSamplePositionsFromTrack = (trakBox, moofBox) => {
+  const stszBox = getStszBox(trakBox);
+  const stcoBox = getStcoBox(trakBox);
+  const stscBox = getStscBox(trakBox);
+  const stssBox = getStssBox(trakBox);
+  const sttsBox = getSttsBox(trakBox);
+  const tkhdBox = getTkhdBox(trakBox);
+  const cttsBox = getCttsBox(trakBox);
+  const timescaleAndDuration = getTimescaleAndDuration(trakBox);
+  if (!tkhdBox) {
+    throw new Error("Expected tkhd box in trak box");
   }
-  const minfBox = mdiaBox.children.find((s) => s.type === "regular-box" && s.boxType === "minf");
-  if (!minfBox || minfBox.type !== "regular-box") {
-    return null;
+  if (!stszBox) {
+    throw new Error("Expected stsz box in trak box");
   }
-  const stblBox = minfBox.children.find((s) => s.type === "regular-box" && s.boxType === "stbl");
-  if (!stblBox || stblBox.type !== "regular-box") {
-    return null;
+  if (!stcoBox) {
+    throw new Error("Expected stco box in trak box");
   }
-  return stblBox;
-};
-var getStsdBox = (trakBox) => {
-  const stblBox = getStblBox(trakBox);
-  if (!stblBox || stblBox.type !== "regular-box") {
-    return null;
+  if (!stscBox) {
+    throw new Error("Expected stsc box in trak box");
   }
-  const stsdBox = stblBox.children.find((s) => s.type === "stsd-box");
-  return stsdBox;
-};
-var getVideoDescriptors = (trakBox) => {
-  const stsdBox = getStsdBox(trakBox);
-  if (!stsdBox) {
-    return null;
+  if (!sttsBox) {
+    throw new Error("Expected stts box in trak box");
   }
-  const descriptors = stsdBox.samples.map((s) => {
-    return s.type === "video" ? s.descriptors.map((d) => {
-      return d.type === "avcc-box" ? d.privateData : d.type === "hvcc-box" ? d.privateData : null;
-    }) : [];
+  if (!timescaleAndDuration) {
+    throw new Error("Expected timescale and duration in trak box");
+  }
+  let samplePositions = getSamplePositions({
+    stcoBox,
+    stscBox,
+    stszBox,
+    stssBox,
+    sttsBox,
+    cttsBox
   });
-  return descriptors.flat(1).filter(Boolean)[0] ?? null;
-};
-var getStcoBox = (trakBox) => {
-  const stblBox = getStblBox(trakBox);
-  if (!stblBox || stblBox.type !== "regular-box") {
-    return null;
+  if (samplePositions.length === 0 && moofBox) {
+    samplePositions = getSamplesFromMoof({ moofBox, trackId: tkhdBox.trackId });
   }
-  const stcoBox = stblBox.children.find((s) => s.type === "stco-box");
-  return stcoBox;
+  return samplePositions;
 };
-var getSttsBox = (trakBox) => {
-  const stblBox = getStblBox(trakBox);
-  if (!stblBox || stblBox.type !== "regular-box") {
+
+// src/get-duration.ts
+var getDurationFromMatroska = (segments) => {
+  const mainSegment = segments.find((s) => s.type === "Segment");
+  if (!mainSegment || mainSegment.type !== "Segment") {
     return null;
   }
-  const sttsBox = stblBox.children.find((s) => s.type === "stts-box");
-  return sttsBox;
-};
-var getCttsBox = (trakBox) => {
-  const stblBox = getStblBox(trakBox);
-  if (!stblBox || stblBox.type !== "regular-box") {
+  const { value: children } = mainSegment;
+  if (!children) {
     return null;
   }
-  const cttsBox = stblBox.children.find((s) => s.type === "ctts-box");
-  return cttsBox;
-};
-var getStszBox = (trakBox) => {
-  const stblBox = getStblBox(trakBox);
-  if (!stblBox || stblBox.type !== "regular-box") {
+  const infoSegment = children.find((s) => s.type === "Info");
+  const relevantBoxes = [
+    ...mainSegment.value,
+    ...infoSegment && infoSegment.type === "Info" ? infoSegment.value : []
+  ];
+  const timestampScale2 = relevantBoxes.find((s) => s.type === "TimestampScale");
+  if (!timestampScale2 || timestampScale2.type !== "TimestampScale") {
     return null;
   }
-  const stszBox = stblBox.children.find((s) => s.type === "stsz-box");
-  return stszBox;
-};
-var getStscBox = (trakBox) => {
-  const stblBox = getStblBox(trakBox);
-  if (!stblBox || stblBox.type !== "regular-box") {
+  const duration2 = relevantBoxes.find((s) => s.type === "Duration");
+  if (!duration2 || duration2.type !== "Duration") {
     return null;
   }
-  const stcoBox = stblBox.children.find((b) => b.type === "stsc-box");
-  return stcoBox;
+  return duration2.value.value / timestampScale2.value.value * 1000;
 };
-var getStssBox = (trakBox) => {
-  const stblBox = getStblBox(trakBox);
-  if (!stblBox || stblBox.type !== "regular-box") {
-    return null;
-  }
-  const stssBox = stblBox.children.find((b) => b.type === "stss-box");
-  return stssBox;
+var isMatroska = (boxes) => {
+  const matroskaBox = boxes.find((b) => b.type === "Segment");
+  return matroskaBox;
 };
-var getTfdtBox = (segment) => {
-  if (segment.type !== "regular-box" || segment.boxType !== "traf") {
-    throw new Error("Expected traf-box");
+var getDuration = (boxes, parserState) => {
+  if (isMatroska(boxes)) {
+    return getDurationFromMatroska(boxes);
   }
-  const tfhdBox = segment.children.find((c) => c.type === "tfdt-box");
-  if (!tfhdBox || tfhdBox.type !== "tfdt-box") {
-    throw new Error("Expected tfhd-box");
+  const moovBox = getMoovBox(boxes);
+  if (!moovBox) {
+    return null;
   }
-  return tfhdBox;
-};
-var getTfhdBox = (segment) => {
-  if (segment.type !== "regular-box" || segment.boxType !== "traf") {
-    throw new Error("Expected traf-box");
+  const moofBox = getMoofBox(boxes);
+  const mvhdBox = getMvhdBox(moovBox);
+  if (!mvhdBox) {
+    return null;
   }
-  const tfhdBox = segment.children.find((c) => c.type === "tfhd-box");
-  if (!tfhdBox || tfhdBox.type !== "tfhd-box") {
-    throw new Error("Expected tfhd-box");
+  if (mvhdBox.type !== "mvhd-box") {
+    throw new Error("Expected mvhd-box");
   }
-  return tfhdBox;
-};
-var getTrunBoxes = (segment) => {
-  if (segment.type !== "regular-box" || segment.boxType !== "traf") {
-    throw new Error("Expected traf-box");
+  if (mvhdBox.durationInSeconds > 0) {
+    return mvhdBox.durationInSeconds;
   }
-  const trunBoxes = segment.children.filter((c) => c.type === "trun-box");
-  return trunBoxes;
+  const tracks2 = getTracks(boxes, parserState);
+  const allTracks = [
+    ...tracks2.videoTracks,
+    ...tracks2.audioTracks,
+    ...tracks2.otherTracks
+  ];
+  const allSamples = allTracks.map((t) => {
+    const { timescale: ts } = t;
+    const samplePositions = getSamplePositionsFromTrack(t.trakBox, moofBox);
+    const highest = samplePositions?.map((sp) => (sp.cts + sp.duration) / ts).reduce((a, b) => Math.max(a, b), 0);
+    return highest ?? 0;
+  });
+  const highestTimestamp = Math.max(...allSamples);
+  return highestTimestamp;
 };
-var getMdatBox = (anySegment) => {
-  const mdat = anySegment.find((b) => b.type === "mdat-box");
-  if (!mdat) {
-    return null;
-  }
-  if (mdat.type !== "mdat-box") {
-    throw new Error("Expected mdat-box");
+var hasDuration = (boxes, parserState) => {
+  try {
+    const duration2 = getDuration(boxes, parserState);
+    return getDuration(boxes, parserState) !== null && duration2 !== 0;
+  } catch {
+    return false;
   }
-  return mdat;
 };
 
 // src/get-fps.ts
@@ -2227,21 +3570,12 @@ var getTimescaleAndDuration = (trakBox) => {
   }
   return null;
 };
-var getFps = (segments) => {
-  const moovBox = getMoovBox(segments);
-  if (!moovBox) {
-    return null;
-  }
-  const trackBoxes = getTraks(moovBox);
-  const trackBox = trackBoxes.find(trakBoxContainsVideo);
-  if (!trackBox) {
-    return null;
-  }
-  const timescaleAndDuration = getTimescaleAndDuration(trackBox);
+var getFpsFromMp4TrakBox = (trakBox) => {
+  const timescaleAndDuration = getTimescaleAndDuration(trakBox);
   if (!timescaleAndDuration) {
     return null;
   }
-  const sttsBox = getSttsBox(trackBox);
+  const sttsBox = getSttsBox(trakBox);
   if (!sttsBox) {
     return null;
   }
@@ -2251,8 +3585,23 @@ var getFps = (segments) => {
     durationInSamples: timescaleAndDuration.duration
   });
 };
+var getFps = (segments) => {
+  const moovBox = getMoovBox(segments);
+  if (!moovBox) {
+    return null;
+  }
+  const trackBoxes = getTraks(moovBox);
+  const trackBox = trackBoxes.find(trakBoxContainsVideo);
+  if (!trackBox) {
+    return null;
+  }
+  return getFpsFromMp4TrakBox(trackBox);
+};
 var hasFps = (boxes) => {
   try {
+    if (isMatroska(boxes)) {
+      return true;
+    }
     return getFps(boxes) !== null;
   } catch {
     return false;
@@ -2275,12 +3624,8 @@ var getAudioCodec = (boxes, parserState) => {
   }
   return null;
 };
-var hasAudioCodec = (boxes, state) => {
-  try {
-    return getAudioCodec(boxes, state) !== null;
-  } catch {
-    return false;
-  }
+var hasAudioCodec = (boxes) => {
+  return hasTracks(boxes);
 };
 var getCodecSpecificatorFromEsdsBox = ({
   child
@@ -2300,9 +3645,9 @@ var getCodecSpecificatorFromEsdsBox = ({
     };
   }
   const audioSpecificConfig = descriptor.decoderSpecificConfigs.find((d) => {
-    return d.type === "audio-specific-config" ? d : null;
+    return d.type === "mp4a-specific-config" ? d : null;
   });
-  if (!audioSpecificConfig || audioSpecificConfig.type !== "audio-specific-config") {
+  if (!audioSpecificConfig || audioSpecificConfig.type !== "mp4a-specific-config") {
     throw new Error("No audio-specific-config");
   }
   return {
@@ -2311,6 +3656,29 @@ var getCodecSpecificatorFromEsdsBox = ({
     description: audioSpecificConfig.asBytes
   };
 };
+var getCodecPrivateFromTrak = (trakBox) => {
+  const stsdBox = getStsdBox(trakBox);
+  if (!stsdBox) {
+    return null;
+  }
+  const audioSample = stsdBox.samples.find((s) => s.type === "audio");
+  if (!audioSample || audioSample.type !== "audio") {
+    return null;
+  }
+  const esds = audioSample.children.find((b) => b.type === "esds-box");
+  if (!esds || esds.type !== "esds-box") {
+    return null;
+  }
+  const decoderConfigDescriptor = esds.descriptors.find((d) => d.type === "decoder-config-descriptor");
+  if (!decoderConfigDescriptor) {
+    return null;
+  }
+  const mp4a = decoderConfigDescriptor.decoderSpecificConfigs.find((d) => d.type === "mp4a-specific-config");
+  if (!mp4a) {
+    return null;
+  }
+  return mp4a.asBytes;
+};
 var onSample = (sample, children) => {
   const child = children.find((c) => c.type === "esds-box");
   if (child && child.type === "esds-box") {
@@ -2651,18 +4019,11 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
       getUint8(),
       getUint8(),
       getUint8(),
-      getUint8()
-    ]);
-    return Number(bigInt);
-  };
-  const getFourByteNumber = (littleEndian = false) => {
-    if (littleEndian) {
-      const one = getUint8();
-      const two = getUint8();
-      const three = getUint8();
-      const four = getUint8();
-      return four << 24 | three << 16 | two << 8 | one;
-    }
+      getUint8()
+    ]);
+    return Number(bigInt);
+  };
+  const getFourByteNumber = () => {
     return getUint8() << 24 | getUint8() << 16 | getUint8() << 8 | getUint8();
   };
   const getPaddedFourByteNumber = () => {
@@ -3016,7 +4377,7 @@ var parseAv1PrivateData = (data, colrAtom) => {
   const chroma_sample_position = iterator.getBits(2);
   str += subsampling_x && subsampling_y ? chroma_sample_position === 1 ? "1" : "0" : "0";
   str += ".";
-  if (colrAtom) {
+  if (colrAtom && colrAtom.colorType === "transfer-characteristics") {
     str += colrAtom.primaries.toString().padStart(2, "0");
     str += ".";
     str += colrAtom.transfer.toString().padStart(2, "0");
@@ -3125,11 +4486,7 @@ var getVideoCodec = (boxes) => {
   return null;
 };
 var hasVideoCodec = (boxes) => {
-  try {
-    return getVideoCodec(boxes) !== null;
-  } catch {
-    return false;
-  }
+  return hasTracks(boxes);
 };
 var getVideoPrivateData = (trakBox) => {
   const videoSample = getStsdVideoConfig(trakBox);
@@ -3159,6 +4516,9 @@ var getIsoBmColrConfig = (trakBox) => {
   if (!colrAtom) {
     return null;
   }
+  if (colrAtom.colorType !== "transfer-characteristics") {
+    return null;
+  }
   return {
     fullRange: colrAtom.fullRangeFlag,
     matrixCoefficients: colrAtom.matrixIndex === 1 ? "bt709" : colrAtom.matrixIndex === 5 ? "bt470bg" : colrAtom.matrixIndex === 6 ? "smpte170m" : null,
@@ -3217,7 +4577,7 @@ var makeBaseMediaTrack = (trakBox) => {
       sampleRate,
       description,
       trakBox,
-      codecPrivate: null,
+      codecPrivate: getCodecPrivateFromTrak(trakBox),
       codecWithoutConfig: getAudioCodecFromTrack(trakBox)
     };
   }
@@ -3270,7 +4630,8 @@ var makeBaseMediaTrack = (trakBox) => {
       primaries: null,
       transferCharacteristics: null
     },
-    codecWithoutConfig: getVideoCodecFromIsoTrak(trakBox)
+    codecWithoutConfig: getVideoCodecFromIsoTrak(trakBox),
+    fps: getFpsFromMp4TrakBox(trakBox)
   };
   return track;
 };
@@ -3534,7 +4895,7 @@ var getMatroskaAudioCodecString = (track) => {
   throw new Error(`Unknown codec: ${codec.value}`);
 };
 var getTrack = ({
-  timescale,
+  timescale: timescale2,
   track
 }) => {
   const trackType2 = getTrackTypeSegment(track);
@@ -3577,7 +4938,7 @@ var getTrack = ({
         numerator: 1,
         denominator: 1
       },
-      timescale,
+      timescale: timescale2,
       codedHeight: height.value.value,
       codedWidth: width.value.value,
       displayAspectHeight: displayHeight2 ? displayHeight2.value.value : height.value.value,
@@ -3593,7 +4954,8 @@ var getTrack = ({
       },
       codecWithoutConfig: getMatroskaVideoCodecWithoutConfigString({
         codecSegment: codec
-      })
+      }),
+      fps: null
     };
   }
   if (trackTypeToString(trackType2.value.value) === "audio") {
@@ -3607,7 +4969,7 @@ var getTrack = ({
       type: "audio",
       trackId,
       codec: getMatroskaAudioCodecString(track),
-      timescale,
+      timescale: timescale2,
       numberOfChannels,
       sampleRate,
       description: getAudioDescription(track),
@@ -3622,7 +4984,7 @@ var getTrack = ({
 };
 
 // src/boxes/webm/get-ready-tracks.ts
-var getTracksFromMatroska = (segment, timescale) => {
+var getTracksFromMatroska = (segment, timescale2) => {
   const tracksSegment = getTracksSegment(segment);
   if (!tracksSegment) {
     throw new Error("No tracks segment");
@@ -3637,7 +4999,7 @@ var getTracksFromMatroska = (segment, timescale) => {
     }
     const track = getTrack({
       track: trackEntrySegment,
-      timescale
+      timescale: timescale2
     });
     if (track) {
       tracks2.push(track);
@@ -3761,239 +5123,6 @@ var hasDimensions = (boxes, state) => {
   }
 };
 
-// src/get-sample-positions.ts
-var getSamplePositions = ({
-  stcoBox,
-  stszBox,
-  stscBox,
-  stssBox,
-  sttsBox,
-  cttsBox
-}) => {
-  const sttsDeltas = [];
-  for (const distribution of sttsBox.sampleDistribution) {
-    for (let i = 0;i < distribution.sampleCount; i++) {
-      sttsDeltas.push(distribution.sampleDelta);
-    }
-  }
-  const cttsEntries = [];
-  for (const entry of cttsBox?.entries ?? [
-    { sampleCount: sttsDeltas.length, sampleOffset: 0 }
-  ]) {
-    for (let i = 0;i < entry.sampleCount; i++) {
-      cttsEntries.push(entry.sampleOffset);
-    }
-  }
-  let dts = 0;
-  const chunks = stcoBox.entries;
-  const samples = [];
-  let samplesPerChunk = 1;
-  for (let i = 0;i < chunks.length; i++) {
-    const hasEntry = stscBox.entries.find((entry) => entry.firstChunk === i + 1);
-    if (hasEntry) {
-      samplesPerChunk = hasEntry.samplesPerChunk;
-    }
-    let offsetInThisChunk = 0;
-    for (let j = 0;j < samplesPerChunk; j++) {
-      const size = stszBox.countType === "fixed" ? stszBox.sampleSize : stszBox.entries[samples.length];
-      const isKeyframe = stssBox ? stssBox.sampleNumber.includes(samples.length + 1) : true;
-      const delta = sttsDeltas[samples.length];
-      const ctsOffset = cttsEntries[samples.length];
-      const cts = dts + ctsOffset;
-      samples.push({
-        offset: Number(chunks[i]) + offsetInThisChunk,
-        size,
-        isKeyframe,
-        dts,
-        cts,
-        duration: delta
-      });
-      dts += delta;
-      offsetInThisChunk += size;
-    }
-  }
-  return samples;
-};
-
-// src/samples-from-moof.ts
-var getSamplesFromTraf = (trafSegment, moofOffset) => {
-  if (trafSegment.type !== "regular-box" || trafSegment.boxType !== "traf") {
-    throw new Error("Expected traf-box");
-  }
-  const tfhdBox = getTfhdBox(trafSegment);
-  const defaultSampleDuration = tfhdBox?.defaultSampleDuration ?? null;
-  const defaultSampleSize = tfhdBox?.defaultSampleSize ?? null;
-  const defaultSampleFlags = tfhdBox?.defaultSampleFlags ?? null;
-  const tfdtBox = getTfdtBox(trafSegment);
-  const trunBoxes = getTrunBoxes(trafSegment);
-  let time = 0;
-  let offset = 0;
-  let dataOffset = 0;
-  const samples = [];
-  for (const trunBox of trunBoxes) {
-    let i = -1;
-    if (trunBox.dataOffset) {
-      dataOffset = trunBox.dataOffset;
-      offset = 0;
-    }
-    for (const sample of trunBox.samples) {
-      i++;
-      const duration2 = sample.sampleDuration ?? defaultSampleDuration;
-      if (duration2 === null) {
-        throw new Error("Expected duration");
-      }
-      const size = sample.sampleSize ?? defaultSampleSize;
-      if (size === null) {
-        throw new Error("Expected size");
-      }
-      const isFirstSample = i === 0;
-      const sampleFlags = sample.sampleFlags ? sample.sampleFlags : isFirstSample && trunBox.firstSampleFlags !== null ? trunBox.firstSampleFlags : defaultSampleFlags;
-      if (sampleFlags === null) {
-        throw new Error("Expected sample flags");
-      }
-      const keyframe = !(sampleFlags >> 16 & 1);
-      const dts = time + (tfdtBox?.baseMediaDecodeTime ?? 0);
-      const samplePosition = {
-        offset: offset + (moofOffset ?? 0) + (dataOffset ?? 0),
-        dts,
-        cts: dts,
-        duration: duration2,
-        isKeyframe: keyframe,
-        size
-      };
-      samples.push(samplePosition);
-      offset += size;
-      time += duration2;
-    }
-  }
-  return samples;
-};
-var getSamplesFromMoof = ({
-  moofBox,
-  trackId
-}) => {
-  if (moofBox.type !== "regular-box") {
-    throw new Error("Expected moof-box");
-  }
-  const trafs = moofBox.children.filter((c) => c.type === "regular-box" && c.boxType === "traf");
-  const mapped = trafs.map((traf) => {
-    const tfhdBox = getTfhdBox(traf);
-    return tfhdBox?.trackId === trackId ? getSamplesFromTraf(traf, moofBox.offset) : [];
-  });
-  return mapped.flat(1);
-};
-
-// src/boxes/iso-base-media/get-sample-positions-from-track.ts
-var getSamplePositionsFromTrack = (trakBox, moofBox) => {
-  const stszBox = getStszBox(trakBox);
-  const stcoBox = getStcoBox(trakBox);
-  const stscBox = getStscBox(trakBox);
-  const stssBox = getStssBox(trakBox);
-  const sttsBox = getSttsBox(trakBox);
-  const tkhdBox = getTkhdBox(trakBox);
-  const cttsBox = getCttsBox(trakBox);
-  const timescaleAndDuration = getTimescaleAndDuration(trakBox);
-  if (!tkhdBox) {
-    throw new Error("Expected tkhd box in trak box");
-  }
-  if (!stszBox) {
-    throw new Error("Expected stsz box in trak box");
-  }
-  if (!stcoBox) {
-    throw new Error("Expected stco box in trak box");
-  }
-  if (!stscBox) {
-    throw new Error("Expected stsc box in trak box");
-  }
-  if (!sttsBox) {
-    throw new Error("Expected stts box in trak box");
-  }
-  if (!timescaleAndDuration) {
-    throw new Error("Expected timescale and duration in trak box");
-  }
-  let samplePositions = getSamplePositions({
-    stcoBox,
-    stscBox,
-    stszBox,
-    stssBox,
-    sttsBox,
-    cttsBox
-  });
-  if (samplePositions.length === 0 && moofBox) {
-    samplePositions = getSamplesFromMoof({ moofBox, trackId: tkhdBox.trackId });
-  }
-  return samplePositions;
-};
-
-// src/get-duration.ts
-var getDurationFromMatroska = (segments) => {
-  const mainSegment = segments.find((s) => s.type === "Segment");
-  if (!mainSegment || mainSegment.type !== "Segment") {
-    return null;
-  }
-  const { value: children } = mainSegment;
-  if (!children) {
-    return null;
-  }
-  const infoSegment = children.find((s) => s.type === "Info");
-  const relevantBoxes = [
-    ...mainSegment.value,
-    ...infoSegment && infoSegment.type === "Info" ? infoSegment.value : []
-  ];
-  const timestampScale2 = relevantBoxes.find((s) => s.type === "TimestampScale");
-  if (!timestampScale2 || timestampScale2.type !== "TimestampScale") {
-    return null;
-  }
-  const duration2 = relevantBoxes.find((s) => s.type === "Duration");
-  if (!duration2 || duration2.type !== "Duration") {
-    return null;
-  }
-  return duration2.value.value / timestampScale2.value.value * 1000;
-};
-var getDuration = (boxes, parserState) => {
-  const matroskaBox = boxes.find((b) => b.type === "Segment");
-  if (matroskaBox) {
-    return getDurationFromMatroska(boxes);
-  }
-  const moovBox = getMoovBox(boxes);
-  if (!moovBox) {
-    return null;
-  }
-  const moofBox = getMoofBox(boxes);
-  const mvhdBox = getMvhdBox(moovBox);
-  if (!mvhdBox) {
-    return null;
-  }
-  if (mvhdBox.type !== "mvhd-box") {
-    throw new Error("Expected mvhd-box");
-  }
-  if (mvhdBox.durationInSeconds > 0) {
-    return mvhdBox.durationInSeconds;
-  }
-  const tracks2 = getTracks(boxes, parserState);
-  const allTracks = [
-    ...tracks2.videoTracks,
-    ...tracks2.audioTracks,
-    ...tracks2.otherTracks
-  ];
-  const allSamples = allTracks.map((t) => {
-    const { timescale: ts } = t;
-    const samplePositions = getSamplePositionsFromTrack(t.trakBox, moofBox);
-    const highest = samplePositions?.map((sp) => (sp.cts + sp.duration) / ts).reduce((a, b) => Math.max(a, b), 0);
-    return highest ?? 0;
-  });
-  const highestTimestamp = Math.max(...allSamples);
-  return highestTimestamp;
-};
-var hasDuration = (boxes, parserState) => {
-  try {
-    const duration2 = getDuration(boxes, parserState);
-    return getDuration(boxes, parserState) !== null && duration2 !== 0;
-  } catch {
-    return false;
-  }
-};
-
 // src/emit-available-info.ts
 var emitAvailableInfo = ({
   hasInfo,
@@ -4007,14 +5136,14 @@ var emitAvailableInfo = ({
   const keys = Object.keys(hasInfo);
   for (const key of keys) {
     if (key === "boxes") {
-      if (hasInfo.boxes && returnValue.boxes === undefined) {
+      if (parseResult && hasInfo.boxes && returnValue.boxes === undefined) {
         moreFields.onBoxes?.(parseResult.segments);
         returnValue.boxes = parseResult.segments;
       }
       continue;
     }
     if (key === "durationInSeconds") {
-      if (hasInfo.durationInSeconds && returnValue.durationInSeconds === undefined) {
+      if (hasInfo.durationInSeconds && returnValue.durationInSeconds === undefined && parseResult) {
         const durationInSeconds = getDuration(parseResult.segments, state);
         moreFields.onDurationInSeconds?.(durationInSeconds);
         returnValue.durationInSeconds = durationInSeconds;
@@ -4022,7 +5151,7 @@ var emitAvailableInfo = ({
       continue;
     }
     if (key === "dimensions") {
-      if (hasInfo.dimensions && returnValue.dimensions === undefined) {
+      if (hasInfo.dimensions && returnValue.dimensions === undefined && parseResult) {
         const dimensionsQueried = getDimensions(parseResult.segments, state);
         const dimensions = {
           height: dimensionsQueried.height,
@@ -4034,7 +5163,7 @@ var emitAvailableInfo = ({
       continue;
     }
     if (key === "unrotatedDimensions") {
-      if (returnValue.unrotatedDimensions === undefined && hasInfo.unrotatedDimensions) {
+      if (returnValue.unrotatedDimensions === undefined && hasInfo.unrotatedDimensions && parseResult) {
         const dimensionsQueried = getDimensions(parseResult.segments, state);
         const unrotatedDimensions = {
           height: dimensionsQueried.unrotatedHeight,
@@ -4046,7 +5175,7 @@ var emitAvailableInfo = ({
       continue;
     }
     if (key === "rotation") {
-      if (returnValue.rotation === undefined && hasInfo.rotation) {
+      if (returnValue.rotation === undefined && hasInfo.rotation && parseResult) {
         const dimensionsQueried = getDimensions(parseResult.segments, state);
         const { rotation } = dimensionsQueried;
         moreFields.onRotation?.(rotation);
@@ -4055,7 +5184,7 @@ var emitAvailableInfo = ({
       continue;
     }
     if (key === "fps") {
-      if (returnValue.fps === undefined && hasInfo.fps) {
+      if (returnValue.fps === undefined && hasInfo.fps && parseResult) {
         const fps = getFps(parseResult.segments);
         moreFields.onFps?.(fps);
         returnValue.fps = fps;
@@ -4063,7 +5192,7 @@ var emitAvailableInfo = ({
       continue;
     }
     if (key === "videoCodec") {
-      if (returnValue.videoCodec === undefined && hasInfo.videoCodec) {
+      if (returnValue.videoCodec === undefined && hasInfo.videoCodec && parseResult) {
         const videoCodec = getVideoCodec(parseResult.segments);
         moreFields.onVideoCodec?.(videoCodec);
         returnValue.videoCodec = videoCodec;
@@ -4071,7 +5200,7 @@ var emitAvailableInfo = ({
       continue;
     }
     if (key === "audioCodec") {
-      if (returnValue.audioCodec === undefined && hasInfo.audioCodec) {
+      if (returnValue.audioCodec === undefined && hasInfo.audioCodec && parseResult) {
         const audioCodec = getAudioCodec(parseResult.segments, state);
         moreFields.onAudioCodec?.(audioCodec);
         returnValue.audioCodec = audioCodec;
@@ -4079,7 +5208,7 @@ var emitAvailableInfo = ({
       continue;
     }
     if (key === "tracks") {
-      if (hasInfo.tracks && returnValue.videoTracks === undefined && returnValue.audioTracks === undefined) {
+      if (hasInfo.tracks && returnValue.videoTracks === undefined && returnValue.audioTracks === undefined && parseResult) {
         const { videoTracks, audioTracks } = getTracks(parseResult.segments, state);
         moreFields.onTracks?.({ videoTracks, audioTracks });
         returnValue.videoTracks = videoTracks;
@@ -4110,7 +5239,7 @@ var emitAvailableInfo = ({
       continue;
     }
     if (key === "container") {
-      if (returnValue.container === undefined && hasInfo.container) {
+      if (returnValue.container === undefined && hasInfo.container && parseResult) {
         const container = getContainer(parseResult.segments);
         moreFields.onContainer?.(container);
         returnValue.container = container;
@@ -4126,25 +5255,25 @@ var getAvailableInfo = (options, parseResult, state) => {
   const keys = Object.entries(options).filter(([, value]) => value);
   const infos = keys.map(([key]) => {
     if (key === "boxes") {
-      return parseResult.status === "done";
+      return Boolean(parseResult && parseResult.status === "done");
     }
     if (key === "durationInSeconds") {
-      return hasDuration(parseResult.segments, state);
+      return Boolean(parseResult && hasDuration(parseResult.segments, state));
     }
     if (key === "dimensions" || key === "rotation" || key === "unrotatedDimensions") {
-      return hasDimensions(parseResult.segments, state);
+      return Boolean(parseResult && hasDimensions(parseResult.segments, state));
     }
     if (key === "fps") {
-      return hasFps(parseResult.segments);
+      return Boolean(parseResult && hasFps(parseResult.segments));
     }
     if (key === "videoCodec") {
-      return hasVideoCodec(parseResult.segments);
+      return Boolean(parseResult && hasVideoCodec(parseResult.segments));
     }
     if (key === "audioCodec") {
-      return hasAudioCodec(parseResult.segments, state);
+      return Boolean(parseResult && hasAudioCodec(parseResult.segments));
     }
     if (key === "tracks") {
-      return hasTracks(parseResult.segments);
+      return Boolean(parseResult && hasTracks(parseResult.segments));
     }
     if (key === "internalStats") {
       return false;
@@ -4156,7 +5285,7 @@ var getAvailableInfo = (options, parseResult, state) => {
       return true;
     }
     if (key === "container") {
-      return hasContainer(parseResult.segments);
+      return Boolean(parseResult && hasContainer(parseResult.segments));
     }
     throw new Error(`Unknown key: ${key}`);
   });
@@ -4169,7 +5298,7 @@ var getAvailableInfo = (options, parseResult, state) => {
 };
 
 // src/boxes/iso-base-media/esds/decoder-specific-config.ts
-var parseDecoderSpecificConfig = (iterator) => {
+var parseDecoderSpecificConfig = (iterator, logLevel) => {
   const layerTag = iterator.getUint8();
   const layerSize = iterator.getPaddedFourByteNumber();
   const start = iterator.counter.getOffset();
@@ -4193,13 +5322,15 @@ var parseDecoderSpecificConfig = (iterator) => {
   if (read < layerSize) {
     iterator.discard(layerSize - read);
   }
-  const patchedAsBytes = bytes.byteLength === 2 && bytes[0] === 17 && bytes[1] === 136 ? new Uint8Array([17, 144]) : bytes;
+  if (bytes.byteLength === 2 && bytes[0] === 17 && bytes[1] === 136) {
+    Log.warn(logLevel, "Chrome has a bug and might not be able to decode this audio. It will be fixed, see: https://issues.chromium.org/issues/360083330");
+  }
   return {
-    type: "audio-specific-config",
+    type: "mp4a-specific-config",
     audioObjectType,
     samplingFrequencyIndex,
     channelConfiguration,
-    asBytes: patchedAsBytes
+    asBytes: bytes
   };
 };
 
@@ -4214,7 +5345,8 @@ var mapToObjectAudioIndicator = (num) => {
   return "unknown";
 };
 var processDescriptor = ({
-  iterator
+  iterator,
+  logLevel
 }) => {
   const tag = iterator.getUint8();
   if (tag === 4) {
@@ -4230,8 +5362,8 @@ var processDescriptor = ({
     const maxBitrate = iterator.getUint32();
     const avgBitrate = iterator.getUint32();
     const decoderSpecificConfigs = [];
-    while (size - (iterator.counter.getOffset() - initialOffset) >= 0) {
-      const decoderSpecificConfig = parseDecoderSpecificConfig(iterator);
+    while (size - (iterator.counter.getOffset() - initialOffset) > 0) {
+      const decoderSpecificConfig = parseDecoderSpecificConfig(iterator, logLevel);
       decoderSpecificConfigs.push(decoderSpecificConfig);
     }
     return {
@@ -4261,12 +5393,13 @@ var processDescriptor = ({
     descriptor: null
   };
 };
-var parseDescriptors = (iterator, maxBytes) => {
+var parseDescriptors = (iterator, maxBytes, logLevel) => {
   const descriptors = [];
   const initialOffset = iterator.counter.getOffset();
   while (iterator.bytesRemaining() > 0 && iterator.counter.getOffset() - initialOffset < maxBytes) {
     const { descriptor } = processDescriptor({
-      iterator
+      iterator,
+      logLevel
     });
     if (descriptor) {
       descriptors.push(descriptor);
@@ -4281,7 +5414,8 @@ var parseDescriptors = (iterator, maxBytes) => {
 var parseEsds = ({
   data,
   size,
-  fileOffset
+  fileOffset,
+  logLevel
 }) => {
   const version = data.getUint8();
   data.discard(3);
@@ -4290,7 +5424,7 @@ var parseEsds = ({
   const esId = data.getUint16();
   data.discard(1);
   const remaining = size - (data.counter.getOffset() - fileOffset);
-  const descriptors = parseDescriptors(data, remaining);
+  const descriptors = parseDescriptors(data, remaining, logLevel);
   const remainingNow = size - (data.counter.getOffset() - fileOffset);
   data.discard(remainingNow);
   return {
@@ -4397,15 +5531,19 @@ var parseMdat = async ({
       break;
     }
     const bytes = data.getSlice(samplesWithIndex.samplePosition.size);
-    const timestamp = Math.floor(samplesWithIndex.samplePosition.cts * 1e6 / samplesWithIndex.track.timescale);
-    const duration2 = Math.floor(samplesWithIndex.samplePosition.duration * 1e6 / samplesWithIndex.track.timescale);
+    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;
     if (samplesWithIndex.track.type === "audio") {
       await options.parserState.onAudioSample(samplesWithIndex.track.trackId, {
         data: bytes,
         timestamp,
+        duration: duration2,
+        cts,
+        dts,
         trackId: samplesWithIndex.track.trackId,
-        type: samplesWithIndex.samplePosition.isKeyframe ? "key" : "delta",
-        duration: duration2
+        type: samplesWithIndex.samplePosition.isKeyframe ? "key" : "delta"
       });
     }
     if (samplesWithIndex.track.type === "video") {
@@ -4413,8 +5551,8 @@ var parseMdat = async ({
         data: bytes,
         timestamp,
         duration: duration2,
-        cts: samplesWithIndex.samplePosition.cts,
-        dts: samplesWithIndex.samplePosition.dts,
+        cts,
+        dts,
         trackId: samplesWithIndex.track.trackId,
         type: samplesWithIndex.samplePosition.isKeyframe ? "key" : "delta"
       });
@@ -4443,7 +5581,7 @@ var parseMdhd = ({
   data.discard(3);
   const creationTime = version === 1 ? Number(data.getUint64()) : data.getUint32();
   const modificationTime = version === 1 ? Number(data.getUint64()) : data.getUint32();
-  const timescale = data.getUint32();
+  const timescale2 = data.getUint32();
   const duration2 = version === 1 ? data.getUint64() : data.getUint32();
   const language2 = data.getUint16();
   const quality = data.getUint16();
@@ -4454,7 +5592,7 @@ var parseMdhd = ({
   return {
     type: "mdhd-box",
     duration: Number(duration2),
-    timescale,
+    timescale: timescale2,
     version,
     language: language2,
     quality,
@@ -4469,7 +5607,8 @@ var parseMoov = async ({
   offset,
   size,
   options,
-  signal
+  signal,
+  logLevel
 }) => {
   const children = await parseBoxes({
     iterator,
@@ -4478,8 +5617,8 @@ var parseMoov = async ({
     initialBoxes: [],
     options,
     continueMdat: false,
-    littleEndian: false,
-    signal
+    signal,
+    logLevel
   });
   if (children.status === "incomplete") {
     throw new Error("Incomplete boxes are not allowed");
@@ -4492,15 +5631,6 @@ var parseMoov = async ({
   };
 };
 
-// src/boxes/iso-base-media/to-date.ts
-var toUnixTimestamp = (value) => {
-  if (value === 0) {
-    return null;
-  }
-  const baseDate = new Date("1904-01-01T00:00:00Z");
-  return Math.floor(value + baseDate.getTime() / 1000) * 1000;
-};
-
 // src/boxes/iso-base-media/mvhd.ts
 var parseMvhd = ({
   iterator,
@@ -4523,14 +5653,17 @@ var parseMvhd = ({
   iterator.discard(2);
   iterator.discard(4);
   iterator.discard(4);
-  const matrix = [];
-  for (let i = 0;i < 9; i++) {
-    if (i % 3 === 2) {
-      matrix.push(iterator.getFixedPointSigned230Number());
-    } else {
-      matrix.push(iterator.getFixedPointSigned1616Number());
-    }
-  }
+  const matrix = [
+    iterator.getFixedPointSigned1616Number(),
+    iterator.getFixedPointSigned1616Number(),
+    iterator.getFixedPointSigned230Number(),
+    iterator.getFixedPointSigned1616Number(),
+    iterator.getFixedPointSigned1616Number(),
+    iterator.getFixedPointSigned230Number(),
+    iterator.getFixedPointSigned1616Number(),
+    iterator.getFixedPointSigned1616Number(),
+    iterator.getFixedPointSigned230Number()
+  ];
   iterator.discard(4 * 6);
   const nextTrackId = iterator.getUint32();
   volumeView.destroy();
@@ -4587,9 +5720,115 @@ var parseAvcc = ({
   };
 };
 
+// src/boxes/iso-base-media/parse-icc-profile.ts
+var parseIccProfile = (data) => {
+  const iterator = getArrayBufferIterator(data, Infinity);
+  const size = iterator.getUint32();
+  if (size !== data.length) {
+    throw new Error("Invalid ICC profile size");
+  }
+  const preferredCMMType = iterator.getByteString(4);
+  const profileVersion = iterator.getByteString(4);
+  const profileDeviceClass = iterator.getByteString(4);
+  const colorSpace = iterator.getByteString(4);
+  const pcs = iterator.getByteString(4);
+  const dateTime = iterator.getSlice(12);
+  const signature = iterator.getByteString(4);
+  if (signature !== "acsp") {
+    throw new Error("Invalid ICC profile signature");
+  }
+  const primaryPlatform = iterator.getByteString(4);
+  const profileFlags = iterator.getUint32();
+  const deviceManufacturer = iterator.getByteString(4);
+  const deviceModel = iterator.getByteString(4);
+  const deviceAttributes = iterator.getUint64();
+  const renderingIntent = iterator.getUint32();
+  const pcsIlluminant1 = iterator.getUint32();
+  const pcsIlluminant2 = iterator.getUint32();
+  const pcsIlluminant3 = iterator.getUint32();
+  const profileCreator = iterator.getByteString(4);
+  const profileId = iterator.getByteString(16);
+  iterator.discard(28);
+  const tagCount = iterator.getUint32();
+  const entries = [];
+  for (let i = 0;i < tagCount; i++) {
+    const entry = {
+      tag: iterator.getByteString(4),
+      offset: iterator.getUint32(),
+      size: iterator.getUint32()
+    };
+    entries.push(entry);
+  }
+  let lastOffset = -1;
+  let rXYZ = null;
+  let gXYZ = null;
+  let bXYZ = null;
+  let whitePoint = null;
+  for (const entry of entries) {
+    const found = data.slice(entry.offset, entry.offset + entry.size);
+    if (entry.tag === "rXYZ" || entry.tag === "gXYZ" || entry.tag === "bXYZ" || entry.tag === "wtpt") {
+      const it = getArrayBufferIterator(found, Infinity);
+      it.discard(4);
+      const x = it.getInt32() / 65536;
+      const y = it.getInt32() / 65536;
+      const z = it.getInt32() / 65536;
+      it.destroy();
+      const point = { x, y, z };
+      if (entry.tag === "rXYZ") {
+        rXYZ = point;
+      } else if (entry.tag === "gXYZ") {
+        gXYZ = point;
+      } else if (entry.tag === "bXYZ") {
+        bXYZ = point;
+      } else if (entry.tag === "wtpt") {
+        whitePoint = point;
+      }
+    }
+    if (lastOffset !== -1) {
+      const bytesToAdvance = entry.offset - lastOffset;
+      const bytesToGoBackwards = entry.size - bytesToAdvance;
+      if (bytesToGoBackwards > 0) {
+        iterator.counter.decrement(bytesToGoBackwards);
+      }
+    }
+    lastOffset = entry.offset;
+  }
+  const profile = {
+    size,
+    preferredCMMType,
+    profileVersion,
+    profileDeviceClass,
+    colorSpace,
+    pcs,
+    dateTime,
+    signature,
+    primaryPlatform,
+    profileFlags,
+    deviceManufacturer,
+    deviceModel,
+    deviceAttributes,
+    renderingIntent,
+    pcsIlluminant: [
+      pcsIlluminant1 / 65536,
+      pcsIlluminant2 / 65536,
+      pcsIlluminant3 / 65536
+    ],
+    profileCreator,
+    profileId,
+    entries,
+    bXYZ,
+    gXYZ,
+    rXYZ,
+    whitePoint
+  };
+  iterator.destroy();
+  return profile;
+};
+
 // src/boxes/iso-base-media/stsd/colr.ts
 var parseColorParameterBox = ({
-  iterator
+  iterator,
+  size
 }) => {
   const byteString = iterator.getByteString(4);
   if (byteString === "nclx") {
@@ -4601,6 +5840,7 @@ var parseColorParameterBox = ({
     iterator.stopReadingBits();
     return {
       type: "colr-box",
+      colorType: "transfer-characteristics",
       fullRangeFlag,
       matrixIndex,
       primaries: primaries2,
@@ -4613,12 +5853,22 @@ var parseColorParameterBox = ({
     const matrixIndex = iterator.getUint16();
     return {
       type: "colr-box",
+      colorType: "transfer-characteristics",
       fullRangeFlag: false,
       matrixIndex,
       primaries: primaries2,
       transfer
     };
   }
+  if (byteString === "prof") {
+    const profile = iterator.getSlice(size - 12);
+    return {
+      type: "colr-box",
+      colorType: "icc-profile",
+      profile,
+      parsed: parseIccProfile(profile)
+    };
+  }
   throw new Error("Unexpected box type " + byteString);
 };
 
@@ -4678,7 +5928,6 @@ var parseMebx = async ({
   offset,
   size,
   options,
-  littleEndian,
   signal
 }) => {
   iterator.discard(6);
@@ -4690,8 +5939,8 @@ var parseMebx = async ({
     initialBoxes: [],
     options,
     continueMdat: false,
-    littleEndian,
-    signal
+    signal,
+    logLevel: "info"
   });
   if (children.status === "incomplete") {
     throw new Error("Incomplete boxes are not allowed");
@@ -4855,7 +6104,8 @@ var audioTags = [
 var processSample = async ({
   iterator,
   options,
-  signal
+  signal,
+  logLevel
 }) => {
   const fileOffset = iterator.counter.getOffset();
   const bytesRemaining = iterator.bytesRemaining();
@@ -4899,8 +6149,8 @@ var processSample = async ({
         initialBoxes: [],
         options,
         continueMdat: false,
-        littleEndian: false,
-        signal
+        signal,
+        logLevel
       });
       if (children.status === "incomplete") {
         throw new Error("Incomplete boxes are not allowed");
@@ -4946,8 +6196,8 @@ var processSample = async ({
         initialBoxes: [],
         options,
         continueMdat: false,
-        littleEndian: false,
-        signal
+        signal,
+        logLevel
       });
       if (children.status === "incomplete") {
         throw new Error("Incomplete boxes are not allowed");
@@ -4997,8 +6247,8 @@ var processSample = async ({
         initialBoxes: [],
         options,
         continueMdat: false,
-        littleEndian: false,
-        signal
+        signal,
+        logLevel
       });
       if (children.status === "incomplete") {
         throw new Error("Incomplete boxes are not allowed");
@@ -5051,8 +6301,8 @@ var processSample = async ({
       initialBoxes: [],
       options,
       continueMdat: false,
-      littleEndian: false,
-      signal
+      signal,
+      logLevel
     }) : (iterator.discard(bytesRemainingInBox), { status: "done", segments: [] });
     if (children.status === "incomplete") {
       throw new Error("Incomplete boxes are not allowed");
@@ -5088,7 +6338,8 @@ var parseSamples = async ({
   iterator,
   maxBytes,
   options,
-  signal
+  signal,
+  logLevel
 }) => {
   const samples = [];
   const initialOffset = iterator.counter.getOffset();
@@ -5096,7 +6347,8 @@ var parseSamples = async ({
     const { sample } = await processSample({
       iterator,
       options,
-      signal
+      signal,
+      logLevel
     });
     if (sample) {
       samples.push(sample);
@@ -5124,7 +6376,8 @@ var parseStsd = async ({
     iterator,
     maxBytes: bytesRemainingInBox,
     options,
-    signal
+    signal,
+    logLevel: "info"
   });
   if (boxes.length !== numberOfEntries) {
     throw new Error(`Expected ${numberOfEntries} sample descriptions, got ${boxes.length}`);
@@ -5394,7 +6647,8 @@ var parseTrak = async ({
   size,
   offsetAtStart,
   options,
-  signal
+  signal,
+  logLevel
 }) => {
   const children = await parseBoxes({
     iterator: data,
@@ -5403,8 +6657,8 @@ var parseTrak = async ({
     initialBoxes: [],
     options,
     continueMdat: false,
-    littleEndian: false,
-    signal
+    signal,
+    logLevel
   });
   if (children.status === "incomplete") {
     throw new Error("Incomplete boxes are not allowed");
@@ -5465,8 +6719,8 @@ var getChildren = async ({
   iterator,
   bytesRemainingInBox,
   options,
-  littleEndian,
-  signal
+  signal,
+  logLevel
 }) => {
   const parseChildren = boxType === "mdia" || boxType === "minf" || boxType === "stbl" || boxType === "moof" || boxType === "dims" || boxType === "wave" || boxType === "traf" || boxType === "stsb";
   if (parseChildren) {
@@ -5477,8 +6731,8 @@ var getChildren = async ({
       initialBoxes: [],
       options,
       continueMdat: false,
-      littleEndian,
-      signal
+      signal,
+      logLevel
     });
     if (parsed.status === "incomplete") {
       throw new Error("Incomplete boxes are not allowed");
@@ -5527,12 +6781,12 @@ var processBox = async ({
   allowIncompleteBoxes,
   parsedBoxes,
   options,
-  littleEndian,
-  signal
+  signal,
+  logLevel
 }) => {
   const fileOffset = iterator.counter.getOffset();
   const bytesRemaining = iterator.bytesRemaining();
-  const boxSizeRaw = iterator.getFourByteNumber(littleEndian);
+  const boxSizeRaw = iterator.getFourByteNumber();
   if (boxSizeRaw === 1 && iterator.bytesRemaining() < 12 || iterator.bytesRemaining() < 4) {
     iterator.counter.decrement(iterator.counter.getOffset() - fileOffset);
     if (allowIncompleteBoxes) {
@@ -5554,7 +6808,7 @@ var processBox = async ({
     };
   }
   const boxType = iterator.getByteString(4);
-  const boxSize = boxSizeRaw === 1 ? iterator.getEightByteNumber(littleEndian) : boxSizeRaw;
+  const boxSize = boxSizeRaw === 1 ? iterator.getEightByteNumber() : boxSizeRaw;
   if (bytesRemaining < boxSize) {
     if (boxType === "mdat") {
       const shouldSkip = (options.canSkipVideoData || !hasTracks(parsedBoxes)) && options.supportsContentRange;
@@ -5604,7 +6858,8 @@ var processBox = async ({
   }
   if (boxType === "colr") {
     const box = parseColorParameterBox({
-      iterator
+      iterator,
+      size: boxSize
     });
     return {
       type: "complete",
@@ -5749,7 +7004,6 @@ var processBox = async ({
       offset: fileOffset,
       size: boxSize,
       options,
-      littleEndian,
       signal
     });
     return {
@@ -5765,7 +7019,8 @@ var processBox = async ({
       offset: fileOffset,
       size: boxSize,
       options,
-      signal
+      signal,
+      logLevel
     });
     return {
       type: "complete",
@@ -5780,7 +7035,8 @@ var processBox = async ({
       size: boxSize,
       offsetAtStart: fileOffset,
       options,
-      signal
+      signal,
+      logLevel
     });
     const transformedTrack = makeBaseMediaTrack(box);
     if (transformedTrack) {
@@ -5880,7 +7136,8 @@ var processBox = async ({
     const box = parseEsds({
       data: iterator,
       size: boxSize,
-      fileOffset
+      fileOffset,
+      logLevel
     });
     return {
       type: "complete",
@@ -5915,8 +7172,8 @@ var processBox = async ({
     iterator,
     bytesRemainingInBox,
     options,
-    littleEndian,
-    signal
+    signal,
+    logLevel
   });
   return {
     type: "complete",
@@ -5938,8 +7195,8 @@ var parseBoxes = async ({
   initialBoxes,
   options,
   continueMdat,
-  littleEndian,
-  signal
+  signal,
+  logLevel
 }) => {
   let boxes = initialBoxes;
   const initialOffset = iterator.counter.getOffset();
@@ -5957,8 +7214,8 @@ var parseBoxes = async ({
       allowIncompleteBoxes,
       parsedBoxes: initialBoxes,
       options,
-      littleEndian,
-      signal
+      signal,
+      logLevel
     });
     if (result.type === "incomplete") {
       if (Number.isFinite(maxBytes)) {
@@ -5975,8 +7232,8 @@ var parseBoxes = async ({
             initialBoxes: boxes,
             options,
             continueMdat: false,
-            littleEndian,
-            signal
+            signal,
+            logLevel
           });
         },
         skipTo: null
@@ -5994,8 +7251,8 @@ var parseBoxes = async ({
             initialBoxes: boxes,
             options,
             continueMdat: result,
-            littleEndian,
-            signal
+            signal,
+            logLevel
           }));
         },
         skipTo: null
@@ -6027,8 +7284,8 @@ var parseBoxes = async ({
             initialBoxes: boxes,
             options,
             continueMdat: false,
-            littleEndian,
-            signal
+            signal,
+            logLevel
           });
         },
         skipTo: result.skipTo
@@ -6046,8 +7303,8 @@ var parseBoxes = async ({
             initialBoxes: boxes,
             options,
             continueMdat: false,
-            littleEndian,
-            signal
+            signal,
+            logLevel
           });
         },
         skipTo: null
@@ -6073,8 +7330,8 @@ var parseBoxes = async ({
           initialBoxes: boxes,
           options,
           continueMdat: false,
-          littleEndian,
-          signal
+          signal,
+          logLevel
         });
       },
       skipTo: skipped ? mdatState.fileOffset : null
@@ -6145,11 +7402,11 @@ var getSampleFromBlock = (ebml, parserContext, offset) => {
   const { keyframe } = parseBlockFlags(iterator, ebml.type === "SimpleBlock" ? matroskaElements.SimpleBlock : matroskaElements.Block);
   const { codec, trackTimescale } = parserContext.parserState.getTrackInfoByNumber(trackNumber2);
   const clusterOffset = parserContext.parserState.getTimestampOffsetForByteOffset(offset);
-  const timescale = parserContext.parserState.getTimescale();
+  const timescale2 = parserContext.parserState.getTimescale();
   if (clusterOffset === undefined) {
     throw new Error("Could not find offset for byte offset " + offset);
   }
-  const timecodeInNanoSeconds = (timecodeRelativeToCluster + clusterOffset) * timescale * (trackTimescale ?? 1);
+  const timecodeInNanoSeconds = (timecodeRelativeToCluster + clusterOffset) * timescale2 * (trackTimescale ?? 1);
   const timecodeInMicroseconds = timecodeInNanoSeconds / 1000;
   if (!codec) {
     throw new Error(`Could not find codec for track ${trackNumber2}`);
@@ -6158,8 +7415,8 @@ var getSampleFromBlock = (ebml, parserContext, offset) => {
   if (codec.startsWith("V_")) {
     const partialVideoSample = {
       data: iterator.getSlice(remainingNow),
-      cts: null,
-      dts: null,
+      cts: timecodeInMicroseconds,
+      dts: timecodeInMicroseconds,
       duration: undefined,
       trackId: trackNumber2,
       timestamp: timecodeInMicroseconds
@@ -6187,7 +7444,9 @@ var getSampleFromBlock = (ebml, parserContext, offset) => {
       trackId: trackNumber2,
       timestamp: timecodeInMicroseconds,
       type: "key",
-      duration: undefined
+      duration: undefined,
+      cts: timecodeInMicroseconds,
+      dts: timecodeInMicroseconds
     };
     iterator.destroy();
     return {
@@ -6367,32 +7626,54 @@ var postprocessEbml = async ({
 };
 
 // src/boxes/webm/segments.ts
-var parseSegment = async ({
-  segmentId,
+var continueAfterMatroskaParseResult = async ({
+  result,
   iterator,
-  length,
   parserContext,
-  headerReadSoFar
+  segment
 }) => {
-  if (length < 0) {
-    throw new Error(`Expected length of ${segmentId} to be greater or equal 0`);
+  if (result.status === "done") {
+    throw new Error("Should not continue after done");
   }
-  iterator.counter.decrement(headerReadSoFar);
-  const offset = iterator.counter.getOffset();
-  const ebml = await parseEbml(iterator, parserContext);
-  const remapped = await postprocessEbml({ offset, ebml, parserContext });
-  return remapped;
+  const proceeded = await result.continueParsing();
+  if (proceeded.status === "done") {
+    return {
+      status: "done",
+      segment
+    };
+  }
+  return {
+    continueParsing() {
+      return continueAfterMatroskaParseResult({
+        result: proceeded,
+        iterator,
+        parserContext,
+        segment
+      });
+    },
+    segment: null,
+    status: "incomplete"
+  };
 };
-var expectSegment = async (iterator, parserContext) => {
-  const offset = iterator.counter.getOffset();
+var expectSegment = async ({
+  iterator,
+  parserContext,
+  offset,
+  children
+}) => {
+  iterator.counter.decrement(iterator.counter.getOffset() - offset);
   if (iterator.bytesRemaining() === 0) {
     return {
       status: "incomplete",
-      segments: [],
       continueParsing: () => {
-        return Promise.resolve(expectSegment(iterator, parserContext));
+        return expectAndProcessSegment({
+          iterator,
+          parserContext,
+          offset,
+          children
+        });
       },
-      skipTo: null
+      segment: null
     };
   }
   const segmentId = iterator.getMatroskaSegmentId();
@@ -6400,11 +7681,15 @@ var expectSegment = async (iterator, parserContext) => {
     iterator.counter.decrement(iterator.counter.getOffset() - offset);
     return {
       status: "incomplete",
-      segments: [],
       continueParsing: () => {
-        return Promise.resolve(expectSegment(iterator, parserContext));
+        return expectAndProcessSegment({
+          iterator,
+          parserContext,
+          offset,
+          children
+        });
       },
-      skipTo: null
+      segment: null
     };
   }
   const offsetBeforeVInt = iterator.counter.getOffset();
@@ -6414,41 +7699,43 @@ var expectSegment = async (iterator, parserContext) => {
     iterator.counter.decrement(iterator.counter.getOffset() - offset);
     return {
       status: "incomplete",
-      segments: [],
       continueParsing: () => {
-        return Promise.resolve(expectSegment(iterator, parserContext));
+        return expectSegment({ iterator, parserContext, offset, children });
       },
-      skipTo: null
+      segment: null
     };
   }
   const bytesRemainingNow = iterator.byteLength() - iterator.counter.getOffset();
   if (segmentId === "0x18538067" || segmentId === "0x1f43b675") {
+    const newSegment = {
+      type: segmentId === "0x18538067" ? "Segment" : "Cluster",
+      minVintWidth: offsetAfterVInt - offsetBeforeVInt,
+      value: []
+    };
     const main = await expectChildren({
       iterator,
       length,
-      initialChildren: [],
-      wrap: segmentId === "0x18538067" ? (s) => ({
-        type: "Segment",
-        value: s,
-        minVintWidth: offsetAfterVInt - offsetBeforeVInt
-      }) : (s) => ({
-        type: "Cluster",
-        value: s,
-        minVintWidth: offsetAfterVInt - offsetBeforeVInt
-      }),
-      parserContext
+      children: newSegment.value,
+      parserContext,
+      startOffset: iterator.counter.getOffset()
     });
     if (main.status === "incomplete") {
       return {
         status: "incomplete",
-        segments: main.segments,
-        skipTo: null,
-        continueParsing: main.continueParsing
+        continueParsing: () => {
+          return continueAfterMatroskaParseResult({
+            iterator,
+            parserContext,
+            result: main,
+            segment: newSegment
+          });
+        },
+        segment: newSegment
       };
     }
     return {
       status: "done",
-      segments: main.segments
+      segment: newSegment
     };
   }
   if (bytesRemainingNow < length) {
@@ -6456,11 +7743,10 @@ var expectSegment = async (iterator, parserContext) => {
     iterator.counter.decrement(bytesRead);
     return {
       status: "incomplete",
-      segments: [],
+      segment: null,
       continueParsing: () => {
-        return Promise.resolve(expectSegment(iterator, parserContext));
-      },
-      skipTo: null
+        return expectSegment({ iterator, parserContext, offset, children });
+      }
     };
   }
   const segment = await parseSegment({
@@ -6472,138 +7758,187 @@ var expectSegment = async (iterator, parserContext) => {
   });
   return {
     status: "done",
-    segments: [segment]
+    segment
   };
 };
+var parseSegment = async ({
+  segmentId,
+  iterator,
+  length,
+  parserContext,
+  headerReadSoFar
+}) => {
+  if (length < 0) {
+    throw new Error(`Expected length of ${segmentId} to be greater or equal 0`);
+  }
+  iterator.counter.decrement(headerReadSoFar);
+  const offset = iterator.counter.getOffset();
+  const ebml = await parseEbml(iterator, parserContext);
+  const remapped = await postprocessEbml({ offset, ebml, parserContext });
+  return remapped;
+};
 
 // src/boxes/webm/segments/parse-children.ts
 var processParseResult = ({
   parseResult,
-  children,
-  wrap
+  children
 }) => {
+  if (parseResult.segment && !children.includes(parseResult.segment)) {
+    children.push(parseResult.segment);
+  }
   if (parseResult.status === "incomplete") {
     return {
       status: "incomplete",
-      segments: [],
+      segment: parseResult.segment,
       continueParsing: async () => {
         const newParseResult = await parseResult.continueParsing();
         return processParseResult({
           children,
-          parseResult: newParseResult,
-          wrap
+          parseResult: newParseResult
         });
-      },
-      skipTo: null
+      }
     };
   }
-  for (const segment of parseResult.segments) {
-    children.push(segment);
-  }
   return {
     status: "done",
-    segments: wrap ? [wrap(children)] : children
+    segment: parseResult.segment
   };
 };
-var continueParsingfunction = ({
-  result,
+var expectAndProcessSegment = async ({
   iterator,
+  parserContext,
+  offset,
+  children
+}) => {
+  const segment = await expectSegment({
+    iterator,
+    parserContext,
+    offset,
+    children
+  });
+  return processParseResult({
+    children,
+    parseResult: segment
+  });
+};
+var continueAfterSegmentResult = async ({
+  result,
+  length,
   children,
-  wrap,
   parserContext,
-  length
-}) => async () => {
-  if (result.status !== "incomplete") {
-    throw new Error("expected incomplete");
+  iterator,
+  startOffset
+}) => {
+  if (result.status === "done") {
+    throw new Error("Should not continue after done");
   }
-  const offset = iterator.counter.getOffset();
-  const continued = await result.continueParsing();
-  if (continued.status === "incomplete") {
-    if (!parserContext.supportsContentRange) {
-      throw new Error("Content-Range header is not supported by the reader, but was asked to seek");
-    }
+  const segmentResult = await result.continueParsing();
+  if (segmentResult.status === "done") {
     return {
       status: "incomplete",
-      continueParsing: continueParsingfunction({
-        result: continued,
-        iterator,
-        children,
-        wrap,
-        parserContext,
-        length: length - (iterator.counter.getOffset() - offset)
-      }),
-      skipTo: continued.skipTo,
-      segments: wrap ? [wrap(children)] : children
+      continueParsing: () => {
+        return expectChildren({
+          children,
+          iterator,
+          length,
+          parserContext,
+          startOffset
+        });
+      },
+      skipTo: null
     };
   }
-  return expectChildren({
-    iterator,
-    length: length - (iterator.counter.getOffset() - offset),
-    initialChildren: children,
-    wrap,
-    parserContext
-  });
+  return {
+    status: "incomplete",
+    continueParsing: () => {
+      return continueAfterSegmentResult({
+        result: segmentResult,
+        children,
+        iterator,
+        length,
+        parserContext,
+        startOffset
+      });
+    },
+    skipTo: null
+  };
 };
 var expectChildren = async ({
   iterator,
   length,
-  initialChildren,
-  wrap,
-  parserContext
+  children,
+  parserContext,
+  startOffset
 }) => {
-  const children = [...initialChildren];
-  const startOffset = iterator.counter.getOffset();
   while (iterator.counter.getOffset() < startOffset + length) {
     if (iterator.bytesRemaining() === 0) {
       break;
     }
-    const parseResult = await expectSegment(iterator, parserContext);
-    const child = processParseResult({
-      children,
-      parseResult,
-      wrap
+    const currentOffset = iterator.counter.getOffset();
+    const child = await expectAndProcessSegment({
+      iterator,
+      parserContext,
+      offset: currentOffset,
+      children
     });
     if (child.status === "incomplete") {
-      if (!parserContext.supportsContentRange) {
-        throw new Error("Content-Range header is not supported by the reader, but was asked to seek");
-      }
       return {
         status: "incomplete",
-        continueParsing: continueParsingfunction({
-          result: child,
-          iterator,
-          children,
-          wrap,
-          parserContext,
-          length: length - (iterator.counter.getOffset() - startOffset)
-        }),
-        skipTo: child.skipTo,
-        segments: wrap ? [wrap(children)] : children
+        continueParsing: () => {
+          return continueAfterSegmentResult({
+            result: child,
+            children,
+            iterator,
+            length: length - (currentOffset - startOffset),
+            parserContext,
+            startOffset: currentOffset
+          });
+        },
+        skipTo: null
       };
     }
   }
   return {
-    status: "done",
-    segments: wrap ? [wrap(children)] : children
+    status: "done"
   };
 };
 
 // src/boxes/webm/parse-webm-header.ts
-var parseWebm = (counter, parserContext) => {
-  return expectChildren({
+var continueAfterMatroskaResult = (result, children) => {
+  if (result.status === "done") {
+    return {
+      status: "done",
+      segments: children
+    };
+  }
+  return {
+    status: "incomplete",
+    segments: children,
+    continueParsing: async () => {
+      const newResult = await result.continueParsing();
+      return continueAfterMatroskaResult(newResult, children);
+    },
+    skipTo: null
+  };
+};
+var parseWebm = async (counter, parserContext) => {
+  const children = [];
+  const results = await expectChildren({
     iterator: counter,
     length: Infinity,
-    initialChildren: [],
-    wrap: null,
-    parserContext
+    children,
+    parserContext,
+    startOffset: counter.counter.getOffset()
   });
+  return continueAfterMatroskaResult(results, children);
 };
 
 // src/parse-video.ts
 var parseVideo = ({
   iterator,
   options,
-  signal
+  signal,
+  logLevel
 }) => {
   if (iterator.bytesRemaining() === 0) {
     return Promise.resolve({
@@ -6613,7 +7948,8 @@ var parseVideo = ({
         return parseVideo({
           iterator,
           options,
-          signal
+          signal,
+          logLevel
         });
       },
       skipTo: null
@@ -6623,6 +7959,7 @@ var parseVideo = ({
     throw new Error("AVI files are not yet supported");
   }
   if (iterator.isIsoBaseMedia()) {
+    Log.verbose(logLevel, "Detected ISO Base Media container");
     return parseBoxes({
       iterator,
       maxBytes: Infinity,
@@ -6630,11 +7967,12 @@ var parseVideo = ({
       initialBoxes: [],
       options,
       continueMdat: false,
-      littleEndian: false,
-      signal
+      signal,
+      logLevel
     });
   }
   if (iterator.isWebm()) {
+    Log.verbose(logLevel, "Detected Matroska container");
     return Promise.resolve(parseWebm(iterator, options));
   }
   if (iterator.isMp3()) {
@@ -6673,15 +8011,15 @@ var makeParserState = ({
   const queuedAudioSamples = {};
   const queuedVideoSamples = {};
   const declinedTrackNumbers = [];
-  let timescale = null;
+  let timescale2 = null;
   const getTimescale = () => {
-    if (timescale === null) {
+    if (timescale2 === null) {
       return 1e6;
     }
-    return timescale;
+    return timescale2;
   };
   const setTimescale = (newTimescale) => {
-    timescale = newTimescale;
+    timescale2 = newTimescale;
   };
   const timestampMap = new Map;
   const setTimestampOffset = (byteOffset, timestamp) => {
@@ -6775,6 +8113,8 @@ var parseMedia = async ({
   onAudioTrack,
   onVideoTrack,
   signal,
+  logLevel = "info",
+  onParseProgress,
   ...more
 }) => {
   const state = makeParserState({
@@ -6794,14 +8134,40 @@ var parseMedia = async ({
   const moreFields = more;
   let iterator = null;
   let parseResult = null;
+  const canSkipVideoData = !onVideoTrack && !onAudioTrack;
+  if (canSkipVideoData) {
+    Log.verbose(logLevel, "Only parsing metadata, because no onVideoTrack and onAudioTrack callbacks were passed.");
+  } else {
+    Log.verbose(logLevel, "Parsing video data, because onVideoTrack/onAudioTrack callbacks were passed.");
+  }
   const options = {
-    canSkipVideoData: !(onAudioTrack || onVideoTrack),
+    canSkipVideoData,
     onAudioTrack: onAudioTrack ?? null,
     onVideoTrack: onVideoTrack ?? null,
     parserState: state,
     nullifySamples: !(typeof process !== "undefined" && typeof process.env !== "undefined" && process.env.KEEP_SAMPLES === "true"),
     supportsContentRange
   };
+  const hasAllInfo = () => {
+    if (parseResult === null) {
+      return false;
+    }
+    const availableInfo = getAvailableInfo(fields ?? {}, parseResult, state);
+    return Object.values(availableInfo).every(Boolean);
+  };
+  const triggerInfoEmit = () => {
+    const availableInfo = getAvailableInfo(fields ?? {}, parseResult, state);
+    emitAvailableInfo({
+      hasInfo: availableInfo,
+      moreFields,
+      parseResult,
+      state,
+      returnValue,
+      contentLength,
+      name
+    });
+  };
+  triggerInfoEmit();
   while (parseResult === null || parseResult.status === "incomplete") {
     if (signal?.aborted) {
       throw new Error("Aborted");
@@ -6828,27 +8194,24 @@ var parseMedia = async ({
     if (!iterator) {
       throw new Error("Unexpected null");
     }
+    await onParseProgress?.({
+      bytes: iterator.counter.getOffset(),
+      percentage: contentLength ? iterator.counter.getOffset() / contentLength : null,
+      totalBytes: contentLength
+    });
+    triggerInfoEmit();
     if (parseResult && parseResult.status === "incomplete") {
+      Log.verbose(logLevel, "Continuing parsing of file, currently at position", iterator.counter.getOffset(), getAvailableInfo(fields ?? {}, parseResult, state));
       parseResult = await parseResult.continueParsing();
     } else {
       parseResult = await parseVideo({
         iterator,
         options,
-        signal: signal ?? null
+        signal: signal ?? null,
+        logLevel
       });
     }
-    const availableInfo = getAvailableInfo(fields ?? {}, parseResult, state);
-    const hasAllInfo = Object.values(availableInfo).every(Boolean);
-    emitAvailableInfo({
-      hasInfo: availableInfo,
-      moreFields,
-      parseResult,
-      state,
-      returnValue,
-      contentLength,
-      name
-    });
-    if (hasAllInfo && !onVideoTrack && !onAudioTrack) {
+    if (hasAllInfo() && !onVideoTrack && !onAudioTrack) {
       break;
     }
     if (parseResult && parseResult.status === "incomplete" && parseResult.skipTo !== null) {
@@ -6861,6 +8224,7 @@ var parseMedia = async ({
       iterator.skipTo(parseResult.skipTo, true);
     }
   }
+  Log.verbose(logLevel, "Finished parsing file");
   emitAvailableInfo({
     hasInfo: Object.keys(fields ?? {}).reduce((acc, key) => {
       acc[key] = true;
@@ -6877,12 +8241,17 @@ var parseMedia = async ({
   iterator?.destroy();
   return returnValue;
 };
+// src/version.ts
+var VERSION = "4.0.231";
+
 // src/index.ts
 var MediaParserInternals = {
-  createMedia,
+  createMatroskaMedia,
+  createIsoBaseMedia,
   Log
 };
 export {
   parseMedia,
+  VERSION,
   MediaParserInternals
 };