@remotion/webcodecs 4.0.244 → 4.0.246

package/dist/esm/index.mjs

@@ -92,6 +92,131 @@ var require_dist = __commonJS((exports) => {
   } });
 });
 
+// src/writers/web-fs.ts
+var createContent = async ({ filename }) => {
+  const directoryHandle = await navigator.storage.getDirectory();
+  const actualFilename = `__remotion_mediaparser:${filename}`;
+  const remove = async () => {
+    await directoryHandle.removeEntry(actualFilename, {
+      recursive: true
+    });
+  };
+  await remove();
+  const fileHandle = await directoryHandle.getFileHandle(actualFilename, {
+    create: true
+  });
+  const writable = await fileHandle.createWritable();
+  let written = 0;
+  let writPromise = Promise.resolve();
+  const write = async (arr) => {
+    await writable.write(arr);
+    written += arr.byteLength;
+  };
+  const updateDataAt = async (position, data) => {
+    await writable.seek(position);
+    await writable.write(data);
+    await writable.seek(written);
+  };
+  const writer = {
+    write: (arr) => {
+      writPromise = writPromise.then(() => write(arr));
+      return writPromise;
+    },
+    save: async () => {
+      try {
+        await writable.close();
+      } catch {
+      }
+      const newHandle = await directoryHandle.getFileHandle(actualFilename, {
+        create: true
+      });
+      const newFile = await newHandle.getFile();
+      return newFile;
+    },
+    getWrittenByteCount: () => written,
+    updateDataAt: (position, data) => {
+      writPromise = writPromise.then(() => updateDataAt(position, data));
+      return writPromise;
+    },
+    waitForFinish: async () => {
+      await writPromise;
+    },
+    remove
+  };
+  return writer;
+};
+var webFsWriter = {
+  createContent
+};
+var canUseWebFsWriter = async () => {
+  if (!("storage" in navigator)) {
+    return false;
+  }
+  if (!("getDirectory" in navigator.storage)) {
+    return false;
+  }
+  const directoryHandle = await navigator.storage.getDirectory();
+  const fileHandle = await directoryHandle.getFileHandle("remotion-probe-web-fs-support", {
+    create: true
+  });
+  const canUse = fileHandle.createWritable !== undefined;
+  return canUse;
+};
+
+// src/writers/buffer-implementation/writer.ts
+var createContent2 = ({ filename, mimeType }) => {
+  const buf = new ArrayBuffer(0, {
+    maxByteLength: 2000000000
+  });
+  if (!buf.resize) {
+    throw new Error("Could not create buffer writer");
+  }
+  const write = (newData) => {
+    const oldLength = buf.byteLength;
+    const newLength = oldLength + newData.byteLength;
+    buf.resize(newLength);
+    const newArray = new Uint8Array(buf);
+    newArray.set(newData, oldLength);
+  };
+  const updateDataAt = (position, newData) => {
+    const newArray = new Uint8Array(buf);
+    newArray.set(newData, position);
+  };
+  let writPromise = Promise.resolve();
+  let removed = false;
+  const writer = {
+    write: (arr) => {
+      writPromise = writPromise.then(() => write(arr));
+      return writPromise;
+    },
+    save: () => {
+      if (removed) {
+        return Promise.reject(new Error("Already called .remove() on the result"));
+      }
+      const arr = new Uint8Array(buf);
+      return Promise.resolve(new File([arr.slice()], filename, { type: mimeType }));
+    },
+    remove() {
+      removed = true;
+      return Promise.resolve();
+    },
+    getWrittenByteCount: () => buf.byteLength,
+    updateDataAt: (position, newData) => {
+      writPromise = writPromise.then(() => updateDataAt(position, newData));
+      return writPromise;
+    },
+    waitForFinish: async () => {
+      await writPromise;
+    }
+  };
+  return Promise.resolve(writer);
+};
+
+// src/writers/buffer.ts
+var bufferWriter = {
+  createContent: createContent2
+};
+
 // src/resizing/calculate-new-size.ts
 var ensureMultipleOfTwo = ({
   dimensions,
@@ -325,17 +450,59 @@ var getWaveAudioDecoder = ({
   };
 };
 
-// src/io-manager/io-synchronizer.ts
-import { MediaParserInternals as MediaParserInternals3 } from "@remotion/media-parser";
+// src/create/event-emitter.ts
+class IoEventEmitter {
+  listeners = {
+    input: [],
+    output: [],
+    processed: [],
+    progress: []
+  };
+  addEventListener(name, callback) {
+    this.listeners[name].push(callback);
+  }
+  removeEventListener(name, callback) {
+    this.listeners[name] = this.listeners[name].filter((l) => l !== callback);
+  }
+  dispatchEvent(dispatchName, context) {
+    this.listeners[dispatchName].forEach((callback) => {
+      callback({ detail: context });
+    });
+  }
+}
+
+// src/create/with-resolvers.ts
+var withResolvers = function() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+};
+var withResolversAndWaitForReturn = () => {
+  const { promise, reject, resolve } = withResolvers();
+  const { promise: returnPromise, resolve: resolveReturn } = withResolvers();
+  return {
+    getPromiseToImmediatelyReturn: () => {
+      resolveReturn(undefined);
+      return promise;
+    },
+    reject: (reason) => {
+      returnPromise.then(() => reject(reason));
+    },
+    resolve
+  };
+};
 
 // src/log.ts
 import { MediaParserInternals } from "@remotion/media-parser";
 var { Log } = MediaParserInternals;
 
 // src/io-manager/make-timeout-promise.ts
-import { MediaParserInternals as MediaParserInternals2 } from "@remotion/media-parser";
 var makeTimeoutPromise = (label, ms) => {
-  const { promise, reject, resolve } = MediaParserInternals2.withResolvers();
+  const { promise, reject, resolve } = withResolvers();
   const timeout = setTimeout(() => {
     reject(new Error(`${label()} (timed out after ${ms}ms)`));
   }, ms);
@@ -354,7 +521,7 @@ var makeIoSynchronizer = ({
   label,
   progress
 }) => {
-  const eventEmitter = new MediaParserInternals3.IoEventEmitter;
+  const eventEmitter = new IoEventEmitter;
   let lastInput = 0;
   let lastInputKeyframe = 0;
   let lastOutput = 0;
@@ -398,7 +565,7 @@ var makeIoSynchronizer = ({
     printState("Got output");
   };
   const waitForOutput = () => {
-    const { promise, resolve } = MediaParserInternals3.withResolvers();
+    const { promise, resolve } = withResolvers();
     const on = () => {
       eventEmitter.removeEventListener("output", on);
       resolve();
@@ -407,7 +574,7 @@ var makeIoSynchronizer = ({
     return promise;
   };
   const waitForProcessed = () => {
-    const { promise, resolve } = MediaParserInternals3.withResolvers();
+    const { promise, resolve } = withResolvers();
     const on = () => {
       eventEmitter.removeEventListener("processed", on);
       resolve();
@@ -927,17 +1094,9 @@ var canReencodeVideoTrack = async ({
   return Boolean(videoDecoderConfig && videoEncoderConfig);
 };
 // src/convert-media.ts
-import {
-  MediaParserInternals as MediaParserInternals9,
-  parseMedia
-} from "@remotion/media-parser";
+import { parseMedia } from "@remotion/media-parser";
 
 // src/auto-select-writer.ts
-import { canUseWebFsWriter, webFsWriter } from "@remotion/media-parser/web-fs";
-import {
-  MediaParserInternals as MediaParserInternals4
-} from "@remotion/media-parser";
-import { bufferWriter } from "@remotion/media-parser/buffer";
 var autoSelectWriter = async (writer, logLevel) => {
   if (writer) {
     Log.verbose(logLevel, "Using writer provided by user");
@@ -950,11 +1109,7 @@ var autoSelectWriter = async (writer, logLevel) => {
     return bufferWriter;
   }
   try {
-    const {
-      promise: timeout,
-      reject,
-      resolve
-    } = MediaParserInternals4.withResolvers();
+    const { promise: timeout, reject, resolve } = withResolvers();
     const time = setTimeout(() => reject(new Error("WebFS check timeout")), 2000);
     const webFsSupported = await Promise.race([canUseWebFsWriter(), timeout]);
     resolve();
@@ -981,6 +1136,64 @@ var calculateProgress = ({
   return millisecondsWritten / expectedOutputDurationInMs;
 };
 
+// src/create/progress-tracker.ts
+var makeProgressTracker = () => {
+  const trackNumberProgresses = {};
+  const eventEmitter = new IoEventEmitter;
+  let startingTimestamp = null;
+  const setPossibleLowestTimestamp = (timestamp) => {
+    if (startingTimestamp === null) {
+      startingTimestamp = timestamp;
+    } else {
+      startingTimestamp = Math.min(startingTimestamp, timestamp);
+    }
+  };
+  const getStartingTimestamp = () => {
+    if (startingTimestamp === null) {
+      throw new Error("No starting timestamp");
+    }
+    return startingTimestamp;
+  };
+  const calculateSmallestProgress = () => {
+    const progressValues = Object.values(trackNumberProgresses).map((p) => {
+      if (p !== null) {
+        return p;
+      }
+      if (startingTimestamp === null) {
+        throw new Error("No progress values to calculate smallest progress from");
+      }
+      return startingTimestamp;
+    });
+    return Math.min(...progressValues);
+  };
+  return {
+    registerTrack: (trackNumber) => {
+      trackNumberProgresses[trackNumber] = null;
+    },
+    getSmallestProgress: calculateSmallestProgress,
+    updateTrackProgress: (trackNumber, progress) => {
+      if (trackNumberProgresses[trackNumber] === undefined) {
+        throw new Error(`Tried to update progress for a track that was not registered: ${trackNumber}`);
+      }
+      trackNumberProgresses[trackNumber] = progress;
+      eventEmitter.dispatchEvent("progress", {
+        smallestProgress: calculateSmallestProgress()
+      });
+    },
+    waitForProgress: () => {
+      const { promise, resolve } = withResolvers();
+      const on = () => {
+        eventEmitter.removeEventListener("progress", on);
+        resolve();
+      };
+      eventEmitter.addEventListener("progress", on);
+      return promise;
+    },
+    getStartingTimestamp,
+    setPossibleLowestTimestamp
+  };
+};
+
 // src/error-cause.ts
 var error_cause_default = Error;
 
@@ -994,7 +1207,7 @@ var generateOutputFilename = (source, container) => {
 
 // src/on-audio-track.ts
 import {
-  MediaParserInternals as MediaParserInternals6
+  MediaParserInternals as MediaParserInternals3
 } from "@remotion/media-parser";
 
 // src/convert-encoded-chunk.ts
@@ -1015,7 +1228,7 @@ var convertEncodedChunk = (chunk, trackId) => {
 };
 
 // src/default-on-audio-track-handler.ts
-import { MediaParserInternals as MediaParserInternals5 } from "@remotion/media-parser";
+import { MediaParserInternals as MediaParserInternals2 } from "@remotion/media-parser";
 var DEFAULT_BITRATE = 128000;
 var defaultOnAudioTrackHandler = async ({
   track,
@@ -1025,11 +1238,11 @@ var defaultOnAudioTrackHandler = async ({
 }) => {
   const bitrate = DEFAULT_BITRATE;
   if (canCopyTrack) {
-    MediaParserInternals5.Log.verbose(logLevel, `Track ${track.trackId} (audio): Can copy track, therefore copying`);
+    MediaParserInternals2.Log.verbose(logLevel, `Track ${track.trackId} (audio): Can copy track, therefore copying`);
     return Promise.resolve({ type: "copy" });
   }
   if (defaultAudioCodec === null) {
-    MediaParserInternals5.Log.verbose(logLevel, `Track ${track.trackId} (audio): Container does not support audio, dropping audio`);
+    MediaParserInternals2.Log.verbose(logLevel, `Track ${track.trackId} (audio): Container does not support audio, dropping audio`);
     return Promise.resolve({ type: "drop" });
   }
   const canReencode = await canReencodeAudioTrack({
@@ -1038,14 +1251,14 @@ var defaultOnAudioTrackHandler = async ({
     bitrate
   });
   if (canReencode) {
-    MediaParserInternals5.Log.verbose(logLevel, `Track ${track.trackId} (audio): Cannot copy, but re-encode, therefore re-encoding`);
+    MediaParserInternals2.Log.verbose(logLevel, `Track ${track.trackId} (audio): Cannot copy, but re-encode, therefore re-encoding`);
     return Promise.resolve({
       type: "reencode",
       bitrate,
       audioCodec: defaultAudioCodec
     });
   }
-  MediaParserInternals5.Log.verbose(logLevel, `Track ${track.trackId} (audio): Can neither re-encode nor copy, failing render`);
+  MediaParserInternals2.Log.verbose(logLevel, `Track ${track.trackId} (audio): Can neither re-encode nor copy, failing render`);
   return Promise.resolve({ type: "fail" });
 };
 
@@ -1141,7 +1354,7 @@ var makeAudioTrackHandler = ({
     abortConversion(new error_cause_default(`Could not configure audio decoder of track ${track.trackId}`));
     return null;
   }
-  const codecPrivate = audioOperation.audioCodec === "aac" ? MediaParserInternals6.createAacCodecPrivate({
+  const codecPrivate = audioOperation.audioCodec === "aac" ? MediaParserInternals3.createAacCodecPrivate({
     audioObjectType: 2,
     sampleRate: track.sampleRate,
     channelConfiguration: track.numberOfChannels
@@ -1222,7 +1435,7 @@ var arrayBufferToUint8Array = (buffer) => {
 };
 
 // src/default-on-video-track-handler.ts
-import { MediaParserInternals as MediaParserInternals7 } from "@remotion/media-parser";
+import { MediaParserInternals as MediaParserInternals4 } from "@remotion/media-parser";
 var defaultOnVideoTrackHandler = async ({
   track,
   defaultVideoCodec,
@@ -1232,11 +1445,11 @@ var defaultOnVideoTrackHandler = async ({
   resizeOperation
 }) => {
   if (canCopyTrack) {
-    MediaParserInternals7.Log.verbose(logLevel, `Track ${track.trackId} (video): Can copy, therefore copying`);
+    MediaParserInternals4.Log.verbose(logLevel, `Track ${track.trackId} (video): Can copy, therefore copying`);
     return Promise.resolve({ type: "copy" });
   }
   if (defaultVideoCodec === null) {
-    MediaParserInternals7.Log.verbose(logLevel, `Track ${track.trackId} (video): Is audio container, therefore dropping video`);
+    MediaParserInternals4.Log.verbose(logLevel, `Track ${track.trackId} (video): Is audio container, therefore dropping video`);
     return Promise.resolve({ type: "drop" });
   }
   const canReencode = await canReencodeVideoTrack({
@@ -1244,7 +1457,7 @@ var defaultOnVideoTrackHandler = async ({
     track
   });
   if (canReencode) {
-    MediaParserInternals7.Log.verbose(logLevel, `Track ${track.trackId} (video): Cannot copy, but re-enconde, therefore re-encoding`);
+    MediaParserInternals4.Log.verbose(logLevel, `Track ${track.trackId} (video): Cannot copy, but re-enconde, therefore re-encoding`);
     return Promise.resolve({
       type: "reencode",
       videoCodec: defaultVideoCodec,
@@ -1252,7 +1465,7 @@ var defaultOnVideoTrackHandler = async ({
       resize: resizeOperation
     });
   }
-  MediaParserInternals7.Log.verbose(logLevel, `Track ${track.trackId} (video): Can neither copy nor re-encode, therefore failing`);
+  MediaParserInternals4.Log.verbose(logLevel, `Track ${track.trackId} (video): Can neither copy nor re-encode, therefore failing`);
   return Promise.resolve({ type: "fail" });
 };
 
@@ -1706,17 +1919,2282 @@ var makeVideoTrackHandler = ({
   };
 };
 
-// src/select-container-creator.ts
-import { MediaParserInternals as MediaParserInternals8 } from "@remotion/media-parser";
+// src/create/iso-base-media/create-iso-base-media.ts
+import {
+  MediaParserInternals as MediaParserInternals6
+} from "@remotion/media-parser";
+
+// src/create/matroska/matroska-utils.ts
+import { MediaParserInternals as MediaParserInternals5 } from "@remotion/media-parser";
+var getIdForName = (name) => {
+  const value = Object.entries(MediaParserInternals5.matroskaElements).find(([key]) => key === name)?.[1];
+  if (!value) {
+    throw new Error(`Could not find id for name ${name}`);
+  }
+  return value;
+};
+function putUintDynamic(number, minimumLength) {
+  if (number < 0) {
+    throw new Error("This function is designed for non-negative integers only.");
+  }
+  const length = Math.max(minimumLength ?? 0, Math.ceil(Math.log2(number + 1) / 8));
+  const bytes = new Uint8Array(length);
+  for (let i = 0;i < length; i++) {
+    bytes[length - 1 - i] = number >> 8 * i & 255;
+  }
+  return bytes;
+}
+var makeFromStructure = (fields) => {
+  if ("bytes" in fields) {
+    return fields;
+  }
+  const arrays = [];
+  const struct = MediaParserInternals5.ebmlMap[getIdForName(fields.type)];
+  if (struct.type === "uint8array") {
+    return {
+      bytes: fields.value,
+      offsets: { offset: 0, children: [], field: fields.type }
+    };
+  }
+  if (struct.type === "children") {
+    const children = [];
+    let bytesWritten = 0;
+    for (const item of fields.value) {
+      const { bytes, offsets } = makeMatroskaBytes(item);
+      arrays.push(bytes);
+      children.push(incrementOffsetAndChildren(offsets, bytesWritten));
+      bytesWritten += bytes.byteLength;
+    }
+    return {
+      bytes: combineUint8Arrays(arrays),
+      offsets: { offset: 0, children, field: fields.type }
+    };
+  }
+  if (struct.type === "string") {
+    return {
+      bytes: new TextEncoder().encode(fields.value),
+      offsets: {
+        children: [],
+        offset: 0,
+        field: fields.type
+      }
+    };
+  }
+  if (struct.type === "uint") {
+    return {
+      bytes: putUintDynamic(fields.value.value, fields.value.byteLength),
+      offsets: {
+        children: [],
+        offset: 0,
+        field: fields.type
+      }
+    };
+  }
+  if (struct.type === "hex-string") {
+    const hex = fields.value.substring(2);
+    const arr = new Uint8Array(hex.length / 2);
+    for (let i = 0;i < hex.length; i += 2) {
+      const byte = parseInt(hex.substring(i, i + 2), 16);
+      arr[i / 2] = byte;
+    }
+    return {
+      bytes: arr,
+      offsets: {
+        children: [],
+        offset: 0,
+        field: fields.type
+      }
+    };
+  }
+  if (struct.type === "float") {
+    const value = fields.value;
+    if (value.size === "32") {
+      const dataView = new DataView(new ArrayBuffer(4));
+      dataView.setFloat32(0, value.value);
+      return {
+        bytes: new Uint8Array(dataView.buffer),
+        offsets: {
+          children: [],
+          offset: 0,
+          field: fields.type
+        }
+      };
+    }
+    const dataView2 = new DataView(new ArrayBuffer(8));
+    dataView2.setFloat64(0, value.value);
+    return {
+      bytes: new Uint8Array(dataView2.buffer),
+      offsets: {
+        children: [],
+        offset: 0,
+        field: fields.type
+      }
+    };
+  }
+  throw new Error("Unexpected type");
+};
+var combineUint8Arrays = (arrays) => {
+  if (arrays.length === 0) {
+    return new Uint8Array([]);
+  }
+  if (arrays.length === 1) {
+    return arrays[0];
+  }
+  let totalLength = 0;
+  for (const array of arrays) {
+    totalLength += array.length;
+  }
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const array of arrays) {
+    result.set(array, offset);
+    offset += array.length;
+  }
+  return result;
+};
+var incrementOffsetAndChildren = (offset, increment) => {
+  return {
+    offset: offset.offset + increment,
+    children: offset.children.map((c) => incrementOffsetAndChildren(c, increment)),
+    field: offset.field
+  };
+};
+var matroskaToHex = (matrId) => {
+  const numbers = new Uint8Array((matrId.length - 2) / 2);
+  for (let i = 2;i < matrId.length; i += 2) {
+    const hex = matrId.substring(i, i + 2);
+    numbers[(i - 2) / 2] = parseInt(hex, 16);
+  }
+  return numbers;
+};
+var measureEBMLVarInt = (value) => {
+  if (value < (1 << 7) - 1) {
+    return 1;
+  }
+  if (value < (1 << 14) - 1) {
+    return 2;
+  }
+  if (value < (1 << 21) - 1) {
+    return 3;
+  }
+  if (value < (1 << 28) - 1) {
+    return 4;
+  }
+  if (value < 2 ** 35 - 1) {
+    return 5;
+  }
+  if (value < 2 ** 42 - 1) {
+    return 6;
+  }
+  throw new Error("EBML VINT size not supported " + value);
+};
+var getVariableInt = (value, minWidth) => {
+  const width = Math.max(measureEBMLVarInt(value), minWidth ?? 0);
+  switch (width) {
+    case 1:
+      return new Uint8Array([1 << 7 | value]);
+    case 2:
+      return new Uint8Array([1 << 6 | value >> 8, value]);
+    case 3:
+      return new Uint8Array([1 << 5 | value >> 16, value >> 8, value]);
+    case 4:
+      return new Uint8Array([
+        1 << 4 | value >> 24,
+        value >> 16,
+        value >> 8,
+        value
+      ]);
+    case 5:
+      return new Uint8Array([
+        1 << 3 | value / 2 ** 32 & 7,
+        value >> 24,
+        value >> 16,
+        value >> 8,
+        value
+      ]);
+    case 6:
+      return new Uint8Array([
+        1 << 2 | value / 2 ** 40 & 3,
+        value / 2 ** 32 | 0,
+        value >> 24,
+        value >> 16,
+        value >> 8,
+        value
+      ]);
+    case 7:
+      return new Uint8Array([
+        1 << 1 | value / 2 ** 48 & 1,
+        value / 2 ** 40 | 0,
+        value / 2 ** 32 | 0,
+        value >> 24,
+        value >> 16,
+        value >> 8,
+        value
+      ]);
+    case 8:
+      return new Uint8Array([
+        1 << 0 | value / 2 ** 56 & 1,
+        value / 2 ** 48 | 0,
+        value / 2 ** 40 | 0,
+        value / 2 ** 32 | 0,
+        value >> 24,
+        value >> 16,
+        value >> 8,
+        value
+      ]);
+    default:
+      throw new Error("Bad EBML VINT size " + width);
+  }
+};
+var makeMatroskaBytes = (fields) => {
+  if ("bytes" in fields) {
+    return fields;
+  }
+  const value = makeFromStructure(fields);
+  const header = matroskaToHex(getIdForName(fields.type));
+  const size = getVariableInt(value.bytes.length, fields.minVintWidth);
+  const bytes = combineUint8Arrays([header, size, value.bytes]);
+  return {
+    bytes,
+    offsets: {
+      offset: value.offsets.offset,
+      field: value.offsets.field,
+      children: value.offsets.children.map((c) => {
+        return incrementOffsetAndChildren(c, header.byteLength + size.byteLength);
+      })
+    }
+  };
+};
+var padMatroskaBytes = (fields, totalLength) => {
+  const regular = makeMatroskaBytes(fields);
+  const paddingLength = totalLength - regular.bytes.byteLength - matroskaToHex(MediaParserInternals5.matroskaElements.Void).byteLength;
+  if (paddingLength < 0) {
+    throw new Error("ooops");
+  }
+  const padding = makeMatroskaBytes({
+    type: "Void",
+    value: new Uint8Array(paddingLength).fill(0),
+    minVintWidth: null
+  });
+  return [
+    regular,
+    {
+      bytes: padding.bytes,
+      offsets: incrementOffsetAndChildren(padding.offsets, regular.bytes.length)
+    }
+  ];
+};
+function serializeUint16(value) {
+  const buffer = new ArrayBuffer(2);
+  const view = new DataView(buffer);
+  view.setUint16(0, value);
+  return new Uint8Array(buffer);
+}
+
+// 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/mp4-header.ts
+import { VERSION as VERSION2 } from "@remotion/media-parser";
+
+// 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/from-unix-timestamp.ts
+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
+}) => {
+  if (!codecPrivate) {
+    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(codecPrivate)
+      ])),
+      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
+}) => {
+  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(duration / 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,
+  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(duration / 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,
+  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(duration / 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) => {
+  if (entry.sampleOffset < 0) {
+    throw new Error("negative sample offset in stts " + entry.sampleOffset);
+  }
+  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 duration of durations) {
+    if (duration === lastDuration) {
+      entries[entries.length - 1].sampleCount++;
+    } else {
+      entries.push({
+        sampleCount: 1,
+        sampleOffset: duration
+      });
+    }
+    lastDuration = duration;
+  }
+  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
+}) => {
+  const sorted = samplePositions.slice().sort((a, b) => a.dts - b.dts);
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("stbl"),
+    createStsdData(codecSpecificData),
+    createSttsAtom(sorted),
+    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" ? "\x00" : type === "video" ? "VideoHandler\x00" : "SoundHandler\x00")
+  ]));
+};
+
+// 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 ${VERSION2}`)
+      ])
+    }))
+  }), HEADER_LENGTH);
+};
+
+// src/create/iso-base-media/create-iso-base-media.ts
+var CONTAINER_TIMESCALE = 1000;
+var createIsoBaseMedia = async ({
+  writer,
+  onBytesProgress,
+  onMillisecondsProgress,
+  logLevel,
+  filename,
+  progressTracker
+}) => {
+  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 globalDurationInUnits = 0;
+  const lowestTrackTimestamps = {};
+  const trackDurations = {};
+  const currentTracks = [];
+  const samplePositions = [];
+  const sampleChunkIndices = [];
+  const moovOffset = w.getWrittenByteCount();
+  const getPaddedMoovAtom = () => {
+    return createPaddedMoovAtom({
+      durationInUnits: globalDurationInUnits,
+      trackInfo: currentTracks.map((track) => {
+        return {
+          track,
+          durationInUnits: trackDurations[track.trackNumber] ?? 0,
+          samplePositions: samplePositions[track.trackNumber] ?? [],
+          timescale: track.timescale
+        };
+      }),
+      timescale: CONTAINER_TIMESCALE
+    });
+  };
+  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 addCodecPrivateToTrack = ({
+    trackNumber,
+    codecPrivate
+  }) => {
+    currentTracks.forEach((track) => {
+      if (track.trackNumber === trackNumber) {
+        track.codecPrivate = codecPrivate;
+      }
+    });
+  };
+  let lastChunkWasVideo = false;
+  const addSample = async ({
+    chunk,
+    trackNumber,
+    isVideo,
+    codecPrivate
+  }) => {
+    const position = w.getWrittenByteCount();
+    await w.write(chunk.data);
+    mdatSize += chunk.data.length;
+    onBytesProgress(w.getWrittenByteCount());
+    progressTracker.setPossibleLowestTimestamp(Math.min(chunk.timestamp, chunk.cts ?? Infinity, chunk.dts ?? Infinity));
+    progressTracker.updateTrackProgress(trackNumber, chunk.timestamp);
+    if (codecPrivate) {
+      addCodecPrivateToTrack({ trackNumber, codecPrivate });
+    }
+    const currentTrack = currentTracks.find((t) => t.trackNumber === trackNumber);
+    if (!currentTrack) {
+      throw new Error(`Tried to add sample to track ${trackNumber}, but it doesn't exist`);
+    }
+    if (!lowestTrackTimestamps[trackNumber] || chunk.timestamp < lowestTrackTimestamps[trackNumber]) {
+      lowestTrackTimestamps[trackNumber] = chunk.timestamp;
+    }
+    if (typeof lowestTrackTimestamps[trackNumber] !== "number") {
+      throw new Error(`Tried to add sample to track ${trackNumber}, but it has no timestamp`);
+    }
+    const newDurationInMicroSeconds = chunk.timestamp + (chunk.duration ?? 0) - lowestTrackTimestamps[trackNumber];
+    const newDurationInTrackTimeUnits = Math.round(newDurationInMicroSeconds / (1e6 / currentTrack.timescale));
+    trackDurations[trackNumber] = newDurationInTrackTimeUnits;
+    const newDurationInMilliseconds = Math.round(newDurationInMicroSeconds / 1e6 * CONTAINER_TIMESCALE);
+    if (newDurationInMilliseconds > globalDurationInUnits) {
+      globalDurationInUnits = newDurationInMilliseconds;
+      onMillisecondsProgress(newDurationInMilliseconds);
+    }
+    if (!samplePositions[trackNumber]) {
+      samplePositions[trackNumber] = [];
+    }
+    if (typeof sampleChunkIndices[trackNumber] === "undefined") {
+      sampleChunkIndices[trackNumber] = 0;
+    }
+    if (isVideo && chunk.type === "key") {
+      sampleChunkIndices[trackNumber]++;
+    } else if (!isVideo && samplePositions[trackNumber].length % 22 === 0) {
+      sampleChunkIndices[trackNumber]++;
+    } else if (lastChunkWasVideo !== isVideo) {
+      sampleChunkIndices[trackNumber]++;
+    }
+    const samplePositionToAdd = {
+      isKeyframe: chunk.type === "key",
+      offset: position,
+      chunk: sampleChunkIndices[trackNumber],
+      cts: Math.round(chunk.cts / 1e6 * currentTrack.timescale),
+      dts: Math.round(chunk.dts / 1e6 * currentTrack.timescale),
+      duration: Math.round((chunk.duration ?? 0) / 1e6 * currentTrack.timescale),
+      size: chunk.data.length
+    };
+    lastChunkWasVideo = isVideo;
+    samplePositions[trackNumber].push(samplePositionToAdd);
+  };
+  const addTrack = (track) => {
+    const trackNumber = currentTracks.length + 1;
+    currentTracks.push({ ...track, trackNumber });
+    progressTracker.registerTrack(trackNumber);
+    return Promise.resolve({ trackNumber });
+  };
+  const waitForFinishPromises = [];
+  return {
+    save: () => {
+      return w.save();
+    },
+    remove: async () => {
+      await w.remove();
+    },
+    addSample: ({ chunk, trackNumber, isVideo, codecPrivate }) => {
+      operationProm.current = operationProm.current.then(() => {
+        return addSample({
+          chunk,
+          trackNumber,
+          isVideo,
+          codecPrivate
+        });
+      });
+      return operationProm.current;
+    },
+    addTrack: (track) => {
+      operationProm.current = operationProm.current.then(() => addTrack(track));
+      return operationProm.current;
+    },
+    updateTrackSampleRate: ({ sampleRate, trackNumber }) => {
+      currentTracks.forEach((track) => {
+        if (track.trackNumber === trackNumber) {
+          if (track.type !== "audio") {
+            throw new Error(`Tried to update sample rate of track ${trackNumber}, but it's not an audio track`);
+          }
+          track.sampleRate = sampleRate;
+        }
+      });
+    },
+    addWaitForFinishPromise: (promise) => {
+      waitForFinishPromises.push(promise);
+    },
+    async waitForFinish() {
+      MediaParserInternals6.Log.verbose(logLevel, "All write operations queued. Waiting for finish...");
+      await Promise.all(waitForFinishPromises.map((p) => p()));
+      MediaParserInternals6.Log.verbose(logLevel, "Cleanup tasks executed");
+      await operationProm.current;
+      await updateMoov();
+      await updateMdatSize();
+      MediaParserInternals6.Log.verbose(logLevel, "All write operations done. Waiting for finish...");
+      await w.waitForFinish();
+    }
+  };
+};
+
+// src/create/matroska/create-matroska-media.ts
+import { MediaParserInternals as MediaParserInternals8 } from "@remotion/media-parser";
+
+// src/create/matroska/cluster.ts
+import {
+  MediaParserInternals as MediaParserInternals7
+} from "@remotion/media-parser";
+
+// src/create/matroska/cluster-segment.ts
+var CLUSTER_MIN_VINT_WIDTH = 8;
+var createClusterSegment = (timestamp) => {
+  return makeMatroskaBytes({
+    type: "Cluster",
+    value: [
+      {
+        type: "Timestamp",
+        minVintWidth: null,
+        value: {
+          value: timestamp,
+          byteLength: null
+        }
+      }
+    ],
+    minVintWidth: CLUSTER_MIN_VINT_WIDTH
+  });
+};
+var makeSimpleBlock = ({
+  bytes,
+  trackNumber,
+  timecodeRelativeToCluster,
+  keyframe,
+  invisible,
+  lacing
+}) => {
+  const simpleBlockHeader = matroskaToHex("0xa3");
+  const headerByte = Number(keyframe) << 7 | Number(invisible) << 3 | lacing << 1;
+  const body = combineUint8Arrays([
+    getVariableInt(trackNumber, null),
+    serializeUint16(timecodeRelativeToCluster),
+    new Uint8Array([headerByte]),
+    bytes
+  ]);
+  return combineUint8Arrays([
+    simpleBlockHeader,
+    getVariableInt(body.length, null),
+    body
+  ]);
+};
+
+// src/create/matroska/cluster.ts
+var maxClusterTimestamp = 2 ** 15;
+var timestampToClusterTimestamp = (timestamp, timescale) => {
+  return Math.round(timestamp / timescale * 1000);
+};
+var canFitInCluster = ({
+  clusterStartTimestamp,
+  chunk,
+  timescale
+}) => {
+  const timecodeRelativeToCluster = timestampToClusterTimestamp(chunk.timestamp, timescale) - timestampToClusterTimestamp(clusterStartTimestamp, timescale);
+  if (timecodeRelativeToCluster < 0) {
+    throw new Error(`timecodeRelativeToCluster is negative, tried to add ${chunk.timestamp} to ${clusterStartTimestamp}`);
+  }
+  return timecodeRelativeToCluster <= maxClusterTimestamp;
+};
+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(MediaParserInternals7.matroskaElements.Cluster).byteLength;
+  let clusterSize = cluster.bytes.byteLength - matroskaToHex(MediaParserInternals7.matroskaElements.Cluster).byteLength - CLUSTER_MIN_VINT_WIDTH;
+  await writer.write(cluster.bytes);
+  const addSample = async (chunk, trackNumber) => {
+    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";
+    const simpleBlock = makeSimpleBlock({
+      bytes: chunk.data,
+      invisible: false,
+      keyframe,
+      lacing: 0,
+      trackNumber,
+      timecodeRelativeToCluster
+    });
+    clusterSize += simpleBlock.byteLength;
+    await writer.updateDataAt(clusterVIntPosition, getVariableInt(clusterSize, CLUSTER_MIN_VINT_WIDTH));
+    await writer.write(simpleBlock);
+    return { timecodeRelativeToCluster };
+  };
+  const shouldMakeNewCluster = ({
+    isVideo,
+    chunk,
+    newT
+  }) => {
+    const newTimestamp = timestampToClusterTimestamp(newT, timescale);
+    const oldTimestamp = timestampToClusterTimestamp(clusterStartTimestamp, timescale);
+    const canFit = canFitInCluster({
+      chunk,
+      clusterStartTimestamp,
+      timescale
+    });
+    if (!canFit) {
+      Log.verbose(logLevel, `Cannot fit ${chunk.timestamp} in cluster ${clusterStartTimestamp}. Creating new cluster`);
+      return true;
+    }
+    const keyframe = chunk.type === "key";
+    return newTimestamp - oldTimestamp >= 2000 && keyframe && isVideo;
+  };
+  return {
+    addSample,
+    shouldMakeNewCluster,
+    startTimestamp: clusterStartTimestamp
+  };
+};
+
+// src/create/matroska/make-duration-with-padding.ts
+var makeDurationWithPadding = (newDuration) => {
+  return makeMatroskaBytes({
+    type: "Duration",
+    value: {
+      value: newDuration,
+      size: "64"
+    },
+    minVintWidth: 8
+  });
+};
+
+// src/create/matroska/matroska-cues.ts
+var createMatroskaCues = (cues) => {
+  return makeMatroskaBytes({
+    type: "Cues",
+    minVintWidth: null,
+    value: cues.map((cue) => {
+      return {
+        type: "CuePoint",
+        value: [
+          {
+            type: "CueTime",
+            minVintWidth: null,
+            value: {
+              value: cue.time,
+              byteLength: null
+            }
+          },
+          {
+            type: "CueTrackPositions",
+            value: [
+              {
+                type: "CueTrack",
+                minVintWidth: null,
+                value: {
+                  value: cue.trackNumber,
+                  byteLength: null
+                }
+              },
+              {
+                type: "CueClusterPosition",
+                minVintWidth: null,
+                value: {
+                  value: cue.clusterPosition,
+                  byteLength: null
+                }
+              }
+            ],
+            minVintWidth: null
+          }
+        ],
+        minVintWidth: null
+      };
+    })
+  });
+};
+
+// src/create/matroska/matroska-header.ts
+var makeMatroskaHeader = () => {
+  return makeMatroskaBytes({
+    type: "Header",
+    value: [
+      {
+        minVintWidth: null,
+        type: "EBMLVersion",
+        value: {
+          value: 1,
+          byteLength: null
+        }
+      },
+      {
+        minVintWidth: null,
+        type: "EBMLReadVersion",
+        value: {
+          value: 1,
+          byteLength: null
+        }
+      },
+      {
+        type: "EBMLMaxIDLength",
+        value: {
+          byteLength: null,
+          value: 4
+        },
+        minVintWidth: null
+      },
+      {
+        type: "EBMLMaxSizeLength",
+        value: {
+          byteLength: null,
+          value: 8
+        },
+        minVintWidth: null
+      },
+      {
+        type: "DocType",
+        value: "webm",
+        minVintWidth: null
+      },
+      {
+        type: "DocTypeVersion",
+        value: {
+          byteLength: null,
+          value: 4
+        },
+        minVintWidth: null
+      },
+      {
+        type: "DocTypeReadVersion",
+        value: {
+          byteLength: null,
+          value: 2
+        },
+        minVintWidth: null
+      }
+    ],
+    minVintWidth: null
+  });
+};
+
+// src/create/matroska/matroska-info.ts
+var makeMatroskaInfo = ({ timescale }) => {
+  return makeMatroskaBytes({
+    type: "Info",
+    value: [
+      {
+        type: "TimestampScale",
+        value: {
+          value: timescale,
+          byteLength: null
+        },
+        minVintWidth: null
+      },
+      {
+        type: "MuxingApp",
+        value: "@remotion/media-parser",
+        minVintWidth: null
+      },
+      {
+        type: "WritingApp",
+        value: "@remotion/media-parser",
+        minVintWidth: null
+      },
+      makeDurationWithPadding(0)
+    ],
+    minVintWidth: null
+  });
+};
+
+// src/create/matroska/matroska-seek.ts
+var createMatroskaSeekHead = (seeks) => {
+  return padMatroskaBytes(makeMatroskaBytes({
+    type: "SeekHead",
+    minVintWidth: null,
+    value: seeks.map((seek) => {
+      return {
+        type: "Seek",
+        minVintWidth: null,
+        value: [
+          {
+            type: "SeekID",
+            minVintWidth: null,
+            value: seek.hexString
+          },
+          {
+            type: "SeekPosition",
+            minVintWidth: null,
+            value: {
+              value: seek.byte,
+              byteLength: null
+            }
+          }
+        ]
+      };
+    })
+  }), 200);
+};
+
+// src/create/matroska/matroska-segment.ts
+var MATROSKA_SEGMENT_MIN_VINT_WIDTH = 8;
+var createMatroskaSegment = (children) => {
+  return makeMatroskaBytes({
+    type: "Segment",
+    value: children,
+    minVintWidth: MATROSKA_SEGMENT_MIN_VINT_WIDTH
+  });
+};
+
+// src/create/matroska/color.ts
+var makeMatroskaColorBytes = ({
+  transferCharacteristics,
+  matrixCoefficients,
+  primaries,
+  fullRange
+}) => {
+  const rangeValue = transferCharacteristics && matrixCoefficients ? 3 : fullRange === true ? 2 : fullRange === false ? 1 : 0;
+  const primariesValue = primaries === "bt709" ? 1 : primaries === "smpte170m" ? 6 : primaries === "bt470bg" ? 5 : 2;
+  const transferChracteristicsValue = transferCharacteristics === "bt709" ? 1 : transferCharacteristics === "smpte170m" ? 6 : transferCharacteristics === "iec61966-2-1" ? 13 : 2;
+  if (matrixCoefficients === "rgb") {
+    throw new Error("Cannot encode Matroska in RGB");
+  }
+  const matrixCoefficientsValue = matrixCoefficients === "bt709" ? 1 : matrixCoefficients === "bt470bg" ? 5 : matrixCoefficients === "smpte170m" ? 6 : 2;
+  return makeMatroskaBytes({
+    type: "Colour",
+    minVintWidth: null,
+    value: [
+      transferChracteristicsValue === 2 ? null : {
+        type: "TransferCharacteristics",
+        value: {
+          value: transferChracteristicsValue,
+          byteLength: null
+        },
+        minVintWidth: null
+      },
+      matrixCoefficientsValue === 2 ? null : {
+        type: "MatrixCoefficients",
+        value: {
+          value: matrixCoefficientsValue,
+          byteLength: null
+        },
+        minVintWidth: null
+      },
+      primariesValue === 2 ? null : {
+        type: "Primaries",
+        value: {
+          value: primariesValue,
+          byteLength: null
+        },
+        minVintWidth: null
+      },
+      {
+        type: "Range",
+        value: {
+          value: rangeValue,
+          byteLength: null
+        },
+        minVintWidth: null
+      }
+    ].filter(truthy)
+  });
+};
+
+// src/create/matroska/matroska-trackentry.ts
+var makeMatroskaVideoBytes = ({
+  color,
+  width,
+  height
+}) => {
+  return makeMatroskaBytes({
+    type: "Video",
+    value: [
+      {
+        type: "PixelWidth",
+        value: {
+          value: width,
+          byteLength: null
+        },
+        minVintWidth: null
+      },
+      {
+        type: "PixelHeight",
+        value: {
+          value: height,
+          byteLength: null
+        },
+        minVintWidth: null
+      },
+      {
+        type: "FlagInterlaced",
+        value: {
+          value: 2,
+          byteLength: null
+        },
+        minVintWidth: null
+      },
+      makeMatroskaColorBytes(color)
+    ],
+    minVintWidth: null
+  });
+};
+var makeVideoCodecId = (codecId) => {
+  if (codecId === "vp8") {
+    return "V_VP8";
+  }
+  if (codecId === "vp9") {
+    return "V_VP9";
+  }
+  if (codecId === "h264") {
+    return "V_MPEG4/ISO/AVC";
+  }
+  if (codecId === "av1") {
+    return "V_AV1";
+  }
+  if (codecId === "h265") {
+    return "V_MPEGH/ISO/HEVC";
+  }
+  if (codecId === "prores") {
+    return "V_PRORES";
+  }
+  throw new Error(`Unknown codec: ${codecId}`);
+};
+var makeAudioCodecId = (codecId) => {
+  if (codecId === "opus") {
+    return "A_OPUS";
+  }
+  if (codecId === "aac") {
+    return "A_AAC";
+  }
+  if (codecId === "mp3") {
+    return "A_MPEG/L3";
+  }
+  if (codecId === "vorbis") {
+    return "A_VORBIS";
+  }
+  if (codecId === "pcm-u8") {
+    return "A_PCM/INT/LIT";
+  }
+  if (codecId === "pcm-s16") {
+    return "A_PCM/INT/LIT";
+  }
+  if (codecId === "pcm-s24") {
+    return "A_PCM/INT/LIT";
+  }
+  if (codecId === "pcm-s32") {
+    return "A_PCM/INT/LIT";
+  }
+  if (codecId === "pcm-f32") {
+    return "A_PCM/INT/LIT";
+  }
+  if (codecId === "aiff") {
+    throw new Error("aiff is not supported in Matroska");
+  }
+  throw new Error(`Unknown codec: ${codecId}`);
+};
+var makeMatroskaAudioTrackEntryBytes = ({
+  trackNumber,
+  codec,
+  numberOfChannels,
+  sampleRate,
+  codecPrivate
+}) => {
+  return makeMatroskaBytes({
+    type: "TrackEntry",
+    minVintWidth: null,
+    value: [
+      {
+        type: "TrackNumber",
+        value: {
+          value: trackNumber,
+          byteLength: null
+        },
+        minVintWidth: null
+      },
+      {
+        type: "TrackUID",
+        value: "0x188FEB95C8EFABA",
+        minVintWidth: null
+      },
+      {
+        type: "TrackType",
+        value: {
+          value: 2,
+          byteLength: null
+        },
+        minVintWidth: null
+      },
+      {
+        type: "CodecID",
+        value: makeAudioCodecId(codec),
+        minVintWidth: null
+      },
+      {
+        type: "Audio",
+        value: [
+          {
+            type: "Channels",
+            minVintWidth: null,
+            value: {
+              value: numberOfChannels,
+              byteLength: null
+            }
+          },
+          {
+            type: "SamplingFrequency",
+            minVintWidth: null,
+            value: {
+              value: sampleRate,
+              size: "64"
+            }
+          },
+          {
+            type: "BitDepth",
+            minVintWidth: null,
+            value: {
+              value: 32,
+              byteLength: null
+            }
+          }
+        ],
+        minVintWidth: null
+      },
+      codecPrivate ? {
+        type: "CodecPrivate",
+        minVintWidth: null,
+        value: codecPrivate
+      } : null
+    ].filter(Boolean)
+  });
+};
+var makeMatroskaVideoTrackEntryBytes = ({
+  color,
+  width,
+  height,
+  trackNumber,
+  codec,
+  codecPrivate
+}) => {
+  return makeMatroskaBytes({
+    type: "TrackEntry",
+    minVintWidth: null,
+    value: [
+      {
+        type: "TrackNumber",
+        value: {
+          value: trackNumber,
+          byteLength: null
+        },
+        minVintWidth: null
+      },
+      {
+        type: "TrackUID",
+        value: "0xab2171012bb9020a",
+        minVintWidth: null
+      },
+      {
+        type: "FlagLacing",
+        value: {
+          value: 0,
+          byteLength: null
+        },
+        minVintWidth: null
+      },
+      {
+        type: "Language",
+        value: "und",
+        minVintWidth: null
+      },
+      {
+        type: "FlagDefault",
+        value: {
+          value: 0,
+          byteLength: null
+        },
+        minVintWidth: null
+      },
+      {
+        type: "CodecID",
+        value: makeVideoCodecId(codec),
+        minVintWidth: null
+      },
+      {
+        type: "TrackType",
+        value: {
+          value: 1,
+          byteLength: null
+        },
+        minVintWidth: null
+      },
+      makeMatroskaVideoBytes({
+        color,
+        width,
+        height
+      }),
+      codecPrivate ? {
+        type: "CodecPrivate",
+        minVintWidth: null,
+        value: codecPrivate
+      } : null
+    ].filter(Boolean)
+  });
+};
+var makeMatroskaTracks = (tracks) => {
+  const bytesArr = tracks.map((t) => {
+    const bytes = t.type === "video" ? makeMatroskaVideoTrackEntryBytes(t) : makeMatroskaAudioTrackEntryBytes(t);
+    return bytes;
+  });
+  return padMatroskaBytes(makeMatroskaBytes({
+    type: "Tracks",
+    value: bytesArr,
+    minVintWidth: null
+  }), 500);
+};
+
+// src/create/matroska/create-matroska-media.ts
+var { matroskaElements } = MediaParserInternals8;
+var timescale = 1e6;
+var createMatroskaMedia = async ({
+  writer,
+  onBytesProgress,
+  onMillisecondsProgress,
+  filename,
+  logLevel,
+  progressTracker
+}) => {
+  const header = makeMatroskaHeader();
+  const w = await writer.createContent({ filename, mimeType: "video/webm" });
+  await w.write(header.bytes);
+  const matroskaInfo = makeMatroskaInfo({
+    timescale
+  });
+  const currentTracks = [];
+  const seeks = [];
+  const cues = [];
+  const trackNumbers = [];
+  const matroskaSegment = createMatroskaSegment([
+    ...createMatroskaSeekHead(seeks),
+    matroskaInfo,
+    ...makeMatroskaTracks(currentTracks)
+  ]);
+  const infoSegment = matroskaSegment.offsets.children.find((o) => o.field === "Info");
+  const durationOffset = (infoSegment?.children.find((c) => c.field === "Duration")?.offset ?? 0) + w.getWrittenByteCount();
+  const tracksOffset = (matroskaSegment.offsets.children.find((o) => o.field === "Tracks")?.offset ?? 0) + w.getWrittenByteCount();
+  const seekHeadOffset = (matroskaSegment.offsets.children.find((o) => o.field === "SeekHead")?.offset ?? 0) + w.getWrittenByteCount();
+  const infoOffset = (infoSegment?.offset ?? 0) + w.getWrittenByteCount();
+  if (!seekHeadOffset) {
+    throw new Error("could not get seek offset");
+  }
+  if (!durationOffset) {
+    throw new Error("could not get duration offset");
+  }
+  if (!tracksOffset) {
+    throw new Error("could not get tracks offset");
+  }
+  if (!infoOffset) {
+    throw new Error("could not get tracks offset");
+  }
+  seeks.push({
+    hexString: matroskaElements.Info,
+    byte: infoOffset - seekHeadOffset
+  });
+  seeks.push({
+    hexString: matroskaElements.Tracks,
+    byte: tracksOffset - seekHeadOffset
+  });
+  const updateSeekWrite = async () => {
+    const updatedSeek = createMatroskaSeekHead(seeks);
+    await w.updateDataAt(seekHeadOffset, combineUint8Arrays(updatedSeek.map((b) => b.bytes)));
+    onBytesProgress(w.getWrittenByteCount());
+  };
+  const segmentOffset = w.getWrittenByteCount();
+  const updateSegmentSize = async (size) => {
+    const data = getVariableInt(size, MATROSKA_SEGMENT_MIN_VINT_WIDTH);
+    await w.updateDataAt(segmentOffset + matroskaToHex(matroskaElements.Segment).byteLength, data);
+    onBytesProgress(w.getWrittenByteCount());
+  };
+  await w.write(matroskaSegment.bytes);
+  const clusterOffset = w.getWrittenByteCount();
+  let currentCluster = await makeCluster({
+    writer: w,
+    clusterStartTimestamp: 0,
+    timescale,
+    logLevel
+  });
+  seeks.push({
+    hexString: matroskaElements.Cluster,
+    byte: clusterOffset - seekHeadOffset
+  });
+  const getClusterOrMakeNew = async ({
+    chunk,
+    isVideo
+  }) => {
+    progressTracker.setPossibleLowestTimestamp(Math.min(chunk.timestamp, chunk.cts ?? Infinity, chunk.dts ?? Infinity));
+    const smallestProgress = progressTracker.getSmallestProgress();
+    if (!currentCluster.shouldMakeNewCluster({
+      newT: smallestProgress,
+      isVideo,
+      chunk
+    })) {
+      return { cluster: currentCluster, isNew: false, smallestProgress };
+    }
+    currentCluster = await makeCluster({
+      writer: w,
+      clusterStartTimestamp: smallestProgress,
+      timescale,
+      logLevel
+    });
+    return { cluster: currentCluster, isNew: true, smallestProgress };
+  };
+  const updateDuration = async (newDuration) => {
+    const blocks = makeDurationWithPadding(newDuration);
+    await w.updateDataAt(durationOffset, blocks.bytes);
+    onBytesProgress(w.getWrittenByteCount());
+  };
+  const addSample = async ({
+    chunk,
+    trackNumber,
+    isVideo
+  }) => {
+    const { cluster, isNew, smallestProgress } = await getClusterOrMakeNew({
+      chunk,
+      isVideo
+    });
+    const newDuration = Math.round((chunk.timestamp + (chunk.duration ?? 0)) / 1000);
+    await updateDuration(newDuration);
+    const { timecodeRelativeToCluster } = await cluster.addSample(chunk, trackNumber);
+    if (isNew) {
+      const newCluster = w.getWrittenByteCount();
+      cues.push({
+        time: timestampToClusterTimestamp(smallestProgress, timescale) + timecodeRelativeToCluster,
+        clusterPosition: newCluster - seekHeadOffset,
+        trackNumber
+      });
+    }
+    if (chunk.type === "key") {
+      progressTracker.updateTrackProgress(trackNumber, chunk.timestamp);
+    }
+    onBytesProgress(w.getWrittenByteCount());
+    onMillisecondsProgress(newDuration);
+  };
+  const addTrack = async (track) => {
+    currentTracks.push(track);
+    const newTracks = makeMatroskaTracks(currentTracks);
+    progressTracker.registerTrack(track.trackNumber);
+    await w.updateDataAt(tracksOffset, combineUint8Arrays(newTracks.map((b) => b.bytes)));
+  };
+  const operationProm = { current: Promise.resolve() };
+  const waitForFinishPromises = [];
+  return {
+    updateTrackSampleRate: ({ sampleRate, trackNumber }) => {
+      currentTracks.forEach((track) => {
+        if (track.trackNumber === trackNumber) {
+          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, trackNumber, isVideo }) => {
+      operationProm.current = operationProm.current.then(() => addSample({ chunk, trackNumber, isVideo }));
+      return operationProm.current;
+    },
+    addTrack: (track) => {
+      const trackNumber = currentTracks.length + 1;
+      operationProm.current = operationProm.current.then(() => addTrack({ ...track, trackNumber }));
+      trackNumbers.push(trackNumber);
+      return operationProm.current.then(() => ({ trackNumber }));
+    },
+    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/create/wav/create-wav.ts
+var numberTo32BiIntLittleEndian = (num) => {
+  return new Uint8Array([
+    num & 255,
+    num >> 8 & 255,
+    num >> 16 & 255,
+    num >> 24 & 255
+  ]);
+};
+var numberTo16BitLittleEndian = (num) => {
+  return new Uint8Array([num & 255, num >> 8 & 255]);
+};
+var BIT_DEPTH = 16;
+var BYTES_PER_SAMPLE = BIT_DEPTH / 8;
+var createWav = async ({
+  filename,
+  logLevel,
+  onBytesProgress,
+  onMillisecondsProgress,
+  writer,
+  progressTracker
+}) => {
+  const w = await writer.createContent({ filename, mimeType: "audio/wav" });
+  await w.write(new Uint8Array([82, 73, 70, 70]));
+  const sizePosition = w.getWrittenByteCount();
+  await w.write(new Uint8Array([0, 0, 0, 0]));
+  await w.write(new Uint8Array([87, 65, 86, 69]));
+  await w.write(new Uint8Array([102, 109, 116, 32]));
+  await w.write(new Uint8Array([16, 0, 0, 0]));
+  await w.write(new Uint8Array([1, 0]));
+  const channelNumPosition = w.getWrittenByteCount();
+  await w.write(new Uint8Array([1, 0]));
+  const sampleRatePosition = w.getWrittenByteCount();
+  await w.write(new Uint8Array([0, 0, 0, 0]));
+  const byteRatePosition = w.getWrittenByteCount();
+  await w.write(new Uint8Array([0, 0, 0, 0]));
+  const blockAlignPosition = w.getWrittenByteCount();
+  await w.write(new Uint8Array([0, 0]));
+  await w.write(numberTo16BitLittleEndian(BIT_DEPTH));
+  await w.write(new Uint8Array([100, 97, 116, 97]));
+  const dataSizePosition = w.getWrittenByteCount();
+  await w.write(new Uint8Array([0, 0, 0, 0]));
+  const operationProm = { current: Promise.resolve() };
+  const updateSize = async () => {
+    const size = w.getWrittenByteCount() - sizePosition - 4;
+    await w.updateDataAt(sizePosition, numberTo32BiIntLittleEndian(size));
+    const dataSize = w.getWrittenByteCount() - dataSizePosition - 4;
+    await w.updateDataAt(dataSizePosition, numberTo32BiIntLittleEndian(dataSize));
+  };
+  const updateChannelNum = async (numberOfChannels) => {
+    await w.updateDataAt(channelNumPosition, new Uint8Array([numberOfChannels, 0]));
+  };
+  const updateSampleRate = async (sampleRate) => {
+    await w.updateDataAt(sampleRatePosition, numberTo32BiIntLittleEndian(sampleRate));
+  };
+  const updateByteRate = async ({
+    sampleRate,
+    numberOfChannels
+  }) => {
+    await w.updateDataAt(byteRatePosition, numberTo32BiIntLittleEndian(sampleRate * numberOfChannels + BYTES_PER_SAMPLE));
+  };
+  const updateBlockAlign = async (numberOfChannels) => {
+    await w.updateDataAt(blockAlignPosition, new Uint8Array(numberTo16BitLittleEndian(numberOfChannels * BYTES_PER_SAMPLE)));
+  };
+  const addSample = async (chunk) => {
+    Log.verbose(logLevel, "Adding sample", chunk);
+    await w.write(chunk.data);
+    onMillisecondsProgress((chunk.timestamp + (chunk.duration ?? 0)) / 1000);
+    onBytesProgress(w.getWrittenByteCount());
+  };
+  const waitForFinishPromises = [];
+  return {
+    save: () => {
+      return w.save();
+    },
+    remove: () => {
+      return w.remove();
+    },
+    addSample: ({ chunk, trackNumber }) => {
+      if (trackNumber !== 1) {
+        throw new Error("Only one track supported for WAV");
+      }
+      operationProm.current = operationProm.current.then(() => addSample(chunk));
+      progressTracker.updateTrackProgress(trackNumber, chunk.timestamp);
+      return operationProm.current;
+    },
+    updateTrackSampleRate: () => {
+      throw new Error("updateTrackSampleRate() not implemented for WAV encoder");
+    },
+    addWaitForFinishPromise: (promise) => {
+      waitForFinishPromises.push(promise);
+    },
+    async waitForFinish() {
+      Log.verbose(logLevel, "All write operations queued. Waiting for finish...");
+      await Promise.all(waitForFinishPromises.map((p) => p()));
+      await operationProm.current;
+      await updateSize();
+      await w.waitForFinish();
+    },
+    addTrack: async (track) => {
+      if (track.type !== "audio") {
+        throw new Error("Only audio tracks supported for WAV");
+      }
+      await updateChannelNum(track.numberOfChannels);
+      await updateSampleRate(track.sampleRate);
+      await updateByteRate({
+        sampleRate: track.sampleRate,
+        numberOfChannels: track.numberOfChannels
+      });
+      await updateBlockAlign(track.numberOfChannels);
+      progressTracker.registerTrack(1);
+      return Promise.resolve({ trackNumber: 1 });
+    }
+  };
+};
+
+// src/select-container-creator.ts
 var selectContainerCreator = (container) => {
   if (container === "mp4") {
-    return MediaParserInternals8.createIsoBaseMedia;
+    return createIsoBaseMedia;
   }
   if (container === "wav") {
-    return MediaParserInternals8.createWav;
+    return createWav;
   }
   if (container === "webm") {
-    return MediaParserInternals8.createMatroskaMedia;
+    return createMatroskaMedia;
   }
   throw new Error(`Unsupported container: ${container}`);
 };
@@ -1821,7 +4299,7 @@ var convertMedia = async function({
   if (videoCodec && videoCodec !== "vp8" && videoCodec !== "vp9") {
     return Promise.reject(new TypeError('Only `videoCodec: "vp8"` and `videoCodec: "vp9"` are supported currently'));
   }
-  const { resolve, reject, getPromiseToImmediatelyReturn } = MediaParserInternals9.withResolversAndWaitForReturn();
+  const { resolve, reject, getPromiseToImmediatelyReturn } = withResolversAndWaitForReturn();
   const controller = new AbortController;
   const abortConversion = (errCause) => {
     reject(errCause);
@@ -1839,7 +4317,7 @@ var convertMedia = async function({
     everyMilliseconds: progressIntervalInMs ?? 100,
     signal: controller.signal
   });
-  const progressTracker = MediaParserInternals9.makeProgressTracker();
+  const progressTracker = makeProgressTracker();
   const state = await creator({
     filename: generateOutputFilename(src, container),
     writer: await autoSelectWriter(writer, logLevel),