@bendyline/squisq-video-react 2.2.10 → 2.3.0

package/dist/chunk-GLOLS2CQ.js

@@ -1,1567 +0,0 @@
-import {
-  EXPORT_AUDIO_CHANNELS,
-  EXPORT_AUDIO_SAMPLE_RATE,
-  audioBufferToWav,
-  createEncoder,
-  encodeAacTrack,
-  muxAudioWithFfmpegWasm,
-  renderAudioTimeline,
-  selectAudioTier,
-  supportsWebCodecs,
-  supportsWebCodecsAac,
-  supportsWebCodecsH264
-} from "./chunk-2XACUF6E.js";
-
-// src/hooks/useFrameCapture.ts
-import { createElement } from "react";
-import { createRoot } from "react-dom/client";
-import { useRef, useCallback, useMemo } from "react";
-import { DocPlayer, MediaContext } from "@bendyline/squisq-react";
-import html2canvas from "html2canvas";
-var MIME_MAP = {
-  jpg: "image/jpeg",
-  jpeg: "image/jpeg",
-  png: "image/png",
-  gif: "image/gif",
-  webp: "image/webp",
-  svg: "image/svg+xml",
-  bmp: "image/bmp",
-  avif: "image/avif",
-  mp3: "audio/mpeg",
-  wav: "audio/wav",
-  ogg: "audio/ogg",
-  mp4: "video/mp4",
-  webm: "video/webm"
-};
-var CAPTURE_ASSET_TIMEOUT_MS = 15e3;
-var RENDER_TIME_EPSILON_SECONDS = 1e-6;
-var POTENTIALLY_ANIMATED_IMAGE_URL = /(?:^data:image\/(?:gif|webp|avif)[;,]|\.(?:gif|webp|avif)(?:[?#]|$))/i;
-var CAPTURE_SVG_SELECTOR = "svg.block-svg";
-async function waitForImageDecode(image) {
-  const src = image.currentSrc || image.src;
-  if (!src) return;
-  const decoded = typeof image.decode === "function" ? image.decode() : new Promise((resolve, reject) => {
-    if (image.complete) {
-      if (image.naturalWidth > 0) resolve();
-      else reject(new Error(`Image could not be decoded: ${src}`));
-      return;
-    }
-    image.addEventListener("load", () => resolve(), { once: true });
-    image.addEventListener(
-      "error",
-      () => reject(new Error(`Image could not be loaded: ${src}`)),
-      {
-        once: true
-      }
-    );
-  });
-  let timeout;
-  try {
-    await Promise.race([
-      decoded,
-      new Promise((_resolve, reject) => {
-        timeout = setTimeout(
-          () => reject(new Error(`Image did not become ready within 15s: ${src}`)),
-          CAPTURE_ASSET_TIMEOUT_MS
-        );
-      })
-    ]);
-  } finally {
-    if (timeout !== void 0) clearTimeout(timeout);
-  }
-}
-async function waitForCaptureAssets(captureRoot, decodedImages = /* @__PURE__ */ new WeakSet()) {
-  const fonts = captureRoot.ownerDocument.fonts;
-  if (fonts) await fonts.ready;
-  const pendingImages = Array.from(captureRoot.querySelectorAll("img")).filter(
-    (image) => !decodedImages.has(image)
-  );
-  await Promise.all(
-    pendingImages.map(async (image) => {
-      await waitForImageDecode(image);
-      decodedImages.add(image);
-    })
-  );
-}
-function createInlineProvider(images) {
-  const blobUrls = /* @__PURE__ */ new Map();
-  const mimeTypes = /* @__PURE__ */ new Map();
-  for (const [path, buffer] of images) {
-    const ext = path.split(".").pop()?.toLowerCase() ?? "";
-    const mime = MIME_MAP[ext] ?? "application/octet-stream";
-    blobUrls.set(path, URL.createObjectURL(new Blob([buffer], { type: mime })));
-    mimeTypes.set(path, mime);
-  }
-  return {
-    async resolveUrl(relativePath) {
-      return blobUrls.get(relativePath) ?? relativePath;
-    },
-    async listMedia() {
-      return [...blobUrls.keys()].map((name) => ({
-        name,
-        mimeType: mimeTypes.get(name) ?? "application/octet-stream",
-        size: images.get(name)?.byteLength ?? 0
-      }));
-    },
-    async addMedia() {
-      throw new Error("Read-only");
-    },
-    async removeMedia() {
-      throw new Error("Read-only");
-    },
-    dispose() {
-      blobUrls.forEach((url) => URL.revokeObjectURL(url));
-      blobUrls.clear();
-    }
-  };
-}
-function shouldIgnoreCaptureSibling(element, captureRoot) {
-  const { head } = captureRoot.ownerDocument;
-  const isInDocumentHead = element === head || head.contains(element);
-  const isInCaptureBranch = element === captureRoot || element.contains(captureRoot) || captureRoot.contains(element);
-  return !isInDocumentHead && !isInCaptureBranch;
-}
-function finiteMediaTime(value) {
-  return Number.isFinite(value) ? value.toFixed(6) : "unknown";
-}
-function coverSourceRect(sourceWidth, sourceHeight, destinationWidth, destinationHeight) {
-  const sourceRatio = sourceWidth / sourceHeight;
-  const destinationRatio = destinationWidth / destinationHeight;
-  if (sourceRatio > destinationRatio) {
-    const sw = sourceHeight * destinationRatio;
-    return { sx: (sourceWidth - sw) / 2, sy: 0, sw, sh: sourceHeight };
-  }
-  const sh = sourceWidth / destinationRatio;
-  return { sx: 0, sy: (sourceHeight - sh) / 2, sw: sourceWidth, sh };
-}
-function videoFrameRect(sourceWidth, sourceHeight, destinationWidth, destinationHeight, objectFit) {
-  if (objectFit === "cover") {
-    return {
-      ...coverSourceRect(sourceWidth, sourceHeight, destinationWidth, destinationHeight),
-      dx: 0,
-      dy: 0,
-      dw: destinationWidth,
-      dh: destinationHeight
-    };
-  }
-  if (objectFit === "contain" || objectFit === "scale-down") {
-    const containScale = Math.min(destinationWidth / sourceWidth, destinationHeight / sourceHeight);
-    const scale = objectFit === "scale-down" ? Math.min(1, containScale) : containScale;
-    const dw = sourceWidth * scale;
-    const dh = sourceHeight * scale;
-    return {
-      sx: 0,
-      sy: 0,
-      sw: sourceWidth,
-      sh: sourceHeight,
-      dx: (destinationWidth - dw) / 2,
-      dy: (destinationHeight - dh) / 2,
-      dw,
-      dh
-    };
-  }
-  if (objectFit === "none") {
-    return {
-      sx: 0,
-      sy: 0,
-      sw: sourceWidth,
-      sh: sourceHeight,
-      dx: (destinationWidth - sourceWidth) / 2,
-      dy: (destinationHeight - sourceHeight) / 2,
-      dw: sourceWidth,
-      dh: sourceHeight
-    };
-  }
-  return {
-    sx: 0,
-    sy: 0,
-    sw: sourceWidth,
-    sh: sourceHeight,
-    dx: 0,
-    dy: 0,
-    dw: destinationWidth,
-    dh: destinationHeight
-  };
-}
-function prepareScheduledVideoClones(originalRoot, clonedRoot) {
-  const captureFamilies = [
-    {
-      original: ".doc-player__media-clips video[data-clip-id]",
-      clone: ".doc-player__media-clips canvas"
-    },
-    {
-      original: ".block-layer--video video[data-clip-start]",
-      clone: ".block-layer--video canvas"
-    }
-  ];
-  const pairs = captureFamilies.flatMap(({ original, clone }) => {
-    const videos = Array.from(originalRoot.querySelectorAll(original));
-    const canvases = Array.from(clonedRoot.querySelectorAll(clone));
-    return videos.flatMap((video, index) => {
-      const canvas = canvases[index];
-      return canvas ? [{ video, canvas }] : [];
-    });
-  });
-  const preparedCanvases = pairs.map(({ canvas }) => canvas);
-  pairs.forEach(({ video, canvas }) => {
-    canvas.className = video.className;
-    canvas.style.cssText = video.style.cssText;
-    for (const attribute of Array.from(video.attributes)) {
-      if (attribute.name.startsWith("data-")) {
-        canvas.setAttribute(attribute.name, attribute.value);
-      }
-    }
-    canvas.dataset.videoCaptureClone = "true";
-    const destinationWidth = Math.round(video.clientWidth || video.offsetWidth);
-    const destinationHeight = Math.round(video.clientHeight || video.offsetHeight);
-    if (video.videoWidth <= 0 || video.videoHeight <= 0 || destinationWidth <= 0 || destinationHeight <= 0) {
-      return;
-    }
-    try {
-      const view = video.ownerDocument.defaultView;
-      const objectFit = video.style.objectFit || view?.getComputedStyle(video).objectFit || "fill";
-      const frame = videoFrameRect(
-        video.videoWidth,
-        video.videoHeight,
-        destinationWidth,
-        destinationHeight,
-        objectFit
-      );
-      const context = canvas.getContext("2d");
-      if (!context) return;
-      canvas.width = destinationWidth;
-      canvas.height = destinationHeight;
-      context.drawImage(
-        video,
-        frame.sx,
-        frame.sy,
-        frame.sw,
-        frame.sh,
-        frame.dx,
-        frame.dy,
-        frame.dw,
-        frame.dh
-      );
-      const foreignObject = canvas.closest("foreignObject");
-      const svg = canvas.closest("svg");
-      if (foreignObject && svg) {
-        const originalHost = video.closest(".doc-player__block") ?? originalRoot;
-        const clonedHost = svg.closest(".doc-player__block") ?? clonedRoot;
-        const videoRect = video.getBoundingClientRect();
-        const hostRect = originalHost.getBoundingClientRect();
-        const renderedWidth = videoRect.width || destinationWidth;
-        const renderedHeight = videoRect.height || destinationHeight;
-        const fallbackX = Number.parseFloat(foreignObject.getAttribute("x") ?? "0") || 0;
-        const fallbackY = Number.parseFloat(foreignObject.getAttribute("y") ?? "0") || 0;
-        const left = videoRect.width ? videoRect.left - hostRect.left : fallbackX;
-        const top = videoRect.height ? videoRect.top - hostRect.top : fallbackY;
-        foreignObject.remove();
-        if (clonedHost === clonedRoot && !clonedHost.style.position) {
-          clonedHost.style.position = "relative";
-        }
-        canvas.style.position = "absolute";
-        canvas.style.left = `${left}px`;
-        canvas.style.top = `${top}px`;
-        canvas.style.width = `${renderedWidth}px`;
-        canvas.style.height = `${renderedHeight}px`;
-        canvas.style.zIndex = "3";
-        canvas.style.margin = "0";
-        canvas.style.transform = "none";
-        clonedHost.appendChild(canvas);
-      }
-    } catch {
-    }
-  });
-  return preparedCanvases;
-}
-function parseAbsoluteSvgLength(value) {
-  if (!value) return 0;
-  const match = /^\s*(\d+(?:\.\d+)?|\.\d+)(?:px)?\s*$/i.exec(value);
-  return match ? Number.parseFloat(match[1]) : 0;
-}
-function svgViewBoxSize(svg) {
-  const values = (svg.getAttribute("viewBox") ?? "").trim().split(/[\s,]+/).map(Number);
-  if (values.length === 4 && values.every(Number.isFinite)) {
-    return { width: Math.max(0, values[2]), height: Math.max(0, values[3]) };
-  }
-  return { width: 0, height: 0 };
-}
-function captureSvgRasterSize(clonedSvg, originalSvg) {
-  const clonedRect = clonedSvg.getBoundingClientRect();
-  const originalRect = originalSvg?.getBoundingClientRect();
-  const clonedViewBox = svgViewBoxSize(clonedSvg);
-  const originalViewBox = originalSvg ? svgViewBoxSize(originalSvg) : { width: 0, height: 0 };
-  const width = clonedRect.width || originalRect?.width || parseAbsoluteSvgLength(clonedSvg.getAttribute("width")) || (originalSvg ? parseAbsoluteSvgLength(originalSvg.getAttribute("width")) : 0) || clonedViewBox.width || originalViewBox.width;
-  const height = clonedRect.height || originalRect?.height || parseAbsoluteSvgLength(clonedSvg.getAttribute("height")) || (originalSvg ? parseAbsoluteSvgLength(originalSvg.getAttribute("height")) : 0) || clonedViewBox.height || originalViewBox.height;
-  return {
-    width: Math.max(1, Math.round(width)),
-    height: Math.max(1, Math.round(height))
-  };
-}
-function copyCaptureSvgPresentation(svg, canvas) {
-  for (const attribute of Array.from(svg.attributes)) {
-    if (attribute.name === "id" || attribute.name === "class" || attribute.name === "style" || attribute.name.startsWith("data-") || attribute.name.startsWith("aria-")) {
-      canvas.setAttribute(attribute.name, attribute.value);
-    }
-  }
-  canvas.dataset.svgCaptureClone = "true";
-}
-function captureImageMimeType(source, blob) {
-  if (blob.type) return blob.type;
-  const path = source.split(/[?#]/, 1)[0];
-  const ext = path.split(".").pop()?.toLowerCase() ?? "";
-  return MIME_MAP[ext] ?? "application/octet-stream";
-}
-function blobToDataUrl(blob, source) {
-  const typedBlob = blob.type ? blob : blob.slice(0, blob.size, captureImageMimeType(source, blob));
-  return new Promise((resolve, reject) => {
-    const reader = new FileReader();
-    reader.addEventListener(
-      "load",
-      () => {
-        if (typeof reader.result === "string") resolve(reader.result);
-        else reject(new Error(`Image could not be embedded for SVG capture: ${source}`));
-      },
-      { once: true }
-    );
-    reader.addEventListener(
-      "error",
-      () => reject(reader.error ?? new Error(`Image could not be read for SVG capture: ${source}`)),
-      { once: true }
-    );
-    reader.readAsDataURL(typedBlob);
-  });
-}
-function resolveCaptureImageDataUrl(source, cache) {
-  const cached = cache.get(source);
-  if (cached) return cached;
-  const pending = fetch(source).then(async (response) => {
-    if (!response.ok) return null;
-    return blobToDataUrl(await response.blob(), source);
-  }).catch(() => null);
-  cache.set(source, pending);
-  return pending;
-}
-function captureImageReference(element) {
-  if (element.localName === "img") {
-    const source2 = element.getAttribute("src") ?? "";
-    return source2 ? {
-      source: source2,
-      replace: (dataUrl) => element.setAttribute("src", dataUrl)
-    } : null;
-  }
-  const xlinkNamespace = "http://www.w3.org/1999/xlink";
-  const source = element.getAttribute("href") ?? element.getAttributeNS(xlinkNamespace, "href") ?? "";
-  return source ? {
-    source,
-    replace: (dataUrl) => {
-      if (element.hasAttribute("href")) element.setAttribute("href", dataUrl);
-      if (element.hasAttributeNS(xlinkNamespace, "href")) {
-        element.setAttributeNS(xlinkNamespace, "href", dataUrl);
-      }
-    }
-  } : null;
-}
-async function embedCaptureSvgImages(svg, cache) {
-  const references = Array.from(svg.querySelectorAll("image, img")).map(captureImageReference).filter((reference) => reference !== null);
-  for (const reference of references) {
-    if (/^data:/i.test(reference.source) || reference.source.startsWith("#")) continue;
-    const dataUrl = await resolveCaptureImageDataUrl(reference.source, cache);
-    if (!dataUrl) return false;
-    reference.replace(dataUrl);
-  }
-  return true;
-}
-async function rasterizeCaptureSvgClones(originalRoot, clonedRoot, transientCanvases = [], imageDataUrls = /* @__PURE__ */ new Map()) {
-  if (typeof createImageBitmap !== "function") return transientCanvases;
-  const originalSvgs = Array.from(
-    originalRoot.querySelectorAll(CAPTURE_SVG_SELECTOR)
-  );
-  const clonedSvgs = Array.from(clonedRoot.querySelectorAll(CAPTURE_SVG_SELECTOR));
-  for (const [index, svg] of clonedSvgs.entries()) {
-    const { width, height } = captureSvgRasterSize(svg, originalSvgs[index]);
-    svg.setAttribute("xmlns", "http://www.w3.org/2000/svg");
-    svg.setAttribute("width", String(width));
-    svg.setAttribute("height", String(height));
-    let bitmap = null;
-    let replacement = null;
-    try {
-      if (!await embedCaptureSvgImages(svg, imageDataUrls)) continue;
-      const serializedSvg = new XMLSerializer().serializeToString(svg);
-      bitmap = await createImageBitmap(new Blob([serializedSvg], { type: "image/svg+xml" }));
-      replacement = svg.ownerDocument.createElement("canvas");
-      replacement.width = width;
-      replacement.height = height;
-      copyCaptureSvgPresentation(svg, replacement);
-      const context = replacement.getContext("2d");
-      if (!context) {
-        replacement.width = 0;
-        replacement.height = 0;
-        continue;
-      }
-      context.drawImage(bitmap, 0, 0, width, height);
-      svg.replaceWith(replacement);
-      transientCanvases.push(replacement);
-    } catch {
-      if (replacement && !replacement.isConnected) {
-        replacement.width = 0;
-        replacement.height = 0;
-      }
-    } finally {
-      bitmap?.close();
-    }
-  }
-  return transientCanvases;
-}
-function releaseCaptureCloneCanvases(canvases) {
-  canvases.forEach((canvas) => {
-    canvas.width = 0;
-    canvas.height = 0;
-  });
-}
-function getFrameVisualStateKey(captureRoot, timelineTime) {
-  const markup = captureRoot.innerHTML;
-  let needsTimelineKey = false;
-  const animationStates = [];
-  if (typeof captureRoot.getAnimations === "function") {
-    const animations = captureRoot.getAnimations({ subtree: true });
-    animations.forEach((animation, index) => {
-      try {
-        const timing = animation.effect?.getComputedTiming();
-        if (!timing) {
-          needsTimelineKey = true;
-          return;
-        }
-        animationStates.push(
-          `${index}:${animation.playState}:${String(timing.progress)}:${String(
-            timing.currentIteration
-          )}`
-        );
-      } catch {
-        needsTimelineKey = true;
-      }
-    });
-  } else if (/\b(?:anim-|transition-)|animation(?:-name)?\s*:/i.test(markup)) {
-    needsTimelineKey = true;
-  }
-  const imageStates = Array.from(captureRoot.querySelectorAll("img")).map((image) => {
-    const src = image.currentSrc || image.src;
-    if (POTENTIALLY_ANIMATED_IMAGE_URL.test(src)) needsTimelineKey = true;
-    return `${src}:${image.complete}:${image.naturalWidth}x${image.naturalHeight}`;
-  });
-  if (POTENTIALLY_ANIMATED_IMAGE_URL.test(markup)) needsTimelineKey = true;
-  const videoStates = Array.from(captureRoot.querySelectorAll("video")).map(
-    (video) => `${video.currentSrc || video.src}:${finiteMediaTime(video.currentTime)}:${video.readyState}:${video.videoWidth}x${video.videoHeight}`
-  );
-  if (captureRoot.querySelector(
-    "canvas, iframe, object, embed, animate, animateMotion, animateTransform, set"
-  )) {
-    needsTimelineKey = true;
-  }
-  const fontStatus = captureRoot.ownerDocument.fonts?.status ?? "unsupported";
-  return JSON.stringify({
-    markup,
-    animationStates,
-    imageStates,
-    videoStates,
-    fontStatus,
-    timelineTime: needsTimelineKey ? timelineTime.toFixed(6) : null
-  });
-}
-function useFrameCapture() {
-  const containerRef = useRef(null);
-  const rootRef = useRef(null);
-  const renderAPIRef = useRef(null);
-  const mediaProviderRef = useRef(null);
-  const captureCanvasRef = useRef(null);
-  const lastVisualStateKeyRef = useRef(null);
-  const hasCapturedFrameRef = useRef(false);
-  const decodedImagesRef = useRef(/* @__PURE__ */ new WeakSet());
-  const captureImageDataUrlsRef = useRef(/* @__PURE__ */ new Map());
-  const dimensionsRef = useRef({ width: 1920, height: 1080 });
-  const init = useCallback(
-    async (doc, renderOptions, captionMode) => {
-      if (rootRef.current || containerRef.current || mediaProviderRef.current || captureCanvasRef.current) {
-        const oldRoot = rootRef.current;
-        const oldContainer = containerRef.current;
-        const oldMediaProvider = mediaProviderRef.current;
-        const oldCaptureCanvas = captureCanvasRef.current;
-        rootRef.current = null;
-        containerRef.current = null;
-        renderAPIRef.current = null;
-        mediaProviderRef.current = null;
-        captureCanvasRef.current = null;
-        lastVisualStateKeyRef.current = null;
-        hasCapturedFrameRef.current = false;
-        decodedImagesRef.current = /* @__PURE__ */ new WeakSet();
-        captureImageDataUrlsRef.current.clear();
-        await new Promise((resolve) => {
-          setTimeout(() => {
-            if (oldRoot) oldRoot.unmount();
-            if (oldContainer) oldContainer.remove();
-            oldMediaProvider?.dispose();
-            if (oldCaptureCanvas) {
-              oldCaptureCanvas.width = 0;
-              oldCaptureCanvas.height = 0;
-            }
-            resolve();
-          }, 0);
-        });
-      }
-      const width = renderOptions.width ?? 1920;
-      const height = renderOptions.height ?? 1080;
-      const animationsEnabled = renderOptions.animationsEnabled ?? true;
-      dimensionsRef.current = { width, height };
-      const captureCanvas = document.createElement("canvas");
-      captureCanvas.width = width;
-      captureCanvas.height = height;
-      captureCanvas.style.width = `${width}px`;
-      captureCanvas.style.height = `${height}px`;
-      captureCanvasRef.current = captureCanvas;
-      lastVisualStateKeyRef.current = null;
-      hasCapturedFrameRef.current = false;
-      decodedImagesRef.current = /* @__PURE__ */ new WeakSet();
-      captureImageDataUrlsRef.current.clear();
-      const container = document.createElement("div");
-      container.style.cssText = `position:fixed;left:0;top:0;width:${width}px;height:${height}px;opacity:0;pointer-events:none;z-index:-1;overflow:hidden;`;
-      document.body.appendChild(container);
-      containerRef.current = container;
-      const renderRoot = document.createElement("div");
-      renderRoot.id = "squisq-capture-root";
-      renderRoot.style.cssText = `width:${width}px;height:${height}px;`;
-      container.appendChild(renderRoot);
-      const mediaProvider = renderOptions.images ? createInlineProvider(renderOptions.images) : null;
-      mediaProviderRef.current = mediaProvider;
-      const root = createRoot(renderRoot);
-      rootRef.current = root;
-      const captionsEnabled = captionMode !== void 0 && captionMode !== "off";
-      const captionStyle = captionMode === "social" ? "social" : "standard";
-      let resolveRenderAPI;
-      const renderAPIReady = new Promise((resolve) => {
-        resolveRenderAPI = resolve;
-      });
-      const playerElement = createElement(DocPlayer, {
-        doc,
-        basePath: ".",
-        renderMode: true,
-        animationsEnabled,
-        showControls: false,
-        autoPlay: false,
-        forceViewport: { width, height, name: "export" },
-        theme: renderOptions.theme,
-        videoPresentation: renderOptions.videoPresentation,
-        pipSize: renderOptions.pipSize,
-        pipShape: renderOptions.pipShape,
-        pipPosition: renderOptions.pipPosition,
-        showCoverSlide: renderOptions.showCoverSlide,
-        captionsEnabled,
-        captionStyle,
-        onRenderAPIReady: (api) => {
-          if (containerRef.current !== container) return;
-          renderAPIRef.current = api;
-          if (api) resolveRenderAPI(api);
-        }
-      });
-      await new Promise((resolve) => setTimeout(resolve, 0));
-      if (mediaProvider) {
-        root.render(createElement(MediaContext.Provider, { value: mediaProvider }, playerElement));
-      } else {
-        root.render(playerElement);
-      }
-      return new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => {
-          const api = renderAPIRef.current;
-          const hasSeek = typeof api?.seekTo === "function";
-          const hasDur = typeof api?.getDuration === "function";
-          const rootEl = containerRef.current?.querySelector("#squisq-capture-root");
-          const hasPlayer = rootEl ? rootEl.querySelector(".doc-player") !== null : false;
-          reject(
-            new Error(
-              `Render API did not initialize within 15s. seekTo=${hasSeek}, getDuration=${hasDur}, player=${hasPlayer}, root=${!!rootEl}`
-            )
-          );
-        }, 15e3);
-        void renderAPIReady.then(async (api) => {
-          try {
-            const captureRoot = container.querySelector("#squisq-capture-root");
-            if (!(captureRoot instanceof HTMLElement)) {
-              throw new Error("Capture root element not found after player initialization.");
-            }
-            await waitForCaptureAssets(captureRoot, decodedImagesRef.current);
-            clearTimeout(timeout);
-            resolve(api.getDuration());
-          } catch (assetError) {
-            clearTimeout(timeout);
-            reject(assetError);
-          }
-        });
-      });
-    },
-    []
-  );
-  const setCoverVisible = useCallback(async (visible) => {
-    const api = renderAPIRef.current;
-    if (!api) throw new Error("Frame capture not initialized \xE2\u20AC\u201D call init() first");
-    if (visible) await api.showCover();
-    else await api.hideCover();
-    lastVisualStateKeyRef.current = null;
-  }, []);
-  const captureCanvasFrame = useCallback(
-    async (time, options = {}) => {
-      const container = containerRef.current;
-      const api = renderAPIRef.current;
-      const captureCanvas = captureCanvasRef.current;
-      if (!container || !api || !captureCanvas) {
-        throw new Error("Frame capture not initialized \u2014 call init() first");
-      }
-      const { width, height } = dimensionsRef.current;
-      await api.seekTo(time);
-      const renderedTime = api.getRenderedTime();
-      if (Math.abs(renderedTime - time) > RENDER_TIME_EPSILON_SECONDS) {
-        throw new Error(
-          `Player committed ${renderedTime.toFixed(6)}s while capture requested ${time.toFixed(6)}s.`
-        );
-      }
-      const root = container.querySelector("#squisq-capture-root");
-      if (!root) {
-        throw new Error("Capture root element not found");
-      }
-      await waitForCaptureAssets(root, decodedImagesRef.current);
-      const visualStateKey = options.reuseIfUnchanged ? getFrameVisualStateKey(root, time) : null;
-      if (visualStateKey !== null && hasCapturedFrameRef.current && lastVisualStateKeyRef.current === visualStateKey) {
-        return captureCanvas;
-      }
-      const captureContext = captureCanvas.getContext("2d");
-      if (!captureContext) throw new Error("Could not create the frame capture canvas context");
-      captureContext.setTransform(1, 0, 0, 1, 0, 0);
-      captureContext.clearRect(0, 0, width, height);
-      const transientCloneCanvases = [];
-      let canvas;
-      try {
-        canvas = await html2canvas(root, {
-          canvas: captureCanvas,
-          width,
-          height,
-          scale: 1,
-          useCORS: true,
-          allowTaint: true,
-          backgroundColor: "#000000",
-          logging: false,
-          onclone: async (_clonedDocument, clonedRoot) => {
-            transientCloneCanvases.push(...prepareScheduledVideoClones(root, clonedRoot));
-            await rasterizeCaptureSvgClones(
-              root,
-              clonedRoot,
-              transientCloneCanvases,
-              captureImageDataUrlsRef.current
-            );
-          },
-          // html2canvas starts cloning at documentElement. Do not clone the rest
-          // of the editor/site UI on every frame; only the capture root, its
-          // ancestors, descendants, and document styles can affect this render.
-          ignoreElements: (element) => shouldIgnoreCaptureSibling(element, root)
-        });
-      } finally {
-        releaseCaptureCloneCanvases(transientCloneCanvases);
-      }
-      hasCapturedFrameRef.current = true;
-      lastVisualStateKeyRef.current = visualStateKey;
-      return canvas;
-    },
-    []
-  );
-  const captureFrame = useCallback(
-    async (time, options = {}) => {
-      const canvas = await captureCanvasFrame(time, options);
-      return createImageBitmap(canvas);
-    },
-    [captureCanvasFrame]
-  );
-  const destroy = useCallback(() => {
-    if (rootRef.current) {
-      rootRef.current.unmount();
-      rootRef.current = null;
-    }
-    if (containerRef.current) {
-      containerRef.current.remove();
-      containerRef.current = null;
-    }
-    mediaProviderRef.current?.dispose();
-    mediaProviderRef.current = null;
-    if (captureCanvasRef.current) {
-      captureCanvasRef.current.width = 0;
-      captureCanvasRef.current.height = 0;
-      captureCanvasRef.current = null;
-    }
-    lastVisualStateKeyRef.current = null;
-    hasCapturedFrameRef.current = false;
-    decodedImagesRef.current = /* @__PURE__ */ new WeakSet();
-    captureImageDataUrlsRef.current.clear();
-    renderAPIRef.current = null;
-  }, []);
-  return useMemo(
-    () => ({ init, setCoverVisible, captureFrame, captureCanvasFrame, destroy }),
-    [init, setCoverVisible, captureFrame, captureCanvasFrame, destroy]
-  );
-}
-
-// src/hooks/useVideoExport.ts
-import { useState, useRef as useRef2, useCallback as useCallback2, useEffect } from "react";
-import {
-  DEFAULT_INTERACTIVE_RESOURCE_POLICY,
-  fetchResourceBytes
-} from "@bendyline/squisq/markdown";
-import {
-  resolveDimensions,
-  computeAudioTimeline,
-  resolveFfmpegWasmLoad as resolveFfmpegWasmLoad2,
-  QUALITY_PRESETS
-} from "@bendyline/squisq-video";
-
-// src/workerEncoder.ts
-import { validateVideoExportOptions } from "@bendyline/squisq-video";
-function createWorkerEncoder(config) {
-  validateVideoExportOptions(config);
-  const worker = new Worker(new URL("./workers/encode.worker.js", import.meta.url), {
-    type: "module"
-  });
-  let state = "open";
-  let fatalError = null;
-  let finalizeResolve = null;
-  let finalizeReject = null;
-  let readyResolve = null;
-  let readyReject = null;
-  let readySettled = false;
-  const frameWaiters = /* @__PURE__ */ new Map();
-  const ready = new Promise((resolve, reject) => {
-    readyResolve = resolve;
-    readyReject = reject;
-  });
-  const frameDuration = 1e6 / config.fps;
-  function post(msg, transfer) {
-    worker.postMessage(msg, transfer ?? []);
-  }
-  const currentState = () => state;
-  worker.onmessage = (event) => {
-    const msg = event.data;
-    switch (msg.type) {
-      case "capabilities":
-        readySettled = true;
-        readyResolve?.(msg.backend);
-        readyResolve = readyReject = null;
-        break;
-      case "frame-complete": {
-        const waiter = frameWaiters.get(msg.frameIndex);
-        waiter?.resolve();
-        frameWaiters.delete(msg.frameIndex);
-        break;
-      }
-      case "complete":
-        state = "closed";
-        finalizeResolve?.(msg.data);
-        finalizeResolve = finalizeReject = null;
-        worker.terminate();
-        break;
-      case "error": {
-        const err = new Error(msg.message);
-        fatalError = err;
-        state = "closed";
-        readySettled = true;
-        readyReject?.(err);
-        finalizeReject?.(err);
-        for (const waiter of frameWaiters.values()) waiter.reject(err);
-        frameWaiters.clear();
-        readyResolve = readyReject = null;
-        finalizeResolve = finalizeReject = null;
-        worker.terminate();
-        break;
-      }
-    }
-  };
-  worker.onerror = (event) => {
-    const err = new Error(event.message || "Worker error");
-    fatalError = err;
-    state = "closed";
-    readySettled = true;
-    readyReject?.(err);
-    finalizeReject?.(err);
-    for (const waiter of frameWaiters.values()) waiter.reject(err);
-    frameWaiters.clear();
-    readyResolve = readyReject = null;
-    finalizeResolve = finalizeReject = null;
-    worker.terminate();
-  };
-  post({
-    type: "init",
-    width: config.width,
-    height: config.height,
-    fps: config.fps,
-    quality: config.quality,
-    ...config.totalFrames !== void 0 ? { totalFrames: config.totalFrames } : {},
-    ...config.ffmpegWasm ? { ffmpegWasm: config.ffmpegWasm } : {}
-  });
-  return {
-    ready,
-    encodeFrame(frame, frameIndex) {
-      if (typeof HTMLCanvasElement !== "undefined" && frame instanceof HTMLCanvasElement) {
-        return Promise.reject(new Error("Worker encoding requires a transferable ImageBitmap"));
-      }
-      const bitmap = frame;
-      if (state !== "open" || fatalError) {
-        bitmap.close();
-        return Promise.reject(fatalError ?? new Error("Encoder is not accepting frames"));
-      }
-      if (frameWaiters.has(frameIndex)) {
-        bitmap.close();
-        return Promise.reject(new Error(`Frame ${frameIndex} was submitted more than once`));
-      }
-      let resolveFrame;
-      let rejectFrame;
-      const promise = new Promise((resolve, reject) => {
-        resolveFrame = resolve;
-        rejectFrame = reject;
-      });
-      frameWaiters.set(frameIndex, { promise, resolve: resolveFrame, reject: rejectFrame });
-      const timestamp = Math.round(frameIndex * frameDuration);
-      post({ type: "frame", bitmap, frameIndex, timestamp }, [bitmap]);
-      return promise;
-    },
-    async finalize() {
-      if (state !== "open") throw new Error("Encoder already closed or finalizing");
-      if (fatalError) throw fatalError;
-      state = "finalizing";
-      await Promise.all(Array.from(frameWaiters.values(), (waiter) => waiter.promise));
-      if (currentState() === "closed") {
-        throw fatalError ?? new Error("Encoder closed during finalization");
-      }
-      return new Promise((resolve, reject) => {
-        finalizeResolve = resolve;
-        finalizeReject = reject;
-        post({ type: "finalize" });
-      });
-    },
-    close() {
-      if (state === "closed") return;
-      state = "closed";
-      const err = new Error("Encoder closed");
-      if (!readySettled) {
-        readySettled = true;
-        readyReject?.(err);
-      }
-      finalizeReject?.(err);
-      for (const waiter of frameWaiters.values()) waiter.reject(err);
-      frameWaiters.clear();
-      readyResolve = readyReject = null;
-      finalizeResolve = finalizeReject = null;
-      post({ type: "cancel" });
-      worker.terminate();
-    }
-  };
-}
-
-// src/gifTranscode.ts
-import {
-  ffmpegGifPaletteApplicationArgs,
-  ffmpegGifPaletteGenerationFilter,
-  resolveFfmpegWasmLoad
-} from "@bendyline/squisq-video";
-function buildGifPaletteFfmpegArgs(options) {
-  return [
-    "-y",
-    "-i",
-    "video.mp4",
-    "-vf",
-    ffmpegGifPaletteGenerationFilter(options),
-    "-frames:v",
-    "1",
-    "palette.png"
-  ];
-}
-function buildGifFfmpegArgs(options) {
-  return [
-    "-y",
-    "-i",
-    "video.mp4",
-    "-i",
-    "palette.png",
-    ...ffmpegGifPaletteApplicationArgs(options),
-    "out.gif"
-  ];
-}
-var FFMPEG_ERRORISH = /error|invalid|failed|out of memory|memory access|abort|unable to/i;
-function ffmpegFailureDetail(logs) {
-  const lines = logs.map((line) => line.trim()).filter(Boolean);
-  return lines.find((line) => FFMPEG_ERRORISH.test(line)) ?? lines.at(-1) ?? null;
-}
-async function transcodeMp4ToGifWithFfmpegWasm(videoMp4, options, loadConfig, signal) {
-  if (videoMp4.byteLength === 0) {
-    throw new Error("Cannot create an animated GIF from an empty MP4.");
-  }
-  if (signal?.aborted) {
-    throw new DOMException("Animated GIF export was cancelled.", "AbortError");
-  }
-  const load = resolveFfmpegWasmLoad(loadConfig, "Animated GIF export", {
-    classWorkerURL: new URL("./workers/ffmpeg.class-worker.js", import.meta.url).href
-  });
-  const paletteArgs = buildGifPaletteFfmpegArgs(options);
-  const gifArgs = buildGifFfmpegArgs(options);
-  const { FFmpeg } = await import("@ffmpeg/ffmpeg");
-  const ffmpeg = new FFmpeg();
-  const recentLogs = [];
-  const handleLog = ({ message }) => {
-    recentLogs.push(message);
-    if (recentLogs.length > 40) recentLogs.shift();
-  };
-  ffmpeg.on("log", handleLog);
-  let terminated = false;
-  const terminate = () => {
-    if (terminated) return;
-    terminated = true;
-    ffmpeg.terminate();
-  };
-  const handleAbort = () => terminate();
-  signal?.addEventListener("abort", handleAbort, { once: true });
-  try {
-    await ffmpeg.load(load);
-    if (signal?.aborted) {
-      throw new DOMException("Animated GIF export was cancelled.", "AbortError");
-    }
-    await ffmpeg.writeFile("video.mp4", videoMp4);
-    if (signal?.aborted) {
-      throw new DOMException("Animated GIF export was cancelled.", "AbortError");
-    }
-    const execPhase = async (args, phase) => {
-      recentLogs.length = 0;
-      let exitCode;
-      try {
-        exitCode = await ffmpeg.exec(args);
-      } catch (caught) {
-        if (signal?.aborted) {
-          throw new DOMException("Animated GIF export was cancelled.", "AbortError");
-        }
-        const detail = ffmpegFailureDetail(recentLogs);
-        const fallback = caught instanceof Error ? caught.message : String(caught);
-        throw new Error(`ffmpeg.wasm GIF transcode failed during ${phase}: ${detail ?? fallback}`);
-      }
-      if (signal?.aborted) {
-        throw new DOMException("Animated GIF export was cancelled.", "AbortError");
-      }
-      if (exitCode !== 0) {
-        const detail = ffmpegFailureDetail(recentLogs);
-        throw new Error(
-          `ffmpeg.wasm GIF transcode failed during ${phase} with exit code ${exitCode}` + (detail ? `: ${detail}` : "")
-        );
-      }
-    };
-    await execPhase(paletteArgs, "palette generation");
-    await execPhase(gifArgs, "palette application");
-    await ffmpeg.deleteFile("video.mp4").catch(() => false);
-    await ffmpeg.deleteFile("palette.png").catch(() => false);
-    const data = await ffmpeg.readFile("out.gif");
-    return data instanceof Uint8Array ? data : new TextEncoder().encode(data);
-  } finally {
-    signal?.removeEventListener("abort", handleAbort);
-    ffmpeg.off("log", handleLog);
-    terminate();
-  }
-}
-
-// src/hooks/useVideoExport.ts
-var MAX_EXPORT_MEDIA_FILES = 256;
-var ENCODER_PROBE_TIMEOUT_MS = 5e3;
-var ENCODER_START_TIMEOUT_MS = 6e4;
-var FRAME_CAPTURE_TIMEOUT_MS = 6e4;
-var FRAME_ENCODE_TIMEOUT_MS = 6e4;
-var CAPTURE_PROGRESS_START = 7;
-var CAPTURE_PROGRESS_END = 95;
-var FRAME_RATE_WINDOW_SIZE = 30;
-var DEFAULT_VIDEO_COVER_PRE_ROLL_SECONDS = 2;
-function calculateRollingFramesPerSecond(frameBoundaryTimes) {
-  if (frameBoundaryTimes.length < 2) return null;
-  const firstIndex = Math.max(0, frameBoundaryTimes.length - (FRAME_RATE_WINDOW_SIZE + 1));
-  const elapsedMs = frameBoundaryTimes[frameBoundaryTimes.length - 1] - frameBoundaryTimes[firstIndex];
-  const completedFrames = frameBoundaryTimes.length - 1 - firstIndex;
-  if (elapsedMs <= 0 || completedFrames <= 0) return null;
-  return completedFrames * 1e3 / elapsedMs;
-}
-function releaseEncoderFrame(frame) {
-  if ("close" in frame) frame.close();
-}
-function settleWithin(operation, timeoutMs, timeoutMessage, onLateResult) {
-  return new Promise((resolve, reject) => {
-    let settled = false;
-    const timeout = globalThis.setTimeout(() => {
-      settled = true;
-      reject(new Error(timeoutMessage));
-    }, timeoutMs);
-    void operation.then(
-      (value) => {
-        if (settled) {
-          onLateResult?.(value);
-          return;
-        }
-        settled = true;
-        globalThis.clearTimeout(timeout);
-        resolve(value);
-      },
-      (caught) => {
-        if (settled) return;
-        settled = true;
-        globalThis.clearTimeout(timeout);
-        reject(caught);
-      }
-    );
-  });
-}
-function toArrayBuffer(bytes) {
-  return bytes.slice().buffer;
-}
-function resolveExportMediaResourcePolicy(declaredSize, policy) {
-  const knownSize = Number.isFinite(declaredSize) ? Math.max(0, declaredSize) : 0;
-  return {
-    ...DEFAULT_INTERACTIVE_RESOURCE_POLICY,
-    ...policy,
-    maxBytes: policy?.maxBytes ?? Math.max(DEFAULT_INTERACTIVE_RESOURCE_POLICY.maxBytes, knownSize)
-  };
-}
-function collectDocumentMediaReferences(doc) {
-  const references = /* @__PURE__ */ new Set();
-  const seen = /* @__PURE__ */ new WeakSet();
-  const visit = (value) => {
-    if (typeof value === "string") {
-      references.add(value);
-      if (value.startsWith("./")) references.add(value.slice(2));
-      return;
-    }
-    if (!value || typeof value !== "object" || seen.has(value)) return;
-    seen.add(value);
-    if (Array.isArray(value)) {
-      value.forEach(visit);
-      return;
-    }
-    Object.values(value).forEach(visit);
-  };
-  visit(doc);
-  return references;
-}
-async function resolveAudioBuffers(clips, sources) {
-  const srcs = new Set(clips.map((c) => c.src));
-  const out = /* @__PURE__ */ new Map();
-  for (const src of srcs) {
-    let data = sources.audio?.get(src) ?? sources.images?.get(src);
-    if (!data && sources.mediaProvider) {
-      try {
-        const url = await sources.mediaProvider.resolveUrl(src);
-        const resource = await fetchResourceBytes(url, {
-          policy: sources.resourcePolicy
-        });
-        data = toArrayBuffer(resource.bytes);
-      } catch {
-      }
-    }
-    if (data) out.set(src, data);
-  }
-  return out;
-}
-function resolveFrontmatterBoolean(value) {
-  if (typeof value === "boolean") return value;
-  if (typeof value !== "string") return void 0;
-  const normalized = value.trim().toLowerCase();
-  if (normalized === "true" || normalized === "yes" || normalized === "on" || normalized === "show" || normalized === "visible") {
-    return true;
-  }
-  if (normalized === "false" || normalized === "no" || normalized === "off" || normalized === "hide" || normalized === "hidden") {
-    return false;
-  }
-  return void 0;
-}
-function resolveVideoExportCover(doc, config = {}) {
-  const frontmatter = doc.frontmatter;
-  const frontmatterValue = frontmatter ? Object.prototype.hasOwnProperty.call(frontmatter, "squisq-cover-slide") ? frontmatter["squisq-cover-slide"] : frontmatter["cover-slide"] : void 0;
-  const showCoverSlide = config.showCoverSlide ?? resolveFrontmatterBoolean(frontmatterValue) ?? true;
-  const requestedPreRoll = config.coverPreRoll ?? DEFAULT_VIDEO_COVER_PRE_ROLL_SECONDS;
-  if (!Number.isFinite(requestedPreRoll) || requestedPreRoll < 0) {
-    throw new Error("Cover pre-roll must be a finite number of seconds greater than or equal to 0");
-  }
-  return {
-    showCoverSlide,
-    coverPreRoll: showCoverSlide && !!doc.startBlock ? requestedPreRoll : 0
-  };
-}
-function useVideoExport(options = {}) {
-  const [state, setState] = useState("idle");
-  const [progress, setProgress] = useState(0);
-  const [phase, setPhase] = useState("");
-  const [currentFrameTime, setCurrentFrameTime] = useState(null);
-  const [processingFps, setProcessingFps] = useState(null);
-  const [duration, setDuration] = useState(0);
-  const [outputFormat, setOutputFormat] = useState("mp4");
-  const [backend, setBackend] = useState(null);
-  const [downloadUrl, setDownloadUrl] = useState(null);
-  const [outputBlob, setOutputBlob] = useState(null);
-  const [fileSize, setFileSize] = useState(0);
-  const [audioIncluded, setAudioIncluded] = useState(false);
-  const [audioSkippedReason, setAudioSkippedReason] = useState(null);
-  const [error, setError] = useState(null);
-  const [elapsed, setElapsed] = useState(0);
-  const [estimatedRemaining, setEstimatedRemaining] = useState(0);
-  const encoderRef = useRef2(null);
-  const gifAbortRef = useRef2(null);
-  const cancelledRef = useRef2(false);
-  const downloadUrlRef = useRef2(null);
-  const startTimeRef = useRef2(0);
-  const elapsedTimerRef = useRef2(null);
-  const previewOptionsRef = useRef2(options);
-  previewOptionsRef.current = options;
-  const frameCapture = useFrameCapture();
-  useEffect(() => {
-    return () => {
-      if (elapsedTimerRef.current) clearInterval(elapsedTimerRef.current);
-      if (downloadUrlRef.current) {
-        URL.revokeObjectURL(downloadUrlRef.current);
-      }
-      if (encoderRef.current) {
-        encoderRef.current.close();
-      }
-      gifAbortRef.current?.abort();
-      frameCapture.destroy();
-    };
-  }, [frameCapture]);
-  const reset = useCallback2(() => {
-    if (downloadUrlRef.current) {
-      URL.revokeObjectURL(downloadUrlRef.current);
-      downloadUrlRef.current = null;
-    }
-    if (encoderRef.current) {
-      encoderRef.current.close();
-      encoderRef.current = null;
-    }
-    gifAbortRef.current?.abort();
-    gifAbortRef.current = null;
-    frameCapture.destroy();
-    setState("idle");
-    setProgress(0);
-    setPhase("");
-    setCurrentFrameTime(null);
-    setProcessingFps(null);
-    setDuration(0);
-    setOutputFormat("mp4");
-    setBackend(null);
-    setDownloadUrl(null);
-    setOutputBlob(null);
-    setFileSize(0);
-    setAudioIncluded(false);
-    setAudioSkippedReason(null);
-    setError(null);
-    setElapsed(0);
-    setEstimatedRemaining(0);
-    if (elapsedTimerRef.current) clearInterval(elapsedTimerRef.current);
-    cancelledRef.current = false;
-  }, [frameCapture]);
-  const cancel = useCallback2(() => {
-    cancelledRef.current = true;
-    if (elapsedTimerRef.current) clearInterval(elapsedTimerRef.current);
-    if (encoderRef.current) {
-      encoderRef.current.close();
-      encoderRef.current = null;
-    }
-    gifAbortRef.current?.abort();
-    gifAbortRef.current = null;
-    frameCapture.destroy();
-    setState("idle");
-    setProgress(0);
-    setPhase("Cancelled");
-  }, [frameCapture]);
-  const startExport = useCallback2(
-    async (doc, config) => {
-      cancelledRef.current = false;
-      if (downloadUrlRef.current) {
-        URL.revokeObjectURL(downloadUrlRef.current);
-        downloadUrlRef.current = null;
-      }
-      setDownloadUrl(null);
-      setOutputBlob(null);
-      setFileSize(0);
-      setAudioIncluded(false);
-      setAudioSkippedReason(null);
-      setError(null);
-      setCurrentFrameTime(null);
-      setProcessingFps(null);
-      const quality = config.quality ?? "normal";
-      const effectiveOutputFormat = config.outputFormat ?? "mp4";
-      const fps = config.fps ?? (effectiveOutputFormat === "gif" ? 10 : 30);
-      const orientation = config.orientation ?? "landscape";
-      const animationsEnabled = config.animationsEnabled ?? effectiveOutputFormat === "mp4";
-      const captionMode = config.captionMode ?? (effectiveOutputFormat === "gif" ? "standard" : "off");
-      const audioPolicy = config.audioPolicy ?? "require";
-      setOutputFormat(effectiveOutputFormat);
-      try {
-        const cover = resolveVideoExportCover(doc, config);
-        const gifDefaults = orientation === "portrait" ? { width: 540, height: 960 } : { width: 960, height: 540 };
-        const { width, height } = resolveDimensions({
-          orientation,
-          fps,
-          quality,
-          ...config.width !== void 0 ? { width: config.width } : effectiveOutputFormat === "gif" ? { width: gifDefaults.width } : {},
-          ...config.height !== void 0 ? { height: config.height } : effectiveOutputFormat === "gif" ? { height: gifDefaults.height } : {}
-        });
-        const webCodecsAvailable = supportsWebCodecs();
-        const sharedArrayBufferAvailable = typeof SharedArrayBuffer !== "undefined";
-        if (effectiveOutputFormat === "gif" && !sharedArrayBufferAvailable) {
-          throw new Error(
-            "Animated GIF export requires ffmpeg.wasm and SharedArrayBuffer (Cross-Origin-Isolation headers)."
-          );
-        }
-        if (effectiveOutputFormat === "gif") {
-          resolveFfmpegWasmLoad2(config.ffmpegWasm, "Animated GIF export");
-        }
-        if (!webCodecsAvailable && !sharedArrayBufferAvailable) {
-          throw new Error(
-            "No video encoder available. WebCodecs requires Chrome 94+ / Edge 94+, and the ffmpeg.wasm fallback requires SharedArrayBuffer (Cross-Origin-Isolation headers)."
-          );
-        }
-        setState("preparing");
-        setPhase("Loading document\u2026");
-        setProgress(0);
-        setElapsed(0);
-        setEstimatedRemaining(0);
-        startTimeRef.current = performance.now();
-        if (elapsedTimerRef.current) clearInterval(elapsedTimerRef.current);
-        elapsedTimerRef.current = setInterval(() => {
-          setElapsed(Math.floor((performance.now() - startTimeRef.current) / 1e3));
-        }, 1e3);
-        let images = config.images;
-        if (!images && config.mediaProvider) {
-          images = /* @__PURE__ */ new Map();
-          const entries = await config.mediaProvider.listMedia();
-          const references = collectDocumentMediaReferences(doc);
-          const neededEntries = entries.filter(
-            (entry) => references.has(entry.name) || references.has(`./${entry.name}`)
-          );
-          if (neededEntries.length > MAX_EXPORT_MEDIA_FILES) {
-            throw new Error(
-              `Document references ${neededEntries.length} media files; browser export supports at most ${MAX_EXPORT_MEDIA_FILES}.`
-            );
-          }
-          for (const entry of neededEntries) {
-            if (cancelledRef.current) return;
-            const url2 = await config.mediaProvider.resolveUrl(entry.name);
-            const resource = await fetchResourceBytes(url2, {
-              policy: resolveExportMediaResourcePolicy(entry.size, config.resourcePolicy)
-            });
-            const data = toArrayBuffer(resource.bytes);
-            images.set(entry.name, data);
-          }
-        }
-        const docDuration = await frameCapture.init(
-          doc,
-          {
-            images,
-            audio: config.audio,
-            width,
-            height,
-            animationsEnabled,
-            theme: config.theme,
-            videoPresentation: config.videoPresentation,
-            pipSize: config.pipSize,
-            pipShape: config.pipShape,
-            pipPosition: config.pipPosition,
-            showCoverSlide: cover.showCoverSlide
-          },
-          captionMode
-        );
-        if (cancelledRef.current) return;
-        if (docDuration <= 0) {
-          throw new Error("Document has zero duration \u2014 nothing to export");
-        }
-        const coverFrameCount = Math.ceil(cover.coverPreRoll * fps);
-        const storyFrameCount = Math.ceil(docDuration * fps);
-        const totalFrames = coverFrameCount + storyFrameCount;
-        const exportDuration = totalFrames / fps;
-        setDuration(exportDuration);
-        setPhase("Checking video encoder\u2026");
-        setProgress(5);
-        const canUseWebCodecs = webCodecsAvailable && await settleWithin(
-          supportsWebCodecsH264({ width, height, fps, quality }),
-          ENCODER_PROBE_TIMEOUT_MS,
-          "The browser did not finish checking WebCodecs support."
-        ).catch(() => false);
-        const audioBitrate = (QUALITY_PRESETS[quality] ?? QUALITY_PRESETS.normal).audioBitrate;
-        const timeline = effectiveOutputFormat === "mp4" && audioPolicy !== "omit" ? computeAudioTimeline(doc, coverFrameCount / fps) : [];
-        const aacSupported = timeline.length > 0 ? await supportsWebCodecsAac(EXPORT_AUDIO_SAMPLE_RATE, EXPORT_AUDIO_CHANNELS) : false;
-        const tierDecision = selectAudioTier({
-          hasClips: timeline.length > 0,
-          aacSupported,
-          sharedArrayBufferAvailable,
-          canUseMainThreadWebCodecs: canUseWebCodecs
-        });
-        let renderedAudio = null;
-        let audioIncludedLocal = false;
-        let audioReasonLocal = tierDecision.reason;
-        if (timeline.length > 0 && tierDecision.tier === 3 && audioPolicy === "require") {
-          throw new Error(tierDecision.reason ?? "This browser cannot include the document audio.");
-        }
-        if (tierDecision.tier === 1 || tierDecision.tier === 2) {
-          setPhase("Preparing audio\u2026");
-          try {
-            const buffers = await resolveAudioBuffers(timeline, {
-              audio: config.audio,
-              images,
-              mediaProvider: config.mediaProvider,
-              resourcePolicy: config.resourcePolicy
-            });
-            const missingSources = [...new Set(timeline.map((clip) => clip.src))].filter(
-              (src) => !buffers.has(src)
-            );
-            if (missingSources.length > 0) {
-              audioReasonLocal = `Audio files could not be loaded: ${missingSources.join(", ")}`;
-              if (audioPolicy === "require") throw new Error(audioReasonLocal);
-            }
-            if (buffers.size === 0) {
-              audioReasonLocal ?? (audioReasonLocal = "Audio files for this document could not be loaded.");
-            } else {
-              const totalAudioDur = timeline.reduce(
-                (max, c) => Math.max(max, c.startSec + c.durationSec),
-                exportDuration
-              );
-              renderedAudio = await renderAudioTimeline(
-                timeline,
-                buffers,
-                totalAudioDur,
-                EXPORT_AUDIO_SAMPLE_RATE
-              );
-              if (!renderedAudio) {
-                audioReasonLocal = "No included video source contained a decodable audio track.";
-              }
-            }
-          } catch (audioErr) {
-            renderedAudio = null;
-            audioReasonLocal = `Audio could not be prepared: ${audioErr instanceof Error ? audioErr.message : String(audioErr)}`;
-            if (audioPolicy === "require") throw new Error(audioReasonLocal);
-          }
-        }
-        const useInlineAudio = renderedAudio !== null && tierDecision.tier === 1;
-        const useFfmpegAudio = renderedAudio !== null && tierDecision.tier === 2;
-        if (cancelledRef.current) return;
-        let encoder;
-        if (canUseWebCodecs) {
-          encoder = createEncoder({
-            width,
-            height,
-            fps,
-            quality,
-            ...useInlineAudio && renderedAudio ? {
-              audio: {
-                numberOfChannels: renderedAudio.numberOfChannels,
-                sampleRate: renderedAudio.sampleRate
-              }
-            } : {}
-          });
-          encoderRef.current = encoder;
-          setBackend("webcodecs");
-        } else if (sharedArrayBufferAvailable) {
-          setProgress(6);
-          setPhase("Loading export engine\u2026");
-          const workerEncoder = createWorkerEncoder({
-            width,
-            height,
-            fps,
-            quality,
-            totalFrames,
-            ffmpegWasm: config.ffmpegWasm
-          });
-          encoder = workerEncoder;
-          encoderRef.current = workerEncoder;
-          const selectedBackend = await settleWithin(
-            workerEncoder.ready,
-            ENCODER_START_TIMEOUT_MS,
-            "The browser export engine did not start within 60 seconds."
-          );
-          setBackend(selectedBackend);
-        } else {
-          throw new Error(
-            "WebCodecs H.264 is unavailable in this browser and the ffmpeg.wasm fallback requires SharedArrayBuffer (Cross-Origin-Isolation headers)."
-          );
-        }
-        if (cancelledRef.current) return;
-        setProgress(CAPTURE_PROGRESS_START);
-        setPhase(`Capturing frame 1/${totalFrames}`);
-        setCurrentFrameTime(0);
-        setState("capturing");
-        const captureStartTime = performance.now();
-        const frameBoundaryTimes = [captureStartTime];
-        if (coverFrameCount > 0) await frameCapture.setCoverVisible(true);
-        for (let i = 0; i < totalFrames; i++) {
-          if (cancelledRef.current) return;
-          if (coverFrameCount > 0 && i === coverFrameCount) {
-            await frameCapture.setCoverVisible(false);
-          }
-          const time = i / fps;
-          const captureTime = i < coverFrameCount ? 0 : (i - coverFrameCount) / fps;
-          const captureOperation = canUseWebCodecs ? frameCapture.captureCanvasFrame(captureTime, { reuseIfUnchanged: true }) : frameCapture.captureFrame(captureTime, { reuseIfUnchanged: true });
-          const frame = await settleWithin(
-            captureOperation,
-            FRAME_CAPTURE_TIMEOUT_MS,
-            `Frame capture stopped responding at frame ${i + 1}/${totalFrames}.`,
-            releaseEncoderFrame
-          );
-          if (cancelledRef.current) {
-            releaseEncoderFrame(frame);
-            return;
-          }
-          const previewOptions = previewOptionsRef.current;
-          const previewInterval = Math.max(1, Math.floor(previewOptions.previewEveryNFrames ?? 1));
-          if (previewOptions.onFramePreview && (i === 0 || i === totalFrames - 1 || i % previewInterval === 0)) {
-            try {
-              previewOptions.onFramePreview({ source: frame, frameIndex: i, totalFrames, time });
-            } catch {
-            }
-          }
-          setPhase(`Encoding frame ${i + 1}/${totalFrames}`);
-          setCurrentFrameTime(time);
-          await settleWithin(
-            encoder.encodeFrame(frame, i),
-            FRAME_ENCODE_TIMEOUT_MS,
-            `Video encoding stopped responding at frame ${i + 1}/${totalFrames}.`
-          );
-          const completedFrames = i + 1;
-          const completedAt = performance.now();
-          frameBoundaryTimes.push(completedAt);
-          if (frameBoundaryTimes.length > FRAME_RATE_WINDOW_SIZE + 1) {
-            frameBoundaryTimes.shift();
-          }
-          setProcessingFps(calculateRollingFramesPerSecond(frameBoundaryTimes));
-          setCurrentFrameTime(Math.min(completedFrames / fps, exportDuration));
-          setPhase(
-            completedFrames < totalFrames ? `Capturing frame ${completedFrames + 1}/${totalFrames}` : `Captured ${totalFrames.toLocaleString()} frames\u2026`
-          );
-          const captureRatio = completedFrames / totalFrames;
-          const captureProgress = CAPTURE_PROGRESS_START + captureRatio * (CAPTURE_PROGRESS_END - CAPTURE_PROGRESS_START);
-          setProgress(Math.round(captureProgress * 10) / 10);
-          const elapsedCapture = (performance.now() - captureStartTime) / 1e3;
-          const avgPerFrame = elapsedCapture / completedFrames;
-          setEstimatedRemaining(Math.round(avgPerFrame * (totalFrames - completedFrames)));
-          setElapsed(Math.floor((performance.now() - startTimeRef.current) / 1e3));
-        }
-        if (cancelledRef.current) return;
-        if (useInlineAudio && renderedAudio && encoder.addAudioChunk) {
-          setState("encoding");
-          setPhase("Encoding audio\u2026");
-          try {
-            await encodeAacTrack(
-              renderedAudio,
-              { addAudioChunk: encoder.addAudioChunk.bind(encoder) },
-              audioBitrate
-            );
-            audioIncludedLocal = true;
-          } catch (audioErr) {
-            audioIncludedLocal = false;
-            audioReasonLocal = `Audio encoding failed: ${audioErr instanceof Error ? audioErr.message : String(audioErr)}`;
-            if (audioPolicy === "require") throw new Error(audioReasonLocal);
-          }
-        }
-        setState("encoding");
-        setPhase(effectiveOutputFormat === "gif" ? "Finalizing GIF frames\u2026" : "Finalizing video\u2026");
-        setProgress(95);
-        let outputBytes = await encoder.finalize();
-        encoderRef.current = null;
-        if (cancelledRef.current) return;
-        if (effectiveOutputFormat === "gif") {
-          setPhase("Generating GIF palette\u2026");
-          const videoOnly = outputBytes instanceof Uint8Array ? outputBytes : new Uint8Array(outputBytes);
-          const gifAbort = new AbortController();
-          gifAbortRef.current = gifAbort;
-          try {
-            outputBytes = await transcodeMp4ToGifWithFfmpegWasm(
-              videoOnly,
-              { width, height, loop: 0 },
-              config.ffmpegWasm,
-              gifAbort.signal
-            );
-          } finally {
-            if (gifAbortRef.current === gifAbort) gifAbortRef.current = null;
-          }
-        } else if (useFfmpegAudio && renderedAudio) {
-          setPhase("Muxing audio\u2026");
-          try {
-            const wav = audioBufferToWav(renderedAudio);
-            const videoOnly = outputBytes instanceof Uint8Array ? outputBytes : new Uint8Array(outputBytes);
-            outputBytes = await muxAudioWithFfmpegWasm(
-              videoOnly,
-              wav,
-              audioBitrate,
-              config.ffmpegWasm
-            );
-            audioIncludedLocal = true;
-          } catch (audioErr) {
-            audioIncludedLocal = false;
-            audioReasonLocal = `Audio muxing failed: ${audioErr instanceof Error ? audioErr.message : String(audioErr)}`;
-            if (audioPolicy === "require") throw new Error(audioReasonLocal);
-          }
-        }
-        if (cancelledRef.current) return;
-        const finalBytes = outputBytes instanceof Uint8Array ? outputBytes.slice() : new Uint8Array(outputBytes);
-        const mimeType = effectiveOutputFormat === "gif" ? "image/gif" : "video/mp4";
-        const blob = new Blob([finalBytes], { type: mimeType });
-        const url = URL.createObjectURL(blob);
-        downloadUrlRef.current = url;
-        setDownloadUrl(url);
-        setOutputBlob(blob);
-        setFileSize(finalBytes.byteLength);
-        setAudioIncluded(audioIncludedLocal);
-        setAudioSkippedReason(
-          effectiveOutputFormat === "gif" || audioIncludedLocal ? null : audioReasonLocal
-        );
-        setState("complete");
-        setProgress(100);
-        setPhase("Export complete");
-        setEstimatedRemaining(0);
-        if (elapsedTimerRef.current) clearInterval(elapsedTimerRef.current);
-        frameCapture.destroy();
-      } catch (err) {
-        if (elapsedTimerRef.current) clearInterval(elapsedTimerRef.current);
-        if (cancelledRef.current) return;
-        const message = err instanceof Error ? err.message : String(err);
-        setState("error");
-        setError(message);
-        setPhase("Export failed");
-        if (encoderRef.current) {
-          encoderRef.current.close();
-          encoderRef.current = null;
-        }
-        gifAbortRef.current?.abort();
-        gifAbortRef.current = null;
-        frameCapture.destroy();
-      }
-    },
-    [frameCapture]
-  );
-  return {
-    state,
-    progress,
-    phase,
-    currentFrameTime,
-    processingFps,
-    duration,
-    outputFormat,
-    backend,
-    downloadUrl,
-    outputBlob,
-    fileSize,
-    audioIncluded,
-    audioSkippedReason,
-    error,
-    elapsed,
-    estimatedRemaining,
-    startExport,
-    cancel,
-    reset
-  };
-}
-
-export {
-  useFrameCapture,
-  DEFAULT_VIDEO_COVER_PRE_ROLL_SECONDS,
-  resolveVideoExportCover,
-  useVideoExport
-};