@bendyline/squisq-video-react 2.5.28 → 2.5.29

package/dist/{chunk-EJ3DVPFF.js → chunk-MOIVICAD.js}

@@ -587,6 +587,9 @@ var roundToMultiple = (value, multiple) => {
 var roundToDivisor = (value, multiple) => {
   return Math.round(value * multiple) / multiple;
 };
+var floorToDivisor = (value, multiple) => {
+  return Math.floor(value * multiple) / multiple;
+};
 var ilog = (x) => {
   let ret = 0;
   while (x) {
@@ -674,6 +677,9 @@ var missingWebCodecsClassMessage = (className) => {
   }
   return `${className} is not available in this environment.`;
 };
+var isCodecReclaimedError = (error) => {
+  return error instanceof DOMException && error.name === "QuotaExceededError" && /reclaimed/i.test(error.message);
+};
 var NativePromiseConstructor = (async () => {
 })().constructor;
 var isThenable = (value) => {
@@ -803,6 +809,9 @@ var validateRectangle = (rect, propertyPath) => {
     throw new TypeError(`${propertyPath}.height must be a non-negative integer.`);
   }
 };
+var wait = (ms) => {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+};
 var toArray = (x) => {
   if (Array.isArray(x)) {
     return x;
@@ -3860,6 +3869,50 @@ var AVC_LEVEL_TABLE = [
   { maxMacroblocks: 139264, maxBitrate: 8e8, maxDpbMbs: 696320, level: 62 }
   // Level 6.2
 ];
+var HEVC_LEVEL_TABLE = [
+  { maxPictureSize: 36864, maxBitrate: 128e3, tier: "L", level: 30 },
+  // Level 1 (Low Tier)
+  { maxPictureSize: 122880, maxBitrate: 15e5, tier: "L", level: 60 },
+  // Level 2 (Low Tier)
+  { maxPictureSize: 245760, maxBitrate: 3e6, tier: "L", level: 63 },
+  // Level 2.1 (Low Tier)
+  { maxPictureSize: 552960, maxBitrate: 6e6, tier: "L", level: 90 },
+  // Level 3 (Low Tier)
+  { maxPictureSize: 983040, maxBitrate: 1e7, tier: "L", level: 93 },
+  // Level 3.1 (Low Tier)
+  { maxPictureSize: 2228224, maxBitrate: 12e6, tier: "L", level: 120 },
+  // Level 4 (Low Tier)
+  { maxPictureSize: 2228224, maxBitrate: 3e7, tier: "H", level: 120 },
+  // Level 4 (High Tier)
+  { maxPictureSize: 2228224, maxBitrate: 2e7, tier: "L", level: 123 },
+  // Level 4.1 (Low Tier)
+  { maxPictureSize: 2228224, maxBitrate: 5e7, tier: "H", level: 123 },
+  // Level 4.1 (High Tier)
+  { maxPictureSize: 8912896, maxBitrate: 25e6, tier: "L", level: 150 },
+  // Level 5 (Low Tier)
+  { maxPictureSize: 8912896, maxBitrate: 1e8, tier: "H", level: 150 },
+  // Level 5 (High Tier)
+  { maxPictureSize: 8912896, maxBitrate: 4e7, tier: "L", level: 153 },
+  // Level 5.1 (Low Tier)
+  { maxPictureSize: 8912896, maxBitrate: 16e7, tier: "H", level: 153 },
+  // Level 5.1 (High Tier)
+  { maxPictureSize: 8912896, maxBitrate: 6e7, tier: "L", level: 156 },
+  // Level 5.2 (Low Tier)
+  { maxPictureSize: 8912896, maxBitrate: 24e7, tier: "H", level: 156 },
+  // Level 5.2 (High Tier)
+  { maxPictureSize: 35651584, maxBitrate: 6e7, tier: "L", level: 180 },
+  // Level 6 (Low Tier)
+  { maxPictureSize: 35651584, maxBitrate: 24e7, tier: "H", level: 180 },
+  // Level 6 (High Tier)
+  { maxPictureSize: 35651584, maxBitrate: 12e7, tier: "L", level: 183 },
+  // Level 6.1 (Low Tier)
+  { maxPictureSize: 35651584, maxBitrate: 48e7, tier: "H", level: 183 },
+  // Level 6.1 (High Tier)
+  { maxPictureSize: 35651584, maxBitrate: 24e7, tier: "L", level: 186 },
+  // Level 6.2 (Low Tier)
+  { maxPictureSize: 35651584, maxBitrate: 8e8, tier: "H", level: 186 }
+  // Level 6.2 (High Tier)
+];
 var VP9_LEVEL_TABLE = [
   { maxPictureSize: 36864, maxBitrate: 2e5, level: 10 },
   // Level 1
@@ -3890,6 +3943,56 @@ var VP9_LEVEL_TABLE = [
   { maxPictureSize: 35651584, maxBitrate: 48e7, level: 62 }
   // Level 6.2
 ];
+var AV1_LEVEL_TABLE = [
+  { maxPictureSize: 147456, maxBitrate: 15e5, tier: "M", level: 0 },
+  // Level 2.0 (Main Tier)
+  { maxPictureSize: 278784, maxBitrate: 3e6, tier: "M", level: 1 },
+  // Level 2.1 (Main Tier)
+  { maxPictureSize: 665856, maxBitrate: 6e6, tier: "M", level: 4 },
+  // Level 3.0 (Main Tier)
+  { maxPictureSize: 1065024, maxBitrate: 1e7, tier: "M", level: 5 },
+  // Level 3.1 (Main Tier)
+  { maxPictureSize: 2359296, maxBitrate: 12e6, tier: "M", level: 8 },
+  // Level 4.0 (Main Tier)
+  { maxPictureSize: 2359296, maxBitrate: 3e7, tier: "H", level: 8 },
+  // Level 4.0 (High Tier)
+  { maxPictureSize: 2359296, maxBitrate: 2e7, tier: "M", level: 9 },
+  // Level 4.1 (Main Tier)
+  { maxPictureSize: 2359296, maxBitrate: 5e7, tier: "H", level: 9 },
+  // Level 4.1 (High Tier)
+  { maxPictureSize: 8912896, maxBitrate: 3e7, tier: "M", level: 12 },
+  // Level 5.0 (Main Tier)
+  { maxPictureSize: 8912896, maxBitrate: 1e8, tier: "H", level: 12 },
+  // Level 5.0 (High Tier)
+  { maxPictureSize: 8912896, maxBitrate: 4e7, tier: "M", level: 13 },
+  // Level 5.1 (Main Tier)
+  { maxPictureSize: 8912896, maxBitrate: 16e7, tier: "H", level: 13 },
+  // Level 5.1 (High Tier)
+  { maxPictureSize: 8912896, maxBitrate: 6e7, tier: "M", level: 14 },
+  // Level 5.2 (Main Tier)
+  { maxPictureSize: 8912896, maxBitrate: 24e7, tier: "H", level: 14 },
+  // Level 5.2 (High Tier)
+  { maxPictureSize: 35651584, maxBitrate: 6e7, tier: "M", level: 15 },
+  // Level 5.3 (Main Tier)
+  { maxPictureSize: 35651584, maxBitrate: 24e7, tier: "H", level: 15 },
+  // Level 5.3 (High Tier)
+  { maxPictureSize: 35651584, maxBitrate: 6e7, tier: "M", level: 16 },
+  // Level 6.0 (Main Tier)
+  { maxPictureSize: 35651584, maxBitrate: 24e7, tier: "H", level: 16 },
+  // Level 6.0 (High Tier)
+  { maxPictureSize: 35651584, maxBitrate: 1e8, tier: "M", level: 17 },
+  // Level 6.1 (Main Tier)
+  { maxPictureSize: 35651584, maxBitrate: 48e7, tier: "H", level: 17 },
+  // Level 6.1 (High Tier)
+  { maxPictureSize: 35651584, maxBitrate: 16e7, tier: "M", level: 18 },
+  // Level 6.2 (Main Tier)
+  { maxPictureSize: 35651584, maxBitrate: 8e8, tier: "H", level: 18 },
+  // Level 6.2 (High Tier)
+  { maxPictureSize: 35651584, maxBitrate: 16e7, tier: "M", level: 19 },
+  // Level 6.3 (Main Tier)
+  { maxPictureSize: 35651584, maxBitrate: 8e8, tier: "H", level: 19 }
+  // Level 6.3 (High Tier)
+];
 var VP9_DEFAULT_SUFFIX = ".01.01.01.01.00";
 var AV1_DEFAULT_SUFFIX = ".0.110.01.01.01.0";
 var PRORES_FOURCCS = [
@@ -3916,6 +4019,72 @@ var DTS_FOURCCS = [
   "dtse"
   // DTS Express
 ];
+var PRORES_PROFILE_TARGET_BITRATES = [
+  { fourCc: "apco", bitrate: 45e6, alpha: false },
+  // 422 Proxy
+  { fourCc: "apcs", bitrate: 102e6, alpha: false },
+  // 422 LT
+  { fourCc: "apcn", bitrate: 147e6, alpha: false },
+  // 422 Standard
+  { fourCc: "apch", bitrate: 22e7, alpha: false },
+  // 422 HQ
+  { fourCc: "ap4h", bitrate: 33e7, alpha: true },
+  // 4444
+  { fourCc: "ap4x", bitrate: 5e8, alpha: true }
+  // 4444 XQ
+];
+var buildVideoCodecString = (codec, width, height, bitrate, alpha) => {
+  if (codec === "avc") {
+    const profileIndication = 100;
+    const totalMacroblocks = Math.ceil(width / 16) * Math.ceil(height / 16);
+    const levelInfo = AVC_LEVEL_TABLE.find((level) => totalMacroblocks <= level.maxMacroblocks && bitrate <= level.maxBitrate) ?? last(AVC_LEVEL_TABLE);
+    const levelIndication = levelInfo ? levelInfo.level : 0;
+    const hexProfileIndication = profileIndication.toString(16).padStart(2, "0");
+    const hexProfileCompatibility = "00";
+    const hexLevelIndication = levelIndication.toString(16).padStart(2, "0");
+    return `avc1.${hexProfileIndication}${hexProfileCompatibility}${hexLevelIndication}`;
+  } else if (codec === "hevc") {
+    const profilePrefix = "";
+    const profileIdc = 1;
+    const compatibilityFlags = "6";
+    const pictureSize = width * height;
+    const levelInfo = HEVC_LEVEL_TABLE.find((level) => pictureSize <= level.maxPictureSize && bitrate <= level.maxBitrate) ?? last(HEVC_LEVEL_TABLE);
+    const constraintFlags = "B0";
+    return `hev1.${profilePrefix}${profileIdc}.${compatibilityFlags}.${levelInfo.tier}${levelInfo.level}.${constraintFlags}`;
+  } else if (codec === "vp8") {
+    return "vp8";
+  } else if (codec === "vp9") {
+    const profile = "00";
+    const pictureSize = width * height;
+    const levelInfo = VP9_LEVEL_TABLE.find((level) => pictureSize <= level.maxPictureSize && bitrate <= level.maxBitrate) ?? last(VP9_LEVEL_TABLE);
+    const bitDepth = "08";
+    return `vp09.${profile}.${levelInfo.level.toString().padStart(2, "0")}.${bitDepth}`;
+  } else if (codec === "av1") {
+    const profile = 0;
+    const pictureSize = width * height;
+    const levelInfo = AV1_LEVEL_TABLE.find((level2) => pictureSize <= level2.maxPictureSize && bitrate <= level2.maxBitrate) ?? last(AV1_LEVEL_TABLE);
+    const level = levelInfo.level.toString().padStart(2, "0");
+    const bitDepth = "08";
+    return `av01.${profile}.${level}${levelInfo.tier}.${bitDepth}`;
+  } else if (codec === "prores") {
+    const referencePixels = 1920 * 1080;
+    const scaleFactor = Math.pow(width * height / referencePixels, 0.95);
+    const candidates = PRORES_PROFILE_TARGET_BITRATES.filter((x) => x.alpha === alpha);
+    let bestFourCc = candidates[0].fourCc;
+    let smallestDifference = Infinity;
+    for (const { fourCc, bitrate: targetBitrate } of candidates) {
+      const difference = Math.abs(targetBitrate * scaleFactor - bitrate);
+      if (difference < smallestDifference) {
+        smallestDifference = difference;
+        bestFourCc = fourCc;
+      }
+    }
+    return bestFourCc;
+  } else {
+    assertNever(codec);
+  }
+  throw new TypeError(`Unhandled codec '${String(codec)}'.`);
+};
 var generateVp9CodecConfigurationFromCodecString = (codecString) => {
   const parts = codecString.split(".");
   const profile = Number(parts[1]);
@@ -4312,6 +4481,24 @@ var inferCodecFromCodecString = (codecString) => {
   }
   return null;
 };
+var getVideoEncoderConfigExtension = (codec) => {
+  if (codec === "avc") {
+    return {
+      avc: {
+        format: "avc"
+        // Ensure the format is not Annex B
+      }
+    };
+  } else if (codec === "hevc") {
+    return {
+      hevc: {
+        format: "hevc"
+        // Ensure the format is not Annex B
+      }
+    };
+  }
+  return {};
+};
 var getAudioEncoderConfigExtension = (codec) => {
   if (codec === "aac") {
     return {
@@ -17520,7 +17707,148 @@ var audioSampleToInterleavedFormat = (sample, format) => {
 };
 
 // ../../node_modules/mediabunny/dist/modules/src/encode.js
+var canEncodeVideoMemo = /* @__PURE__ */ new Map();
 var canEncodeAudioMemo = /* @__PURE__ */ new Map();
+var validateVideoEncodingConfig = (config) => {
+  if (!config || typeof config !== "object") {
+    throw new TypeError("Encoding config must be an object.");
+  }
+  if (!VIDEO_CODECS.includes(config.codec)) {
+    throw new TypeError(`Invalid video codec '${config.codec}'. Must be one of: ${VIDEO_CODECS.join(", ")}.`);
+  }
+  const bitrate = config.bitrate;
+  if (config.quality === void 0 && bitrate === void 0) {
+    throw new TypeError("config.quality must be provided.");
+  }
+  if (config.quality !== void 0 && bitrate !== void 0) {
+    throw new TypeError("config.quality and config.bitrate cannot both be provided.");
+  }
+  if (config.quality !== void 0 && !(config.quality instanceof Quality)) {
+    throw new TypeError("config.quality, when provided, must be a Quality.");
+  }
+  if (bitrate !== void 0 && !(bitrate instanceof Quality) && (!Number.isInteger(bitrate) || bitrate <= 0)) {
+    throw new TypeError("config.bitrate, when provided, must be a positive integer or a quality.");
+  }
+  if (config.keyFrameInterval !== void 0 && (!Number.isFinite(config.keyFrameInterval) || config.keyFrameInterval < 0)) {
+    throw new TypeError("config.keyFrameInterval, when provided, must be a non-negative number.");
+  }
+  if (config.sizeChangeBehavior !== void 0 && !["deny", "passThrough", "fill", "contain", "cover"].includes(config.sizeChangeBehavior)) {
+    throw new TypeError("config.sizeChangeBehavior, when provided, must be 'deny', 'passThrough', 'fill', 'contain' or 'cover'.");
+  }
+  if (config.transform !== void 0) {
+    if (typeof config.transform !== "object" || !config.transform) {
+      throw new TypeError("config.transform, when provided, must be an object.");
+    }
+    if (config.transform.width !== void 0 && (!Number.isInteger(config.transform.width) || config.transform.width <= 0)) {
+      throw new TypeError("config.transform.width, when provided, must be a positive integer.");
+    }
+    if (config.transform.height !== void 0 && (!Number.isInteger(config.transform.height) || config.transform.height <= 0)) {
+      throw new TypeError("config.transform.height, when provided, must be a positive integer.");
+    }
+    if (config.transform.fit !== void 0 && !["fill", "contain", "cover"].includes(config.transform.fit)) {
+      throw new TypeError('config.transform.fit, when provided, must be one of "fill", "contain", or "cover".');
+    }
+    if (config.transform.width !== void 0 && config.transform.height !== void 0 && config.transform.fit === void 0 && !["fill", "contain", "cover"].includes(config.sizeChangeBehavior)) {
+      throw new TypeError("When both config.transform.width and config.transform.height are provided, config.transform.fit must also be provided.");
+    }
+    if (config.transform.fit !== void 0 && ["fill", "contain", "cover"].includes(config.sizeChangeBehavior) && config.transform.fit !== config.sizeChangeBehavior) {
+      throw new TypeError("config.transform.fit, when provided, cannot differ from config.sizeChangeBehavior when config.sizeChangeBehavior is 'fill', 'contain' or 'cover', as sizeChangeBehavior already determines the fitting algorithm.");
+    }
+    if (config.transform.rotate !== void 0 && ![0, 90, 180, 270].includes(config.transform.rotate)) {
+      throw new TypeError("config.transform.rotate, when provided, must be 0, 90, 180 or 270.");
+    }
+    if (config.transform.flip !== void 0 && typeof config.transform.flip !== "boolean") {
+      throw new TypeError("config.transform.flip, when provided, must be a boolean.");
+    }
+    if (config.transform.crop !== void 0) {
+      validateCropRectangle(config.transform.crop, "config.transform.");
+    }
+    if (config.transform.process !== void 0 && typeof config.transform.process !== "function") {
+      throw new TypeError("config.transform.process, when provided, must be a function.");
+    }
+    if (config.transform.frameRate !== void 0 && (!Number.isFinite(config.transform.frameRate) || config.transform.frameRate <= 0)) {
+      throw new TypeError("config.transform.frameRate, when provided, must be a finite positive number.");
+    }
+    if (config.transform.force !== void 0 && typeof config.transform.force !== "boolean") {
+      throw new TypeError("config.transform.force, when provided, must be a boolean.");
+    }
+  }
+  if (config.onEncodedPacket !== void 0 && typeof config.onEncodedPacket !== "function") {
+    throw new TypeError("config.onEncodedPacket, when provided, must be a function.");
+  }
+  if (config.onEncoderConfig !== void 0 && typeof config.onEncoderConfig !== "function") {
+    throw new TypeError("config.onEncoderConfig, when provided, must be a function.");
+  }
+  if (config.onEncodedSample !== void 0 && typeof config.onEncodedSample !== "function") {
+    throw new TypeError("config.onEncodedSample, when provided, must be a function.");
+  }
+  validateVideoEncodingAdditionalOptions(config.codec, config);
+};
+var validateVideoEncodingAdditionalOptions = (codec, options) => {
+  if (!options || typeof options !== "object") {
+    throw new TypeError("Encoding options must be an object.");
+  }
+  if (options.alpha !== void 0 && !["discard", "keep"].includes(options.alpha)) {
+    throw new TypeError("options.alpha, when provided, must be 'discard' or 'keep'.");
+  }
+  const bitrateMode = options.bitrateMode;
+  if (bitrateMode !== void 0 && !["constant", "variable"].includes(bitrateMode)) {
+    throw new TypeError("bitrateMode, when provided, must be 'constant' or 'variable'.");
+  }
+  if (options.latencyMode !== void 0 && !["quality", "realtime"].includes(options.latencyMode)) {
+    throw new TypeError("latencyMode, when provided, must be 'quality' or 'realtime'.");
+  }
+  if (options.fullCodecString !== void 0 && typeof options.fullCodecString !== "string") {
+    throw new TypeError("fullCodecString, when provided, must be a string.");
+  }
+  if (options.fullCodecString !== void 0 && inferCodecFromCodecString(options.fullCodecString) !== codec) {
+    throw new TypeError(`fullCodecString, when provided, must be a string that matches the specified codec (${codec}).`);
+  }
+  if (options.hardwareAcceleration !== void 0 && !["no-preference", "prefer-hardware", "prefer-software"].includes(options.hardwareAcceleration)) {
+    throw new TypeError("hardwareAcceleration, when provided, must be 'no-preference', 'prefer-hardware' or 'prefer-software'.");
+  }
+  if (options.scalabilityMode !== void 0 && typeof options.scalabilityMode !== "string") {
+    throw new TypeError("scalabilityMode, when provided, must be a string.");
+  }
+  if (options.contentHint !== void 0 && typeof options.contentHint !== "string") {
+    throw new TypeError("contentHint, when provided, must be a string.");
+  }
+};
+var buildVideoEncoderConfigs = (options) => {
+  const fallbackBitrateMode = options.bitrateMode;
+  const rateControl = options.quality._toVideoRateControl(options.codec, options.width, options.height, fallbackBitrateMode);
+  const buildConfig = (bitrate, bitrateMode, bitrateEstimate) => ({
+    codec: options.fullCodecString ?? buildVideoCodecString(options.codec, options.width, options.height, bitrateEstimate, options.alpha === "keep"),
+    width: options.width,
+    height: options.height,
+    displayWidth: options.squarePixelWidth,
+    displayHeight: options.squarePixelHeight,
+    bitrate,
+    bitrateMode,
+    alpha: options.alpha ?? "discard",
+    framerate: options.framerate,
+    latencyMode: options.latencyMode,
+    hardwareAcceleration: options.hardwareAcceleration,
+    scalabilityMode: options.scalabilityMode,
+    contentHint: options.contentHint,
+    ...getVideoEncoderConfigExtension(options.codec)
+  });
+  const candidates = [];
+  if (rateControl.quantizer !== null) {
+    candidates.push({
+      config: buildConfig(void 0, "quantizer", rateControl.bitrate),
+      quantizer: rateControl.quantizer
+    });
+  }
+  if (rateControl.bitrateMode !== "quantizer") {
+    candidates.push({
+      config: buildConfig(rateControl.bitrate, rateControl.bitrateMode, rateControl.bitrate),
+      quantizer: null
+    });
+  }
+  assert(candidates.length > 0);
+  return candidates;
+};
 var validateAudioEncodingConfig = (config) => {
   if (!config || typeof config !== "object") {
     throw new TypeError("Encoding config must be an object.");
@@ -17788,6 +18116,129 @@ var computeVideoBitrate = (codec, width, height, factor) => {
   const finalBitrate = codecAdjustedBitrate * factor;
   return Math.ceil(finalBitrate / 1e3) * 1e3;
 };
+var buildQuantizerEncodeOptions = (codec, quantizer) => {
+  if (codec === "avc") {
+    return { avc: { quantizer } };
+  } else if (codec === "hevc") {
+    return { hevc: { quantizer } };
+  } else if (codec === "vp9") {
+    return { vp9: { quantizer } };
+  } else if (codec === "av1") {
+    return { av1: { quantizer } };
+  }
+  assert(false);
+};
+var QUALITY_HIGH = /* @__PURE__ */ new Quality("high");
+var canEncodeVideo = async (codec, options = {}) => {
+  const {
+    width = 1280,
+    height = 720,
+    quality,
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
+    bitrate,
+    frameRate,
+    ...restOptions
+  } = options;
+  if (!VIDEO_CODECS.includes(codec)) {
+    return false;
+  }
+  if (!Number.isInteger(width) || width <= 0) {
+    throw new TypeError("width must be a positive integer.");
+  }
+  if (!Number.isInteger(height) || height <= 0) {
+    throw new TypeError("height must be a positive integer.");
+  }
+  if (quality !== void 0 && !(quality instanceof Quality)) {
+    throw new TypeError("quality, when provided, must be a Quality.");
+  }
+  if (quality !== void 0 && bitrate !== void 0) {
+    throw new TypeError("quality and bitrate cannot both be provided.");
+  }
+  if (bitrate !== void 0 && !(bitrate instanceof Quality) && (!Number.isInteger(bitrate) || bitrate <= 0)) {
+    throw new TypeError("bitrate must be a positive integer or a quality.");
+  }
+  if (frameRate !== void 0 && (!Number.isFinite(frameRate) || frameRate <= 0)) {
+    throw new TypeError("frameRate, when provided, must be a finite positive number.");
+  }
+  validateVideoEncodingAdditionalOptions(codec, restOptions);
+  const resolvedQuality = resolveQuality(quality, bitrate) ?? new Quality("medium");
+  let candidates;
+  try {
+    candidates = buildVideoEncoderConfigs({
+      codec,
+      width,
+      height,
+      quality: resolvedQuality,
+      framerate: frameRate,
+      ...restOptions,
+      alpha: "discard"
+      // Since we handle alpha ourselves
+    });
+  } catch {
+    return false;
+  }
+  const key = JSON.stringify(candidates);
+  const memoized = canEncodeVideoMemo.get(key);
+  if (memoized) {
+    return memoized;
+  }
+  const promise = (async () => {
+    for (const { config } of candidates) {
+      if (customVideoEncoders.some((x) => x.supports(codec, config))) {
+        return true;
+      }
+    }
+    if (typeof VideoEncoder === "undefined") {
+      return false;
+    }
+    const hasOddDimension = width % 2 === 1 || height % 2 === 1;
+    if (hasOddDimension && (codec === "avc" || codec === "hevc")) {
+      return false;
+    }
+    for (const { config, quantizer } of candidates) {
+      try {
+        const support = await VideoEncoder.isConfigSupported(config);
+        if (!support.supported) {
+          continue;
+        }
+      } catch {
+        continue;
+      }
+      if (!isFirefox()) {
+        return true;
+      }
+      const success = await new Promise(async (resolve) => {
+        try {
+          const encoder = new VideoEncoder({
+            output: () => {
+            },
+            error: () => resolve(false)
+          });
+          encoder.configure(config);
+          const frameData = new Uint8Array(width * height * 4);
+          const frame = new VideoFrame(frameData, {
+            format: "RGBA",
+            codedWidth: width,
+            codedHeight: height,
+            timestamp: 0
+          });
+          encoder.encode(frame, quantizer !== null ? buildQuantizerEncodeOptions(codec, quantizer) : void 0);
+          frame.close();
+          await encoder.flush();
+          resolve(true);
+        } catch {
+          resolve(false);
+        }
+      });
+      if (success) {
+        return true;
+      }
+    }
+    return false;
+  })();
+  canEncodeVideoMemo.set(key, promise);
+  return promise;
+};
 var canEncodeAudio = async (codec, options = {}) => {
   const {
     numberOfChannels = 2,
@@ -17858,10 +18309,19 @@ var resolveQuality = (quality, bitrate) => {
   }
   return bitrate instanceof Quality ? bitrate : new Quality({ bitrate });
 };
+var getFirstEncodableVideoCodec = async (checkedCodecs, options) => {
+  for (const codec of checkedCodecs) {
+    if (await canEncodeVideo(codec, options)) {
+      return codec;
+    }
+  }
+  return null;
+};
 
 // ../../node_modules/mediabunny/dist/modules/src/custom-coder.js
 var customVideoDecoders = [];
 var customAudioDecoders = [];
+var customVideoEncoders = [];
 var customAudioEncoders = [];
 
 // ../../node_modules/mediabunny/dist/modules/src/pcm.js
@@ -22130,6 +22590,64 @@ var AudioResampler = class {
 };
 
 // ../../node_modules/mediabunny/dist/modules/src/media-source.js
+var __addDisposableResource2 = function(env, value, async) {
+  if (value !== null && value !== void 0) {
+    if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+    var dispose, inner;
+    if (async) {
+      if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+      dispose = value[Symbol.asyncDispose];
+    }
+    if (dispose === void 0) {
+      if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+      dispose = value[Symbol.dispose];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    env.stack.push({ value, dispose, async });
+  } else if (async) {
+    env.stack.push({ async: true });
+  }
+  return value;
+};
+var __disposeResources2 = /* @__PURE__ */ (function(SuppressedError2) {
+  return function(env) {
+    function fail(e) {
+      env.error = env.hasError ? new SuppressedError2(e, env.error, "An error was suppressed during disposal.") : e;
+      env.hasError = true;
+    }
+    var r, s = 0;
+    function next() {
+      while (r = env.stack.pop()) {
+        try {
+          if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+          if (r.dispose) {
+            var result = r.dispose.call(r.value);
+            if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+              fail(e);
+              return next();
+            });
+          } else s |= 1;
+        } catch (e) {
+          fail(e);
+        }
+      }
+      if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+      if (env.hasError) throw env.error;
+    }
+    return next();
+  };
+})(typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+  var e = new Error(message);
+  return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 var MediaSource = class {
   constructor() {
     this._connectedTrack = null;
@@ -22205,6 +22723,776 @@ var VideoSource = class extends MediaSource {
     this._codec = codec;
   }
 };
+var maybeEnsureIsKeyPacket = (track, packet) => {
+  if (track.metadata.hasOnlyKeyPackets && packet.type !== "key") {
+    throw new Error("Cannot add non-key packets to a hasOnlyKeyPackets video track.");
+  }
+};
+var VideoEncoderWrapper = class {
+  setError(error) {
+    if (!this.errorSet) {
+      this.error = error;
+      this.errorSet = true;
+    }
+  }
+  constructor(source, encodingConfig) {
+    this.source = source;
+    this.encodingConfig = encodingConfig;
+    this.ensureEncoderPromise = null;
+    this.encoderInitialized = false;
+    this.encoder = null;
+    this.encoderConfig = null;
+    this.encodersReclaimed = false;
+    this.muxer = null;
+    this.lastMultipleOfKeyFrameInterval = -1;
+    this.emittedEncoderPackets = 0;
+    this.codedWidth = null;
+    this.codedHeight = null;
+    this.outputWidth = null;
+    this.outputHeight = null;
+    this.frameRateLastSample = null;
+    this.frameRateLastTimestamp = null;
+    this.frameRateLastEndTimestamp = null;
+    this.preciseTimings = [];
+    this.customEncoder = null;
+    this.customEncoderCallSerializer = new CallSerializer();
+    this.customEncoderQueueSize = 0;
+    this.defaultEncodeOptions = {};
+    this.alphaEncoder = null;
+    this.splitter = null;
+    this.splitterCreationFailed = false;
+    this.alphaFrameQueue = [];
+    this.error = null;
+    this.errorSet = false;
+    this.lastMuxerPromise = Promise.resolve();
+    this.closed = false;
+  }
+  async add(videoSample, shouldClose, encodeOptions) {
+    const originalSample = videoSample;
+    try {
+      this.checkForEncoderError();
+      this.source._ensureValidAdd();
+      const config = this.encodingConfig;
+      const sizeChangeBehavior = config.sizeChangeBehavior ?? "deny";
+      let isSizeChange = false;
+      if (this.codedWidth !== null && this.codedHeight !== null) {
+        if (videoSample.codedWidth !== this.codedWidth || videoSample.codedHeight !== this.codedHeight) {
+          isSizeChange = true;
+          if (sizeChangeBehavior === "deny") {
+            throw new Error(`Video sample size must remain constant. Expected ${this.codedWidth}x${this.codedHeight}, got ${videoSample.codedWidth}x${videoSample.codedHeight}. To allow the sample size to change over time, set \`sizeChangeBehavior\` to a value other than 'deny' in the encoding options.`);
+          }
+        }
+      } else {
+        this.codedWidth = videoSample.codedWidth;
+        this.codedHeight = videoSample.codedHeight;
+      }
+      const hasTransformConfig = config.transform?.width !== void 0 || config.transform?.height !== void 0 || config.transform?.rotate !== void 0 || config.transform?.flip !== void 0 || config.transform?.crop !== void 0 || config.transform?.force === true;
+      const needsTransform = hasTransformConfig || isSizeChange && sizeChangeBehavior !== "passThrough";
+      if (needsTransform) {
+        let targetWidth = config.transform?.width;
+        let targetHeight = config.transform?.height;
+        let appliedFit = config.transform?.fit ?? "fill";
+        if (isSizeChange && sizeChangeBehavior !== "passThrough") {
+          assert(this.outputWidth);
+          assert(this.outputHeight);
+          assert(sizeChangeBehavior !== "deny");
+          targetWidth = this.outputWidth;
+          targetHeight = this.outputHeight;
+          appliedFit = sizeChangeBehavior;
+        }
+        const transformed = await videoSample.transform({
+          width: targetWidth,
+          height: targetHeight,
+          roundDimensionsTo: 2,
+          crop: config.transform?.crop,
+          rotate: config.transform?.rotate,
+          flip: config.transform?.flip,
+          fit: appliedFit,
+          alpha: config.alpha
+        });
+        if (this.outputWidth === null || this.outputHeight === null) {
+          this.outputWidth = transformed.displayWidth;
+          this.outputHeight = transformed.displayHeight;
+        }
+        if (shouldClose) {
+          videoSample.close();
+        }
+        videoSample = transformed;
+        shouldClose = true;
+      } else {
+        if (this.outputWidth === null || this.outputHeight === null) {
+          this.outputWidth = videoSample.codedWidth;
+          this.outputHeight = videoSample.codedHeight;
+        }
+      }
+      const frameRate = config.transform?.frameRate;
+      if (frameRate !== void 0) {
+        const originalEndTimestamp = videoSample.timestamp + videoSample.duration;
+        const alignedTimestamp = floorToDivisor(videoSample.timestamp, frameRate);
+        if (this.frameRateLastSample !== null) {
+          if (alignedTimestamp <= this.frameRateLastTimestamp) {
+            this.frameRateLastSample.close();
+            this.frameRateLastSample = videoSample.clone();
+            this.frameRateLastEndTimestamp = originalEndTimestamp;
+            return;
+          } else {
+            await this.padFrameRate(alignedTimestamp, encodeOptions);
+          }
+        }
+        if (videoSample === originalSample) {
+          videoSample = videoSample.clone();
+          shouldClose = true;
+        }
+        videoSample.setTimestamp(alignedTimestamp);
+        videoSample.setDuration(1 / frameRate);
+        this.frameRateLastSample?.close();
+        this.frameRateLastSample = videoSample.clone();
+        this.frameRateLastTimestamp = alignedTimestamp;
+        this.frameRateLastEndTimestamp = originalEndTimestamp;
+      }
+      await this.processAndEncode(videoSample, encodeOptions);
+    } finally {
+      if (shouldClose) {
+        videoSample.close();
+      }
+    }
+  }
+  /**
+   * Runs the process function (if any) and encodes the resulting samples.
+   */
+  async processAndEncode(videoSample, encodeOptions) {
+    const config = this.encodingConfig;
+    let samplesToEncode;
+    if (config.transform?.process) {
+      let processed = config.transform.process(videoSample);
+      if (isThenable(processed)) {
+        processed = await processed;
+      }
+      if (processed === null) {
+        return;
+      }
+      if (!Array.isArray(processed)) {
+        processed = [processed];
+      }
+      const mappedSamples = [];
+      try {
+        for (const x of processed) {
+          if (x instanceof VideoSample) {
+            mappedSamples.push(x);
+          } else if (typeof VideoFrame !== "undefined" && x instanceof VideoFrame) {
+            mappedSamples.push(new VideoSample(x));
+          } else {
+            mappedSamples.push(new VideoSample(x, {
+              timestamp: videoSample.timestamp,
+              duration: videoSample.duration
+            }));
+          }
+        }
+      } catch (error) {
+        for (const sample of mappedSamples) {
+          if (sample !== videoSample) {
+            sample.close();
+          }
+        }
+        for (const x of processed) {
+          if (x instanceof VideoSample && x !== videoSample) {
+            x.close();
+          } else if (typeof VideoFrame !== "undefined" && x instanceof VideoFrame) {
+            x.close();
+          }
+        }
+        throw error;
+      }
+      samplesToEncode = mappedSamples;
+    } else {
+      samplesToEncode = [videoSample];
+    }
+    try {
+      for (const sampleToEncode of samplesToEncode) {
+        if (!this.encoderInitialized) {
+          if (!this.ensureEncoderPromise) {
+            this.ensureEncoder(sampleToEncode);
+          }
+          if (!this.encoderInitialized) {
+            await this.ensureEncoderPromise;
+          }
+        }
+        assert(this.encoderInitialized);
+        if (this.closed) {
+          break;
+        }
+        if (this.encodersReclaimed) {
+          this.recreateWebCodecsEncoders();
+        }
+        const keyFrameInterval = this.encodingConfig.keyFrameInterval ?? 2;
+        const multipleOfKeyFrameInterval = Math.floor(sampleToEncode.timestamp / keyFrameInterval);
+        const mergedEncodeOptions = {
+          ...this.defaultEncodeOptions,
+          ...sampleToEncode.encodeOptions,
+          ...encodeOptions
+        };
+        const finalEncodeOptions = {
+          ...mergedEncodeOptions,
+          keyFrame: mergedEncodeOptions.keyFrame !== void 0 ? mergedEncodeOptions.keyFrame : keyFrameInterval === 0 || multipleOfKeyFrameInterval !== this.lastMultipleOfKeyFrameInterval
+        };
+        this.lastMultipleOfKeyFrameInterval = multipleOfKeyFrameInterval;
+        this.encodingConfig.onEncodedSample?.(sampleToEncode);
+        if (this.customEncoder) {
+          this.customEncoderQueueSize++;
+          const clonedSample = sampleToEncode.clone();
+          const promise = this.customEncoderCallSerializer.call(() => this.customEncoder.encode(clonedSample, finalEncodeOptions)).catch((error) => this.setError(error)).finally(() => {
+            this.customEncoderQueueSize--;
+            clonedSample.close();
+          });
+          if (this.customEncoderQueueSize >= 4) {
+            await promise;
+          }
+        } else {
+          assert(this.encoder);
+          const videoFrame = sampleToEncode.toVideoFrame();
+          const preciseTimingIndex = binarySearchLessOrEqual(this.preciseTimings, videoFrame.timestamp, (x) => x.microsecondTimestamp);
+          const existingEntry = preciseTimingIndex !== -1 ? this.preciseTimings[preciseTimingIndex] : null;
+          if (existingEntry && existingEntry.microsecondTimestamp === videoFrame.timestamp) {
+            if (existingEntry.timestamp !== sampleToEncode.timestamp) {
+              existingEntry.timestampIsValid = false;
+            }
+            if (existingEntry.duration !== sampleToEncode.duration) {
+              existingEntry.durationIsValid = false;
+            }
+          } else {
+            this.preciseTimings.splice(preciseTimingIndex + 1, 0, {
+              microsecondTimestamp: videoFrame.timestamp,
+              timestamp: sampleToEncode.timestamp,
+              duration: sampleToEncode.duration,
+              timestampIsValid: true,
+              durationIsValid: true
+            });
+            if (this.preciseTimings.length > 128) {
+              this.preciseTimings.shift();
+            }
+          }
+          if (!this.alphaEncoder) {
+            try {
+              this.encoder.encode(videoFrame, finalEncodeOptions);
+            } finally {
+              videoFrame.close();
+            }
+          } else {
+            const frameDefinitelyHasNoAlpha = !!videoFrame.format && !videoFrame.format.includes("A");
+            if (frameDefinitelyHasNoAlpha || this.splitterCreationFailed) {
+              this.alphaFrameQueue.push(null);
+              try {
+                this.encoder.encode(videoFrame, finalEncodeOptions);
+              } finally {
+                videoFrame.close();
+              }
+            } else {
+              if (!this.splitter) {
+                this.splitter = new ColorAlphaSplitter();
+              }
+              const { colorFrame, alphaFrame } = await this.splitter.split(videoFrame);
+              this.alphaFrameQueue.push(alphaFrame);
+              try {
+                this.encoder.encode(colorFrame, finalEncodeOptions);
+              } finally {
+                colorFrame.close();
+              }
+            }
+          }
+          if (this.encoder.encodeQueueSize >= 4) {
+            await new Promise((resolve) => this.encoder.addEventListener("dequeue", resolve, { once: true }));
+          }
+        }
+        await this.lastMuxerPromise;
+      }
+    } finally {
+      for (const sample of samplesToEncode) {
+        if (sample !== videoSample) {
+          sample.close();
+        }
+      }
+    }
+  }
+  /** Repeats the last frame rate sample to fill the gap up to the given timestamp. */
+  async padFrameRate(until, encodeOptions) {
+    const frameRate = this.encodingConfig.transform.frameRate;
+    assert(this.frameRateLastSample);
+    const frameDifference = Math.round((until - this.frameRateLastTimestamp) * frameRate);
+    for (let i = 1; i < frameDifference; i++) {
+      const env_1 = { stack: [], error: void 0, hasError: false };
+      try {
+        const sample = __addDisposableResource2(env_1, this.frameRateLastSample.clone(), false);
+        sample.setTimestamp(this.frameRateLastTimestamp + i / frameRate);
+        sample.setDuration(1 / frameRate);
+        await this.processAndEncode(sample, encodeOptions);
+      } catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+      } finally {
+        __disposeResources2(env_1);
+      }
+    }
+  }
+  ensureEncoder(videoSample) {
+    this.ensureEncoderPromise = (async () => {
+      const quality = resolveQuality(this.encodingConfig.quality, this.encodingConfig.bitrate);
+      assert(quality !== void 0);
+      const candidates = buildVideoEncoderConfigs({
+        ...this.encodingConfig,
+        quality,
+        width: videoSample.codedWidth,
+        height: videoSample.codedHeight,
+        squarePixelWidth: videoSample.squarePixelWidth,
+        squarePixelHeight: videoSample.squarePixelHeight,
+        framerate: this.source._connectedTrack?.metadata.frameRate
+      });
+      let selected = null;
+      let MatchingCustomEncoder;
+      for (const candidate of candidates) {
+        const candidateConfig = candidate.config;
+        this.encodingConfig.onEncoderConfig?.(candidateConfig);
+        MatchingCustomEncoder = customVideoEncoders.find((x) => x.supports(this.encodingConfig.codec, candidateConfig));
+        if (MatchingCustomEncoder) {
+          selected = candidate;
+          break;
+        }
+        if (typeof VideoEncoder === "undefined") {
+          continue;
+        }
+        candidateConfig.alpha = "discard";
+        if (this.encodingConfig.alpha === "keep") {
+          candidateConfig.latencyMode = "quality";
+        }
+        const hasOddDimension = candidateConfig.width % 2 === 1 || candidateConfig.height % 2 === 1;
+        if (hasOddDimension && (this.encodingConfig.codec === "avc" || this.encodingConfig.codec === "hevc")) {
+          throw new Error(`The dimensions ${candidateConfig.width}x${candidateConfig.height} are not supported for codec '${this.encodingConfig.codec}'; both width and height must be even numbers. Make sure to round your dimensions to the nearest even number.`);
+        }
+        try {
+          const support = await VideoEncoder.isConfigSupported(candidateConfig);
+          if (support.supported) {
+            selected = candidate;
+            break;
+          }
+        } catch {
+        }
+      }
+      if (!selected) {
+        if (typeof VideoEncoder === "undefined") {
+          throw new Error(missingWebCodecsClassMessage("VideoEncoder"));
+        }
+        const firstConfig = candidates[0].config;
+        const rateControls = candidates.map(({ config, quantizer }) => quantizer !== null ? `quantizer ${quantizer}` : `${config.bitrate} bps`);
+        throw new Error(`This specific encoder configuration (${firstConfig.codec}, ${rateControls.join(" / ")}, ${firstConfig.width}x${firstConfig.height}, hardware acceleration: ${firstConfig.hardwareAcceleration ?? "no-preference"}) is not supported in this environment. Consider using another codec or changing your video parameters.`);
+      }
+      const encoderConfig = selected.config;
+      if (selected.quantizer !== null) {
+        this.defaultEncodeOptions = buildQuantizerEncodeOptions(this.encodingConfig.codec, selected.quantizer);
+      } else {
+        this.source._nominalBitrate = encoderConfig.bitrate ?? null;
+      }
+      if (MatchingCustomEncoder) {
+        this.customEncoder = new MatchingCustomEncoder();
+        this.customEncoder.codec = this.encodingConfig.codec;
+        this.customEncoder.config = encoderConfig;
+        this.customEncoder.onPacket = (packet, meta) => {
+          if (!(packet instanceof EncodedPacket)) {
+            throw new TypeError("The first argument passed to onPacket must be an EncodedPacket.");
+          }
+          if (meta !== void 0 && (!meta || typeof meta !== "object")) {
+            throw new TypeError("The second argument passed to onPacket must be an object or undefined.");
+          }
+          maybeEnsureIsKeyPacket(this.source._connectedTrack, packet);
+          this.encodingConfig.onEncodedPacket?.(packet, meta);
+          this.lastMuxerPromise = this.muxer.addEncodedVideoPacket(this.source._connectedTrack, packet, meta).catch((error) => {
+            this.setError(error);
+          });
+        };
+        this.customEncoder.onError = (error) => {
+          this.setError(error);
+        };
+        await this.customEncoder.init();
+      } else {
+        this.encoderConfig = encoderConfig;
+        this.createWebCodecsEncoders();
+      }
+      assert(this.source._connectedTrack);
+      this.muxer = this.source._connectedTrack.output._muxer;
+      this.encoderInitialized = true;
+    })();
+  }
+  createWebCodecsEncoders() {
+    const encoderConfig = this.encoderConfig;
+    assert(encoderConfig);
+    const colorChunkQueue = [];
+    const nullAlphaChunkQueue = [];
+    let encodedAlphaChunkCount = 0;
+    let alphaEncoderQueue = 0;
+    const handleError = (error, stack2) => {
+      if (isCodecReclaimedError(error)) {
+        this.encodersReclaimed = true;
+        return;
+      }
+      error.stack = stack2;
+      this.setError(error);
+    };
+    const stack = new Error("Encoding error").stack;
+    this.encoder = new VideoEncoder({
+      output: (chunk, meta) => {
+        if (!this.alphaEncoder) {
+          this.addPacket(chunk, null, meta);
+          return;
+        }
+        const alphaFrame = this.alphaFrameQueue.shift();
+        assert(alphaFrame !== void 0);
+        if (alphaFrame) {
+          this.alphaEncoder.encode(alphaFrame, {
+            ...this.defaultEncodeOptions,
+            // Crucial: The alpha frame is forced to be a key frame whenever the color frame
+            // also is. Without this, playback can glitch and even crash in some browsers.
+            // This is the reason why the two encoders are wired in series and not in parallel.
+            keyFrame: chunk.type === "key"
+          });
+          alphaEncoderQueue++;
+          alphaFrame.close();
+          colorChunkQueue.push({ chunk, meta });
+        } else {
+          if (alphaEncoderQueue === 0) {
+            this.addPacket(chunk, null, meta);
+          } else {
+            nullAlphaChunkQueue.push(encodedAlphaChunkCount + alphaEncoderQueue);
+            colorChunkQueue.push({ chunk, meta });
+          }
+        }
+      },
+      error: (error) => handleError(error, stack)
+    });
+    this.encoder.configure(encoderConfig);
+    if (this.encodingConfig.alpha === "keep") {
+      const stack2 = new Error("Encoding error").stack;
+      this.alphaEncoder = new VideoEncoder({
+        // We ignore the alpha chunk's metadata
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        output: (chunk, meta) => {
+          alphaEncoderQueue--;
+          const colorChunk = colorChunkQueue.shift();
+          assert(colorChunk !== void 0);
+          this.addPacket(colorChunk.chunk, chunk, colorChunk.meta);
+          encodedAlphaChunkCount++;
+          while (nullAlphaChunkQueue.length > 0 && nullAlphaChunkQueue[0] === encodedAlphaChunkCount) {
+            nullAlphaChunkQueue.shift();
+            const colorChunk2 = colorChunkQueue.shift();
+            assert(colorChunk2 !== void 0);
+            this.addPacket(colorChunk2.chunk, null, colorChunk2.meta);
+          }
+        },
+        error: (error) => handleError(error, stack2)
+      });
+      this.alphaEncoder.configure(encoderConfig);
+    }
+  }
+  addPacket(colorChunk, alphaChunk, meta) {
+    const sideData = {};
+    if (alphaChunk) {
+      const alphaData = new Uint8Array(alphaChunk.byteLength);
+      alphaChunk.copyTo(alphaData);
+      sideData.alpha = alphaData;
+    }
+    let packet = EncodedPacket.fromEncodedChunk(colorChunk, sideData);
+    const preciseTimingIndex = binarySearchLessOrEqual(this.preciseTimings, colorChunk.timestamp, (x) => x.microsecondTimestamp);
+    const entry = preciseTimingIndex !== -1 ? this.preciseTimings[preciseTimingIndex] : null;
+    let actualType = null;
+    if (this.emittedEncoderPackets === 0 && packet.type === "delta" && meta?.decoderConfig) {
+      actualType = determineVideoPacketType(this.encodingConfig.codec, meta.decoderConfig, packet.data);
+    }
+    if (entry && entry.microsecondTimestamp === colorChunk.timestamp || actualType !== null) {
+      packet = packet.clone({
+        timestamp: entry?.timestampIsValid ? entry.timestamp : void 0,
+        duration: entry?.durationIsValid ? entry.duration : void 0,
+        type: actualType ?? void 0
+      });
+    }
+    maybeEnsureIsKeyPacket(this.source._connectedTrack, packet);
+    this.encodingConfig.onEncodedPacket?.(packet, meta);
+    this.lastMuxerPromise = this.muxer.addEncodedVideoPacket(this.source._connectedTrack, packet, meta).catch((error) => {
+      this.setError(error);
+    });
+    this.emittedEncoderPackets++;
+  }
+  // Browsers may reclaim codecs that have been inactive for a while (see
+  // https://github.com/Vanilagy/mediabunny/issues/531), closing them and reporting a QuotaExceededError. Since a
+  // reclaimed encoder was idle, no frames are lost, so we transparently replace the encoders with fresh ones.
+  recreateWebCodecsEncoders() {
+    assert(this.encoder);
+    if (this.encoder.state !== "closed") {
+      this.encoder.close();
+    }
+    if (this.alphaEncoder && this.alphaEncoder.state !== "closed") {
+      this.alphaEncoder.close();
+    }
+    this.alphaFrameQueue.forEach((x) => x?.close());
+    this.alphaFrameQueue.length = 0;
+    this.encodersReclaimed = false;
+    this.lastMultipleOfKeyFrameInterval = -1;
+    this.createWebCodecsEncoders();
+  }
+  async flushAndClose(forceClose) {
+    try {
+      if (!forceClose) {
+        this.checkForEncoderError();
+        if (this.frameRateLastSample) {
+          const frameRate = this.encodingConfig.transform.frameRate;
+          const alignedEnd = floorToDivisor(this.frameRateLastEndTimestamp, frameRate);
+          await this.padFrameRate(alignedEnd);
+        }
+      }
+      this.closed = true;
+      if (!forceClose) {
+        if (this.customEncoder) {
+          void this.customEncoderCallSerializer.call(() => this.customEncoder.flush());
+        } else if (this.encoder && !this.encodersReclaimed) {
+          await this.encoder.flush();
+          await this.alphaEncoder?.flush();
+          await wait(25);
+        }
+      }
+    } finally {
+      this.closed = true;
+      this.frameRateLastSample?.close();
+      this.frameRateLastSample = null;
+      if (this.customEncoder) {
+        await this.customEncoderCallSerializer.call(() => this.customEncoder.close()).catch((error) => this.setError(error));
+      } else if (this.encoder) {
+        if (this.encoder.state !== "closed") {
+          this.encoder.close();
+        }
+        if (this.alphaEncoder && this.alphaEncoder.state !== "closed") {
+          this.alphaEncoder.close();
+        }
+        this.alphaFrameQueue.forEach((x) => x?.close());
+        this.alphaFrameQueue.length = 0;
+        this.splitter?.close();
+      }
+    }
+    if (!forceClose) {
+      this.checkForEncoderError();
+    }
+  }
+  getQueueSize() {
+    if (this.customEncoder) {
+      return this.customEncoderQueueSize;
+    } else {
+      return this.encoder?.encodeQueueSize ?? 0;
+    }
+  }
+  checkForEncoderError() {
+    if (this.errorSet) {
+      throw this.error;
+    }
+  }
+};
+var splitterWorkerUrl = null;
+var ColorAlphaSplitter = class {
+  constructor() {
+    this.worker = null;
+    this.pendingRequests = /* @__PURE__ */ new Map();
+    this.nextRequestId = 0;
+  }
+  split(sourceFrame) {
+    if (!this.worker) {
+      if (!splitterWorkerUrl) {
+        const blob = new Blob([`(${colorAlphaSplitterWorkerCode.toString()})()`], { type: "application/javascript" });
+        splitterWorkerUrl = URL.createObjectURL(blob);
+      }
+      this.worker = new Worker(splitterWorkerUrl);
+      this.worker.addEventListener("message", (event) => {
+        const data = event.data;
+        const pending2 = this.pendingRequests.get(data.id);
+        if (!pending2) {
+          return;
+        }
+        this.pendingRequests.delete(data.id);
+        if ("error" in data) {
+          pending2.reject(new Error(data.error));
+        } else {
+          pending2.resolve({ colorFrame: data.colorFrame, alphaFrame: data.alphaFrame });
+        }
+      });
+      this.worker.addEventListener("error", (event) => {
+        const error = new Error(event.message || "Color/alpha splitter worker error.");
+        for (const pending2 of this.pendingRequests.values()) {
+          pending2.reject(error);
+        }
+        this.pendingRequests.clear();
+      });
+    }
+    const id = this.nextRequestId++;
+    const pending = promiseWithResolvers();
+    this.pendingRequests.set(id, pending);
+    this.worker.postMessage({ id, sourceFrame }, { transfer: [sourceFrame] });
+    return pending.promise;
+  }
+  close() {
+    this.worker?.terminate();
+    this.worker = null;
+    const error = new Error("Color/alpha splitter closed.");
+    for (const pending of this.pendingRequests.values()) {
+      pending.reject(error);
+    }
+    this.pendingRequests.clear();
+  }
+};
+var colorAlphaSplitterWorkerCode = () => {
+  let cpuSourceBuffer = null;
+  let chain = Promise.resolve();
+  self.addEventListener("message", (event) => {
+    const { id, sourceFrame } = event.data;
+    chain = chain.then(async () => {
+      try {
+        const { colorFrame, alphaFrame } = await split(sourceFrame);
+        self.postMessage({ id, colorFrame, alphaFrame }, { transfer: [colorFrame, alphaFrame] });
+      } catch (error) {
+        self.postMessage({ id, error: error.message });
+      } finally {
+        sourceFrame.close();
+      }
+    });
+  });
+  const split = async (sourceFrame) => {
+    const format = sourceFrame.format;
+    if (!format) {
+      throw new Error("CPU color/alpha splitting requires a known VideoFrame format.");
+    }
+    const sourceSize = sourceFrame.allocationSize();
+    if (!cpuSourceBuffer || cpuSourceBuffer.byteLength !== sourceSize) {
+      cpuSourceBuffer = new Uint8Array(sourceSize);
+    }
+    await sourceFrame.copyTo(cpuSourceBuffer);
+    if (format === "RGBA" || format === "BGRA") {
+      return splitInterleavedRgba(cpuSourceBuffer, format, sourceFrame);
+    } else if (format === "I420A" || format === "I420AP10" || format === "I420AP12" || format === "I422A" || format === "I422AP10" || format === "I422AP12" || format === "I444A" || format === "I444AP10" || format === "I444AP12") {
+      return splitPlanarYuvA(cpuSourceBuffer, format, sourceFrame);
+    }
+    throw new Error(`CPU color/alpha splitting does not support format '${format}'.`);
+  };
+  const splitInterleavedRgba = (source, format, sourceFrame) => {
+    const width = sourceFrame.visibleRect?.width ?? sourceFrame.codedWidth;
+    const height = sourceFrame.visibleRect?.height ?? sourceFrame.codedHeight;
+    const pixelCount = width * height;
+    const chromaW = Math.ceil(width / 2);
+    const chromaH = Math.ceil(height / 2);
+    const alphaSize = pixelCount + chromaW * chromaH * 2;
+    const alphaBuffer = new Uint8Array(alphaSize);
+    for (let i = 0, j = 3; i < pixelCount; i++, j += 4) {
+      alphaBuffer[i] = source[j];
+    }
+    alphaBuffer.fill(128, pixelCount);
+    const colorFrame = new VideoFrame(source, {
+      format: format === "RGBA" ? "RGBX" : "BGRX",
+      codedWidth: width,
+      codedHeight: height,
+      timestamp: sourceFrame.timestamp,
+      duration: sourceFrame.duration ?? void 0
+      // No transfer!
+    });
+    const alphaInit = {
+      format: "I420",
+      codedWidth: width,
+      codedHeight: height,
+      timestamp: sourceFrame.timestamp,
+      duration: sourceFrame.duration ?? void 0,
+      transfer: [alphaBuffer.buffer]
+    };
+    const alphaFrame = new VideoFrame(alphaBuffer, alphaInit);
+    return { colorFrame, alphaFrame };
+  };
+  const splitPlanarYuvA = (source, format, sourceFrame) => {
+    const width = sourceFrame.visibleRect?.width ?? sourceFrame.codedWidth;
+    const height = sourceFrame.visibleRect?.height ?? sourceFrame.codedHeight;
+    const is10 = format.includes("P10");
+    const is12 = format.includes("P12");
+    const bytesPerSample = is10 || is12 ? 2 : 1;
+    let chromaW;
+    let chromaH;
+    if (format.startsWith("I420")) {
+      chromaW = Math.ceil(width / 2);
+      chromaH = Math.ceil(height / 2);
+    } else if (format.startsWith("I422")) {
+      chromaW = Math.ceil(width / 2);
+      chromaH = height;
+    } else {
+      chromaW = width;
+      chromaH = height;
+    }
+    const ySamples = width * height;
+    const uvSamples = chromaW * chromaH;
+    const yBytes = ySamples * bytesPerSample;
+    const uvBytes = uvSamples * bytesPerSample;
+    const aBytes = ySamples * bytesPerSample;
+    const colorBytes = yBytes + uvBytes * 2;
+    const colorFormat = format.replace("A", "");
+    const alphaChromaW = Math.ceil(width / 2);
+    const alphaChromaH = Math.ceil(height / 2);
+    const alphaUvSamples = alphaChromaW * alphaChromaH;
+    const alphaUvBytes = alphaUvSamples * bytesPerSample;
+    const alphaSize = aBytes + 2 * alphaUvBytes;
+    const alphaBuffer = new Uint8Array(alphaSize);
+    const aPlaneStart = colorBytes;
+    alphaBuffer.set(source.subarray(aPlaneStart, aPlaneStart + aBytes), 0);
+    const uvOffset = aBytes;
+    const neutralChroma = is10 ? 512 : is12 ? 2048 : 128;
+    if (bytesPerSample === 1) {
+      alphaBuffer.fill(neutralChroma, uvOffset);
+    } else {
+      const uvView = new Uint16Array(alphaBuffer.buffer, uvOffset, 2 * alphaUvSamples);
+      uvView.fill(neutralChroma);
+    }
+    const alphaFormat = is10 ? "I420P10" : is12 ? "I420P12" : "I420";
+    const colorFrame = new VideoFrame(source.subarray(0, colorBytes), {
+      format: colorFormat,
+      codedWidth: width,
+      codedHeight: height,
+      timestamp: sourceFrame.timestamp,
+      duration: sourceFrame.duration ?? void 0
+    });
+    const alphaInit = {
+      format: alphaFormat,
+      codedWidth: width,
+      codedHeight: height,
+      timestamp: sourceFrame.timestamp,
+      duration: sourceFrame.duration ?? void 0,
+      transfer: [alphaBuffer.buffer]
+    };
+    const alphaFrame = new VideoFrame(alphaBuffer, alphaInit);
+    return { colorFrame, alphaFrame };
+  };
+};
+var VideoSampleSource = class extends VideoSource {
+  /**
+   * Creates a new {@link VideoSampleSource} whose samples are encoded according to the specified
+   * {@link VideoEncodingConfig}.
+   */
+  constructor(encodingConfig) {
+    validateVideoEncodingConfig(encodingConfig);
+    super(encodingConfig.codec);
+    this._encoder = new VideoEncoderWrapper(this, encodingConfig);
+  }
+  /**
+   * Encodes a video sample (frame) and then adds it to the output.
+   *
+   * @returns A Promise that resolves once the output is ready to receive more samples. You should await this Promise
+   * to respect writer and encoder backpressure.
+   */
+  add(videoSample, encodeOptions) {
+    if (!(videoSample instanceof VideoSample)) {
+      throw new TypeError("videoSample must be a VideoSample.");
+    }
+    return this._encoder.add(videoSample, false, encodeOptions);
+  }
+  /** @internal */
+  _flushAndClose(forceClose) {
+    return this._encoder.flushAndClose(forceClose);
+  }
+};
 var AudioSource = class extends MediaSource {
   /** Internal constructor. */
   constructor(codec) {
@@ -27895,11 +29183,15 @@ export {
   ADTS,
   FLAC,
   AudioSample,
+  QUALITY_HIGH,
+  canEncodeVideo,
   canEncodeAudio,
+  getFirstEncodableVideoCodec,
   VideoSampleSink,
   AudioSampleSink,
   Input,
   BufferTarget,
+  VideoSampleSource,
   AudioSampleSource,
   Mp4OutputFormat,
   WebMOutputFormat,