init commit

remotion/node_modules/@remotion/web-renderer/dist/add-sample.d.ts

@@ -0,0 +1,3 @@
+import type { AudioSampleSource, VideoSampleSource } from 'mediabunny';
+export declare const addVideoSampleAndCloseFrame: (frameToEncode: VideoFrame, videoSampleSource: VideoSampleSource) => Promise<void>;
+export declare const addAudioSample: (audio: AudioData, audioSampleSource: AudioSampleSource) => Promise<void>;

remotion/node_modules/@remotion/web-renderer/dist/artifact.d.ts

@@ -0,0 +1,23 @@
+import type { DownloadBehavior, TRenderAsset } from 'remotion';
+export type EmittedArtifact = {
+    filename: string;
+    content: string | Uint8Array;
+    frame: number;
+    downloadBehavior: DownloadBehavior | null;
+};
+export declare const onlyArtifact: ({ assets, frameBuffer, }: {
+    assets: TRenderAsset[];
+    frameBuffer: Blob | OffscreenCanvas | null;
+}) => Promise<EmittedArtifact[]>;
+export type WebRendererOnArtifact = (asset: EmittedArtifact) => void;
+export type ArtifactsRef = React.RefObject<{
+    collectAssets: () => TRenderAsset[];
+} | null>;
+export declare const handleArtifacts: () => {
+    handle: ({ imageData, frame, assets: artifactAssets, onArtifact, }: {
+        imageData: Blob | OffscreenCanvas | null;
+        frame: number;
+        assets: TRenderAsset[];
+        onArtifact: WebRendererOnArtifact;
+    }) => Promise<void>;
+};

remotion/node_modules/@remotion/web-renderer/dist/audio.d.ts

@@ -0,0 +1,6 @@
+import type { TRenderAsset } from 'remotion';
+export declare const onlyInlineAudio: ({ assets, fps, timestamp, }: {
+    assets: TRenderAsset[];
+    fps: number;
+    timestamp: number;
+}) => AudioData | null;

remotion/node_modules/@remotion/web-renderer/dist/background-keepalive.d.ts

@@ -0,0 +1,9 @@
+import { type LogLevel } from 'remotion';
+export type BackgroundKeepalive = {
+    waitForTick: () => Promise<void>;
+    [Symbol.dispose]: () => void;
+};
+export declare function createBackgroundKeepalive({ fps, logLevel }: {
+    fps: number;
+    logLevel: LogLevel;
+}): BackgroundKeepalive;

remotion/node_modules/@remotion/web-renderer/dist/can-render-media-on-web.d.ts

@@ -0,0 +1,3 @@
+import type { CanRenderMediaOnWebOptions, CanRenderMediaOnWebResult } from './can-render-types';
+export type { CanRenderIssue, CanRenderMediaOnWebOptions, CanRenderMediaOnWebResult, } from './can-render-types';
+export declare const canRenderMediaOnWeb: (options: CanRenderMediaOnWebOptions) => Promise<CanRenderMediaOnWebResult>;

remotion/node_modules/@remotion/web-renderer/dist/can-render-types.d.ts

@@ -0,0 +1,27 @@
+import type { WebRendererAudioCodec, WebRendererContainer, WebRendererQuality, WebRendererVideoCodec } from './mediabunny-mappings';
+import type { WebRendererOutputTarget } from './output-target';
+export type CanRenderIssueType = 'video-codec-unsupported' | 'audio-codec-unsupported' | 'webgl-unsupported' | 'webcodecs-unavailable' | 'container-codec-mismatch' | 'transparent-video-unsupported' | 'invalid-dimensions' | 'output-target-unsupported';
+export type CanRenderIssue = {
+    type: CanRenderIssueType;
+    message: string;
+    severity: 'error' | 'warning';
+};
+export type CanRenderMediaOnWebResult = {
+    canRender: boolean;
+    issues: CanRenderIssue[];
+    resolvedVideoCodec: WebRendererVideoCodec;
+    resolvedAudioCodec: WebRendererAudioCodec | null;
+    resolvedOutputTarget: WebRendererOutputTarget;
+};
+export type CanRenderMediaOnWebOptions = {
+    container?: WebRendererContainer;
+    videoCodec?: WebRendererVideoCodec;
+    audioCodec?: WebRendererAudioCodec | null;
+    width: number;
+    height: number;
+    transparent?: boolean;
+    muted?: boolean;
+    videoBitrate?: number | WebRendererQuality;
+    audioBitrate?: number | WebRendererQuality;
+    outputTarget?: WebRendererOutputTarget | null;
+};

remotion/node_modules/@remotion/web-renderer/dist/can-use-webfs-target.d.ts

@@ -0,0 +1 @@
+export declare const canUseWebFsWriter: () => Promise<boolean>;

remotion/node_modules/@remotion/web-renderer/dist/check-webgl-support.d.ts

@@ -0,0 +1,2 @@
+import type { CanRenderIssue } from './can-render-types';
+export declare const checkWebGLSupport: () => CanRenderIssue | null;

remotion/node_modules/@remotion/web-renderer/dist/compose.d.ts

@@ -0,0 +1,26 @@
+export declare const compose: ({ element, context, logLevel, parentRect, internalState, onlyBackgroundClipText, scale, }: {
+    element: HTMLElement | SVGElement;
+    context: OffscreenCanvasRenderingContext2D;
+    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
+    parentRect: DOMRect;
+    internalState: {
+        getDrawn3dPixels: () => number;
+        getPrecomposedTiles: () => number;
+        addPrecompose: ({ canvasWidth, canvasHeight, }: {
+            canvasWidth: number;
+            canvasHeight: number;
+        }) => void;
+        helperCanvasState: import("./internal-state").HelperCanvasState;
+        [Symbol.dispose]: () => void;
+        getWaitForReadyTime: () => number;
+        addWaitForReadyTime: (time: number) => void;
+        getAddSampleTime: () => number;
+        addAddSampleTime: (time: number) => void;
+        getCreateFrameTime: () => number;
+        addCreateFrameTime: (time: number) => void;
+        getAudioMixingTime: () => number;
+        addAudioMixingTime: (time: number) => void;
+    };
+    onlyBackgroundClipText: boolean;
+    scale: number;
+}) => Promise<void>;

remotion/node_modules/@remotion/web-renderer/dist/create-audio-sample-source.d.ts

@@ -0,0 +1,9 @@
+import { AudioSampleSource, type Quality } from 'mediabunny';
+export declare const createAudioSampleSource: ({ muted, codec, bitrate, }: {
+    muted: boolean;
+    codec: "aac" | "alaw" | "flac" | "mp3" | "opus" | "pcm-f32" | "pcm-f32be" | "pcm-f64" | "pcm-f64be" | "pcm-s16" | "pcm-s16be" | "pcm-s24" | "pcm-s24be" | "pcm-s32" | "pcm-s32be" | "pcm-s8" | "pcm-u8" | "ulaw" | "vorbis" | null;
+    bitrate: number | Quality;
+}) => {
+    audioSampleSource: AudioSampleSource;
+    [Symbol.dispose]: () => void;
+} | null;

remotion/node_modules/@remotion/web-renderer/dist/create-scaffold.d.ts

@@ -0,0 +1,35 @@
+import { type ComponentType } from 'react';
+import type { Codec, DelayRenderScope, LogLevel, TRenderAsset } from 'remotion';
+import type { AnyZodObject } from 'zod';
+import type { TimeUpdaterRef } from './update-time';
+export type ErrorHolder = {
+    error: Error | null;
+};
+export declare function checkForError(errorHolder: ErrorHolder): void;
+export declare function createScaffold<Props extends Record<string, unknown>>({ width, height, delayRenderTimeoutInMilliseconds, logLevel, resolvedProps, id, mediaCacheSizeInBytes, durationInFrames, fps, initialFrame, schema, Component, audioEnabled, videoEnabled, defaultCodec, defaultOutName }: {
+    width: number;
+    height: number;
+    delayRenderTimeoutInMilliseconds: number;
+    logLevel: LogLevel;
+    resolvedProps: Record<string, unknown>;
+    id: string;
+    mediaCacheSizeInBytes: number | null;
+    initialFrame: number;
+    durationInFrames: number;
+    fps: number;
+    schema: AnyZodObject | null;
+    Component: ComponentType<Props>;
+    audioEnabled: boolean;
+    videoEnabled: boolean;
+    defaultCodec: Codec | null;
+    defaultOutName: string | null;
+}): {
+    delayRenderScope: DelayRenderScope;
+    div: HTMLDivElement;
+    timeUpdater: React.RefObject<TimeUpdaterRef | null>;
+    collectAssets: React.RefObject<{
+        collectAssets: () => TRenderAsset[];
+    } | null>;
+    errorHolder: ErrorHolder;
+    [Symbol.dispose]: () => void;
+};

remotion/node_modules/@remotion/web-renderer/dist/drawing/border-radius.d.ts

@@ -0,0 +1,31 @@
+export type BorderRadiusCorners = {
+    topLeft: {
+        horizontal: number;
+        vertical: number;
+    };
+    topRight: {
+        horizontal: number;
+        vertical: number;
+    };
+    bottomRight: {
+        horizontal: number;
+        vertical: number;
+    };
+    bottomLeft: {
+        horizontal: number;
+        vertical: number;
+    };
+};
+export declare function parseBorderRadius({ borderRadius, width, height }: {
+    borderRadius: string;
+    width: number;
+    height: number;
+}): BorderRadiusCorners;
+export declare function setBorderRadius({ ctx, rect, borderRadius, forceClipEvenWhenZero, computedStyle, backgroundClip }: {
+    ctx: OffscreenCanvasRenderingContext2D;
+    rect: DOMRect;
+    borderRadius: BorderRadiusCorners;
+    forceClipEvenWhenZero: boolean;
+    computedStyle: CSSStyleDeclaration;
+    backgroundClip: string;
+}): () => void;

remotion/node_modules/@remotion/web-renderer/dist/drawing/calculate-object-fit.d.ts

@@ -0,0 +1,40 @@
+export type ObjectFit = 'fill' | 'contain' | 'cover' | 'none' | 'scale-down';
+export type ObjectFitResult = {
+    sourceX: number;
+    sourceY: number;
+    sourceWidth: number;
+    sourceHeight: number;
+    destX: number;
+    destY: number;
+    destWidth: number;
+    destHeight: number;
+};
+type ObjectFitParams = {
+    containerSize: {
+        width: number;
+        height: number;
+        left: number;
+        top: number;
+    };
+    intrinsicSize: {
+        width: number;
+        height: number;
+    };
+};
+/**
+ * Calculates how to draw an image based on object-fit CSS property.
+ *
+ * @param objectFit - The CSS object-fit value
+ * @param containerSize - The container dimensions (where the image should be drawn)
+ * @param intrinsicSize - The natural/intrinsic size of the image
+ * @returns Source and destination rectangles for drawImage
+ */
+export declare const calculateObjectFit: ({ objectFit, containerSize, intrinsicSize, }: {
+    objectFit: ObjectFit;
+} & ObjectFitParams) => ObjectFitResult;
+/**
+ * Parse an object-fit CSS value string into our ObjectFit type.
+ * Returns 'fill' as the default if the value is not recognized.
+ */
+export declare const parseObjectFit: (value: string | null | undefined) => ObjectFit;
+export {};

remotion/node_modules/@remotion/web-renderer/dist/drawing/calculate-transforms.d.ts

@@ -0,0 +1,21 @@
+import type { LinearGradientInfo } from './parse-linear-gradient';
+export declare const calculateTransforms: ({ element, rootElement, }: {
+    element: HTMLElement | SVGElement;
+    rootElement: HTMLElement | SVGElement;
+}) => {
+    dimensions: DOMRect;
+    totalMatrix: DOMMatrix;
+    [Symbol.dispose]: () => void;
+    nativeTransformOrigin: {
+        x: number;
+        y: number;
+    };
+    computedStyle: CSSStyleDeclaration;
+    opacity: number;
+    maskImageInfo: LinearGradientInfo | null;
+    precompositing: {
+        needs3DTransformViaWebGL: boolean;
+        needsMaskImage: LinearGradientInfo | null;
+        needsPrecompositing: boolean;
+    };
+};

remotion/node_modules/@remotion/web-renderer/dist/drawing/clamp-rect-to-parent-bounds.d.ts

@@ -0,0 +1,8 @@
+export declare const getNarrowerRect: ({ firstRect, secondRect, }: {
+    firstRect: DOMRect;
+    secondRect: DOMRect;
+}) => DOMRect;
+export declare const getWiderRectAndExpand: ({ firstRect, secondRect, }: {
+    firstRect: DOMRect | null;
+    secondRect: DOMRect;
+}) => DOMRect;

remotion/node_modules/@remotion/web-renderer/dist/drawing/do-rects-intersect.d.ts

@@ -0,0 +1 @@
+export declare function doRectsIntersect(rect1: DOMRect, rect2: DOMRect): boolean;

remotion/node_modules/@remotion/web-renderer/dist/drawing/draw-background.d.ts

@@ -0,0 +1,31 @@
+export declare const drawBackground: ({ backgroundImage, context, rect, backgroundColor, backgroundClip, element, logLevel, internalState, computedStyle, offsetLeft: parentOffsetLeft, offsetTop: parentOffsetTop, scale, }: {
+    backgroundImage: string;
+    context: OffscreenCanvasRenderingContext2D;
+    rect: DOMRect;
+    backgroundColor: string;
+    backgroundClip: string;
+    element: HTMLElement | SVGElement;
+    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
+    internalState: {
+        getDrawn3dPixels: () => number;
+        getPrecomposedTiles: () => number;
+        addPrecompose: ({ canvasWidth, canvasHeight, }: {
+            canvasWidth: number;
+            canvasHeight: number;
+        }) => void;
+        helperCanvasState: import("../internal-state").HelperCanvasState;
+        [Symbol.dispose]: () => void;
+        getWaitForReadyTime: () => number;
+        addWaitForReadyTime: (time: number) => void;
+        getAddSampleTime: () => number;
+        addAddSampleTime: (time: number) => void;
+        getCreateFrameTime: () => number;
+        addCreateFrameTime: (time: number) => void;
+        getAudioMixingTime: () => number;
+        addAudioMixingTime: (time: number) => void;
+    };
+    computedStyle: CSSStyleDeclaration;
+    offsetLeft: number;
+    offsetTop: number;
+    scale: number;
+}) => Promise<void>;

remotion/node_modules/@remotion/web-renderer/dist/drawing/draw-border.d.ts

@@ -0,0 +1,7 @@
+import type { BorderRadiusCorners } from './border-radius';
+export declare const drawBorder: ({ ctx, rect, borderRadius, computedStyle, }: {
+    ctx: OffscreenCanvasRenderingContext2D;
+    rect: DOMRect;
+    borderRadius: BorderRadiusCorners;
+    computedStyle: CSSStyleDeclaration;
+}) => void;

remotion/node_modules/@remotion/web-renderer/dist/drawing/draw-box-shadow.d.ts

@@ -0,0 +1,17 @@
+import type { BorderRadiusCorners } from './border-radius';
+interface BoxShadow {
+    offsetX: number;
+    offsetY: number;
+    blurRadius: number;
+    color: string;
+    inset: boolean;
+}
+export declare const parseBoxShadow: (boxShadowValue: string) => BoxShadow[];
+export declare const drawBorderRadius: ({ ctx, rect, borderRadius, computedStyle, logLevel, }: {
+    ctx: OffscreenCanvasRenderingContext2D;
+    rect: DOMRect;
+    borderRadius: BorderRadiusCorners;
+    computedStyle: CSSStyleDeclaration;
+    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
+}) => void;
+export {};

remotion/node_modules/@remotion/web-renderer/dist/drawing/draw-dom-element.d.ts

@@ -0,0 +1,2 @@
+import type { DrawFn } from './drawn-fn';
+export declare const drawDomElement: (node: HTMLElement | SVGElement) => DrawFn;

remotion/node_modules/@remotion/web-renderer/dist/drawing/draw-element.d.ts

@@ -0,0 +1,33 @@
+import type { DrawFn } from './drawn-fn';
+export declare const drawElement: ({ rect, computedStyle, context, draw, opacity, totalMatrix, parentRect, logLevel, element, internalState, scale, }: {
+    rect: DOMRect;
+    computedStyle: CSSStyleDeclaration;
+    context: OffscreenCanvasRenderingContext2D;
+    opacity: number;
+    totalMatrix: DOMMatrix;
+    draw: DrawFn;
+    parentRect: DOMRect;
+    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
+    element: HTMLElement | SVGElement;
+    internalState: {
+        getDrawn3dPixels: () => number;
+        getPrecomposedTiles: () => number;
+        addPrecompose: ({ canvasWidth, canvasHeight, }: {
+            canvasWidth: number;
+            canvasHeight: number;
+        }) => void;
+        helperCanvasState: import("../internal-state").HelperCanvasState;
+        [Symbol.dispose]: () => void;
+        getWaitForReadyTime: () => number;
+        addWaitForReadyTime: (time: number) => void;
+        getAddSampleTime: () => number;
+        addAddSampleTime: (time: number) => void;
+        getCreateFrameTime: () => number;
+        addCreateFrameTime: (time: number) => void;
+        getAudioMixingTime: () => number;
+        addAudioMixingTime: (time: number) => void;
+    };
+    scale: number;
+}) => Promise<{
+    cleanupAfterChildren: () => void;
+}>;

remotion/node_modules/@remotion/web-renderer/dist/drawing/draw-outline.d.ts

@@ -0,0 +1,9 @@
+import type { BorderRadiusCorners } from './border-radius';
+export declare const parseOutlineWidth: (value: string) => number;
+export declare const parseOutlineOffset: (value: string) => number;
+export declare const drawOutline: ({ ctx, rect, borderRadius, computedStyle, }: {
+    ctx: OffscreenCanvasRenderingContext2D;
+    rect: DOMRect;
+    borderRadius: BorderRadiusCorners;
+    computedStyle: CSSStyleDeclaration;
+}) => void;

remotion/node_modules/@remotion/web-renderer/dist/drawing/draw-rounded.d.ts

@@ -0,0 +1,9 @@
+import type { BorderRadiusCorners } from './border-radius';
+export declare const drawRoundedRectPath: ({ ctx, x, y, width, height, borderRadius, }: {
+    ctx: OffscreenCanvasRenderingContext2D;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    borderRadius: BorderRadiusCorners;
+}) => void;

remotion/node_modules/@remotion/web-renderer/dist/drawing/drawn-fn.d.ts

@@ -0,0 +1,5 @@
+export type DrawFn = ({ computedStyle, contextToDraw, dimensions }: {
+    dimensions: DOMRect;
+    computedStyle: CSSStyleDeclaration;
+    contextToDraw: OffscreenCanvasRenderingContext2D;
+}) => Promise<void> | void;

remotion/node_modules/@remotion/web-renderer/dist/drawing/fit-svg-into-its-dimensions.d.ts

@@ -0,0 +1,12 @@
+export declare const fitSvgIntoItsContainer: ({ containerSize, elementSize, }: {
+    containerSize: DOMRect;
+    elementSize: {
+        width: number;
+        height: number;
+    };
+}) => {
+    width: number;
+    height: number;
+    top: number;
+    left: number;
+};

remotion/node_modules/@remotion/web-renderer/dist/drawing/get-background-fill.d.ts

@@ -0,0 +1,8 @@
+export declare const getBackgroundFill: ({ backgroundColor, backgroundImage, contextToDraw, boundingRect, offsetLeft, offsetTop, }: {
+    backgroundImage: string;
+    backgroundColor: string;
+    contextToDraw: OffscreenCanvasRenderingContext2D;
+    boundingRect: DOMRect;
+    offsetLeft: number;
+    offsetTop: number;
+}) => string | CanvasGradient | null;

remotion/node_modules/@remotion/web-renderer/dist/drawing/get-padding-box.d.ts

@@ -0,0 +1 @@
+export declare const getBoxBasedOnBackgroundClip: (rect: DOMRect, computedStyle: CSSStyleDeclaration, backgroundClip: string | undefined) => DOMRect;

remotion/node_modules/@remotion/web-renderer/dist/drawing/get-pretransform-rect.d.ts

@@ -0,0 +1 @@
+export declare function getPreTransformRect(targetRect: DOMRect, matrix: DOMMatrix): DOMRect | null;

remotion/node_modules/@remotion/web-renderer/dist/drawing/handle-3d-transform.d.ts

@@ -0,0 +1,30 @@
+export declare const getPrecomposeRectFor3DTransform: ({ element, parentRect, matrix, }: {
+    element: HTMLElement | SVGElement;
+    parentRect: DOMRect;
+    matrix: DOMMatrix;
+}) => DOMRect | null;
+export declare const handle3dTransform: ({ matrix, sourceRect, tempCanvas, rectAfterTransforms, internalState, scale, }: {
+    matrix: DOMMatrix;
+    sourceRect: DOMRect;
+    tempCanvas: OffscreenCanvas;
+    rectAfterTransforms: DOMRect;
+    internalState: {
+        getDrawn3dPixels: () => number;
+        getPrecomposedTiles: () => number;
+        addPrecompose: ({ canvasWidth, canvasHeight, }: {
+            canvasWidth: number;
+            canvasHeight: number;
+        }) => void;
+        helperCanvasState: import("../internal-state").HelperCanvasState;
+        [Symbol.dispose]: () => void;
+        getWaitForReadyTime: () => number;
+        addWaitForReadyTime: (time: number) => void;
+        getAddSampleTime: () => number;
+        addAddSampleTime: (time: number) => void;
+        getCreateFrameTime: () => number;
+        addCreateFrameTime: (time: number) => void;
+        getAudioMixingTime: () => number;
+        addAudioMixingTime: (time: number) => void;
+    };
+    scale: number;
+}) => OffscreenCanvas | null;

remotion/node_modules/@remotion/web-renderer/dist/drawing/handle-mask.d.ts

@@ -0,0 +1,9 @@
+import type { LinearGradientInfo } from './parse-linear-gradient';
+export declare const getPrecomposeRectForMask: (element: HTMLElement | SVGElement) => DOMRect;
+export declare const handleMask: ({ gradientInfo, rect, precomposeRect, tempContext, scale, }: {
+    gradientInfo: LinearGradientInfo;
+    rect: DOMRect;
+    precomposeRect: DOMRect;
+    tempContext: OffscreenCanvasRenderingContext2D;
+    scale: number;
+}) => void;

remotion/node_modules/@remotion/web-renderer/dist/drawing/has-transform.d.ts

@@ -0,0 +1,4 @@
+export declare const hasTransformCssValue: (style: CSSStyleDeclaration) => boolean;
+export declare const hasRotateCssValue: (style: CSSStyleDeclaration) => boolean;
+export declare const hasScaleCssValue: (style: CSSStyleDeclaration) => boolean;
+export declare const hasAnyTransformCssValue: (style: CSSStyleDeclaration) => boolean;

remotion/node_modules/@remotion/web-renderer/dist/drawing/mask-image.d.ts

@@ -0,0 +1,3 @@
+import type { LinearGradientInfo } from './parse-linear-gradient';
+export declare const getMaskImageValue: (computedStyle: CSSStyleDeclaration) => string | null;
+export declare const parseMaskImage: (maskImageValue: string) => LinearGradientInfo | null;

remotion/node_modules/@remotion/web-renderer/dist/drawing/opacity.d.ts

@@ -0,0 +1,4 @@
+export declare const setOpacity: ({ ctx, opacity, }: {
+    ctx: OffscreenCanvasRenderingContext2D;
+    opacity: number;
+}) => () => void;

remotion/node_modules/@remotion/web-renderer/dist/drawing/overflow.d.ts

@@ -0,0 +1,9 @@
+import type { BorderRadiusCorners } from './border-radius';
+export declare const setOverflowHidden: ({ ctx, rect, borderRadius, overflowHidden, computedStyle, backgroundClip, }: {
+    ctx: OffscreenCanvasRenderingContext2D;
+    rect: DOMRect;
+    borderRadius: BorderRadiusCorners;
+    overflowHidden: boolean;
+    computedStyle: CSSStyleDeclaration;
+    backgroundClip: string;
+}) => () => void;

remotion/node_modules/@remotion/web-renderer/dist/drawing/parse-linear-gradient.d.ts

@@ -0,0 +1,16 @@
+export interface ColorStop {
+    color: string;
+    position: number;
+}
+export interface LinearGradientInfo {
+    angle: number;
+    colorStops: ColorStop[];
+}
+export declare const parseLinearGradient: (backgroundImage: string) => LinearGradientInfo | null;
+export declare const createCanvasGradient: ({ ctx, rect, gradientInfo, offsetLeft, offsetTop, }: {
+    ctx: OffscreenCanvasRenderingContext2D;
+    rect: DOMRect;
+    gradientInfo: LinearGradientInfo;
+    offsetLeft: number;
+    offsetTop: number;
+}) => CanvasGradient;

remotion/node_modules/@remotion/web-renderer/dist/drawing/parse-transform-origin.d.ts

@@ -0,0 +1,4 @@
+export declare const parseTransformOrigin: (transformOrigin: string) => {
+    x: number;
+    y: number;
+} | null;

remotion/node_modules/@remotion/web-renderer/dist/drawing/process-node.d.ts

@@ -0,0 +1,34 @@
+import type { DrawFn } from './drawn-fn';
+export type ProcessNodeReturnValue = {
+    type: 'continue';
+    cleanupAfterChildren: null | (() => void);
+} | {
+    type: 'skip-children';
+};
+export declare const processNode: ({ element, context, draw, logLevel, parentRect, internalState, rootElement, scale, }: {
+    element: HTMLElement | SVGElement;
+    context: OffscreenCanvasRenderingContext2D;
+    draw: DrawFn;
+    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
+    parentRect: DOMRect;
+    internalState: {
+        getDrawn3dPixels: () => number;
+        getPrecomposedTiles: () => number;
+        addPrecompose: ({ canvasWidth, canvasHeight, }: {
+            canvasWidth: number;
+            canvasHeight: number;
+        }) => void;
+        helperCanvasState: import("../internal-state").HelperCanvasState;
+        [Symbol.dispose]: () => void;
+        getWaitForReadyTime: () => number;
+        addWaitForReadyTime: (time: number) => void;
+        getAddSampleTime: () => number;
+        addAddSampleTime: (time: number) => void;
+        getCreateFrameTime: () => number;
+        addCreateFrameTime: (time: number) => void;
+        getAudioMixingTime: () => number;
+        addAudioMixingTime: (time: number) => void;
+    };
+    rootElement: HTMLElement | SVGElement;
+    scale: number;
+}) => Promise<ProcessNodeReturnValue>;

remotion/node_modules/@remotion/web-renderer/dist/drawing/round-to-expand-rect.d.ts

@@ -0,0 +1 @@
+export declare const roundToExpandRect: (rect: DOMRect) => DOMRect;

remotion/node_modules/@remotion/web-renderer/dist/drawing/scale-rect.d.ts

@@ -0,0 +1,4 @@
+export declare const scaleRect: ({ rect, scale, }: {
+    rect: DOMRect;
+    scale: number;
+}) => DOMRect;

remotion/node_modules/@remotion/web-renderer/dist/drawing/text/apply-text-transform.d.ts

@@ -0,0 +1 @@
+export declare const applyTextTransform: (text: string, transform: string) => string;

remotion/node_modules/@remotion/web-renderer/dist/drawing/text/draw-text.d.ts

@@ -0,0 +1,7 @@
+import type { DrawFn } from '../drawn-fn';
+export declare const drawText: ({ span, logLevel, onlyBackgroundClipText, parentRect, }: {
+    span: HTMLSpanElement;
+    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
+    parentRect: DOMRect;
+    onlyBackgroundClipText: boolean;
+}) => DrawFn;

remotion/node_modules/@remotion/web-renderer/dist/drawing/text/find-line-breaks.text.d.ts

@@ -0,0 +1,6 @@
+type Token = {
+    text: string;
+    rect: DOMRect;
+};
+export declare const findWords: (span: HTMLSpanElement) => Token[];
+export {};

remotion/node_modules/@remotion/web-renderer/dist/drawing/text/handle-text-node.d.ts

@@ -0,0 +1,28 @@
+import type { ProcessNodeReturnValue } from '../process-node';
+export declare const handleTextNode: ({ node, context, logLevel, parentRect, internalState, rootElement, onlyBackgroundClipText, scale, }: {
+    node: Text;
+    context: OffscreenCanvasRenderingContext2D;
+    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
+    parentRect: DOMRect;
+    internalState: {
+        getDrawn3dPixels: () => number;
+        getPrecomposedTiles: () => number;
+        addPrecompose: ({ canvasWidth, canvasHeight, }: {
+            canvasWidth: number;
+            canvasHeight: number;
+        }) => void;
+        helperCanvasState: import("../../internal-state").HelperCanvasState;
+        [Symbol.dispose]: () => void;
+        getWaitForReadyTime: () => number;
+        addWaitForReadyTime: (time: number) => void;
+        getAddSampleTime: () => number;
+        addAddSampleTime: (time: number) => void;
+        getCreateFrameTime: () => number;
+        addCreateFrameTime: (time: number) => void;
+        getAudioMixingTime: () => number;
+        addAudioMixingTime: (time: number) => void;
+    };
+    rootElement: HTMLElement | SVGElement;
+    onlyBackgroundClipText: boolean;
+    scale: number;
+}) => Promise<ProcessNodeReturnValue>;

remotion/node_modules/@remotion/web-renderer/dist/drawing/transform-in-3d.d.ts

@@ -0,0 +1,26 @@
+import type { HelperCanvasState } from '../internal-state';
+export declare const transformIn3d: ({ matrix, sourceCanvas, sourceRect, destRect, internalState, scale, }: {
+    sourceRect: DOMRect;
+    matrix: DOMMatrix;
+    sourceCanvas: OffscreenCanvas;
+    destRect: DOMRect;
+    internalState: {
+        getDrawn3dPixels: () => number;
+        getPrecomposedTiles: () => number;
+        addPrecompose: ({ canvasWidth, canvasHeight, }: {
+            canvasWidth: number;
+            canvasHeight: number;
+        }) => void;
+        helperCanvasState: HelperCanvasState;
+        [Symbol.dispose]: () => void;
+        getWaitForReadyTime: () => number;
+        addWaitForReadyTime: (time: number) => void;
+        getAddSampleTime: () => number;
+        addAddSampleTime: (time: number) => void;
+        getCreateFrameTime: () => number;
+        addCreateFrameTime: (time: number) => void;
+        getAudioMixingTime: () => number;
+        addAudioMixingTime: (time: number) => void;
+    };
+    scale: number;
+}) => OffscreenCanvas;

remotion/node_modules/@remotion/web-renderer/dist/drawing/transform-rect-with-matrix.d.ts

@@ -0,0 +1,4 @@
+export declare function transformDOMRect({ rect, matrix }: {
+    rect: DOMRect;
+    matrix: DOMMatrix;
+}): DOMRect;

remotion/node_modules/@remotion/web-renderer/dist/drawing/transform.d.ts

@@ -0,0 +1,6 @@
+export declare const setTransform: ({ ctx, transform, parentRect, scale, }: {
+    ctx: OffscreenCanvasRenderingContext2D;
+    transform: DOMMatrix;
+    parentRect: DOMRect;
+    scale: number;
+}) => () => void;

remotion/node_modules/@remotion/web-renderer/dist/drawing/turn-svg-into-drawable.d.ts

@@ -0,0 +1 @@
+export declare const turnSvgIntoDrawable: (svg: SVGSVGElement) => Promise<HTMLImageElement>;

remotion/node_modules/@remotion/web-renderer/dist/frame-range.d.ts

@@ -0,0 +1,2 @@
+export type FrameRange = number | [number, number];
+export declare const getRealFrameRange: (durationInFrames: number, frameRange: FrameRange | null) => [number, number];

remotion/node_modules/@remotion/web-renderer/dist/get-audio-encoding-config.d.ts

@@ -0,0 +1,2 @@
+import { type AudioEncodingConfig } from 'mediabunny';
+export declare const getDefaultAudioEncodingConfig: () => Promise<AudioEncodingConfig | null>;

remotion/node_modules/@remotion/web-renderer/dist/get-biggest-bounding-client-rect.d.ts

@@ -0,0 +1 @@
+export declare const getBiggestBoundingClientRect: (element: HTMLElement | SVGElement) => DOMRect;

remotion/node_modules/@remotion/web-renderer/dist/get-encodable-codecs.d.ts

@@ -0,0 +1,9 @@
+import { type WebRendererAudioCodec, type WebRendererContainer, type WebRendererQuality, type WebRendererVideoCodec } from './mediabunny-mappings';
+export type GetEncodableVideoCodecsOptions = {
+    videoBitrate?: number | WebRendererQuality;
+};
+export type GetEncodableAudioCodecsOptions = {
+    audioBitrate?: number | WebRendererQuality;
+};
+export declare const getEncodableVideoCodecs: (container: WebRendererContainer, options?: GetEncodableVideoCodecsOptions | undefined) => Promise<WebRendererVideoCodec[]>;
+export declare const getEncodableAudioCodecs: (container: WebRendererContainer, options?: GetEncodableAudioCodecsOptions | undefined) => Promise<WebRendererAudioCodec[]>;

remotion/node_modules/@remotion/web-renderer/dist/index.d.ts

@@ -0,0 +1,14 @@
+import './symbol-dispose';
+export type { EmittedArtifact, WebRendererOnArtifact } from './artifact';
+export { canRenderMediaOnWeb } from './can-render-media-on-web';
+export type { CanRenderIssue, CanRenderMediaOnWebOptions, CanRenderMediaOnWebResult, } from './can-render-media-on-web';
+export type { FrameRange } from './frame-range';
+export { getEncodableAudioCodecs, getEncodableVideoCodecs, type GetEncodableAudioCodecsOptions, type GetEncodableVideoCodecsOptions, } from './get-encodable-codecs';
+export { getDefaultAudioCodecForContainer, getDefaultVideoCodecForContainer, getSupportedAudioCodecsForContainer, getSupportedVideoCodecsForContainer, } from './mediabunny-mappings';
+export type { WebRendererAudioCodec, WebRendererContainer, WebRendererQuality, WebRendererVideoCodec, } from './mediabunny-mappings';
+export type { WebRendererOutputTarget } from './output-target';
+export { renderMediaOnWeb } from './render-media-on-web';
+export type { RenderMediaOnWebOptions, RenderMediaOnWebProgress, RenderMediaOnWebProgressCallback, RenderMediaOnWebResult, WebRendererHardwareAcceleration, } from './render-media-on-web';
+export { renderStillOnWeb } from './render-still-on-web';
+export type { RenderStillOnWebImageFormat, RenderStillOnWebOptions, } from './render-still-on-web';
+export type { OnFrameCallback } from './validate-video-frame';

remotion/node_modules/@remotion/web-renderer/dist/internal-state.d.ts

@@ -0,0 +1,37 @@
+type HelperCanvas = {
+    canvas: OffscreenCanvas;
+    gl: WebGLRenderingContext;
+    program: WebGLProgram;
+    locations: {
+        aPosition: number;
+        aTexCoord: number;
+        uTransform: WebGLUniformLocation | null;
+        uResolution: WebGLUniformLocation | null;
+        uOffset: WebGLUniformLocation | null;
+        uTexture: WebGLUniformLocation | null;
+    };
+    cleanup: () => void;
+};
+export type HelperCanvasState = {
+    current: HelperCanvas | null;
+};
+export declare const makeInternalState: () => {
+    getDrawn3dPixels: () => number;
+    getPrecomposedTiles: () => number;
+    addPrecompose: ({ canvasWidth, canvasHeight, }: {
+        canvasWidth: number;
+        canvasHeight: number;
+    }) => void;
+    helperCanvasState: HelperCanvasState;
+    [Symbol.dispose]: () => void;
+    getWaitForReadyTime: () => number;
+    addWaitForReadyTime: (time: number) => void;
+    getAddSampleTime: () => number;
+    addAddSampleTime: (time: number) => void;
+    getCreateFrameTime: () => number;
+    addCreateFrameTime: (time: number) => void;
+    getAudioMixingTime: () => number;
+    addAudioMixingTime: (time: number) => void;
+};
+export type InternalState = ReturnType<typeof makeInternalState>;
+export {};

remotion/node_modules/@remotion/web-renderer/dist/mediabunny-cleanups.d.ts

@@ -0,0 +1,10 @@
+import type { OutputFormat, OutputOptions, Target, VideoEncodingConfig } from 'mediabunny';
+import { Output, VideoSampleSource } from 'mediabunny';
+export declare const makeOutputWithCleanup: <T extends OutputFormat, U extends Target>(options: OutputOptions<T, U>) => {
+    output: Output<T, U>;
+    [Symbol.dispose]: () => void;
+};
+export declare const makeVideoSampleSourceCleanup: (encodingConfig: VideoEncodingConfig) => {
+    videoSampleSource: VideoSampleSource;
+    [Symbol.dispose]: () => void;
+};

remotion/node_modules/@remotion/web-renderer/dist/mediabunny-mappings.d.ts

@@ -0,0 +1,15 @@
+import type { Quality } from 'mediabunny';
+import { type OutputFormat } from 'mediabunny';
+export type WebRendererVideoCodec = 'h264' | 'h265' | 'vp8' | 'vp9' | 'av1';
+export type WebRendererContainer = 'mp4' | 'webm';
+export type WebRendererAudioCodec = 'aac' | 'opus';
+export type WebRendererQuality = 'very-low' | 'low' | 'medium' | 'high' | 'very-high';
+export declare const codecToMediabunnyCodec: (codec: WebRendererVideoCodec) => "av1" | "avc" | "hevc" | "vp8" | "vp9";
+export declare const containerToMediabunnyContainer: (container: WebRendererContainer) => OutputFormat;
+export declare const getDefaultVideoCodecForContainer: (container: WebRendererContainer) => WebRendererVideoCodec;
+export declare const getQualityForWebRendererQuality: (quality: WebRendererQuality) => Quality;
+export declare const getMimeType: (container: WebRendererContainer) => string;
+export declare const getDefaultAudioCodecForContainer: (container: WebRendererContainer) => WebRendererAudioCodec;
+export declare const getSupportedVideoCodecsForContainer: (container: WebRendererContainer) => WebRendererVideoCodec[];
+export declare const getSupportedAudioCodecsForContainer: (container: WebRendererContainer) => WebRendererAudioCodec[];
+export declare const audioCodecToMediabunnyAudioCodec: (audioCodec: WebRendererAudioCodec) => "aac" | "alaw" | "flac" | "mp3" | "opus" | "pcm-f32" | "pcm-f32be" | "pcm-f64" | "pcm-f64be" | "pcm-s16" | "pcm-s16be" | "pcm-s24" | "pcm-s24be" | "pcm-s32" | "pcm-s32be" | "pcm-s8" | "pcm-u8" | "ulaw" | "vorbis";

remotion/node_modules/@remotion/web-renderer/dist/output-target.d.ts

@@ -0,0 +1 @@
+export type WebRendererOutputTarget = 'arraybuffer' | 'web-fs';

remotion/node_modules/@remotion/web-renderer/dist/props-if-has-props.d.ts

@@ -0,0 +1,36 @@
+import type { ComponentType } from 'react';
+import type { CalculateMetadataFunction } from 'remotion';
+import type { AnyZodObject, z } from 'zod';
+export type InferProps<Schema extends AnyZodObject, Props extends Record<string, unknown>> = AnyZodObject extends Schema ? {} extends Props ? Record<string, unknown> : Props : {} extends Props ? z.input<Schema> : z.input<Schema> & Props;
+export type DefaultPropsIfHasProps<Schema extends AnyZodObject, Props> = AnyZodObject extends Schema ? {} extends Props ? {
+    defaultProps?: z.input<Schema> & Props;
+} : {
+    defaultProps: Props;
+} : {} extends Props ? {
+    defaultProps: z.input<Schema>;
+} : {
+    defaultProps: z.input<Schema> & Props;
+};
+type LooseComponentType<T> = ComponentType<T> | ((props: T) => React.ReactNode);
+type OptionalDimensions<Schema extends AnyZodObject, Props extends Record<string, unknown>> = {
+    component: LooseComponentType<Props>;
+    id: string;
+    width?: number;
+    height?: number;
+    calculateMetadata: CalculateMetadataFunction<InferProps<Schema, Props>>;
+};
+type MandatoryDimensions<Schema extends AnyZodObject, Props extends Record<string, unknown>> = {
+    component: LooseComponentType<Props>;
+    id: string;
+    width: number;
+    height: number;
+    calculateMetadata?: CalculateMetadataFunction<InferProps<Schema, Props>> | null;
+};
+export type CompositionCalculateMetadataOrExplicit<Schema extends AnyZodObject, Props extends Record<string, unknown>> = ((OptionalDimensions<Schema, Props> & {
+    fps?: number;
+    durationInFrames?: number;
+}) | (MandatoryDimensions<Schema, Props> & {
+    fps: number;
+    durationInFrames: number;
+})) & DefaultPropsIfHasProps<Schema, Props>;
+export {};

remotion/node_modules/@remotion/web-renderer/dist/render-media-on-web.d.ts

@@ -0,0 +1,59 @@
+import { type LogLevel } from 'remotion';
+import type { AnyZodObject, z } from 'zod';
+import { type WebRendererOnArtifact } from './artifact';
+import { type FrameRange } from './frame-range';
+import type { InternalState } from './internal-state';
+import type { WebRendererAudioCodec, WebRendererContainer, WebRendererQuality } from './mediabunny-mappings';
+import { type WebRendererVideoCodec } from './mediabunny-mappings';
+import type { WebRendererOutputTarget } from './output-target';
+import type { CompositionCalculateMetadataOrExplicit } from './props-if-has-props';
+import { type OnFrameCallback } from './validate-video-frame';
+export type InputPropsIfHasProps<Schema extends AnyZodObject, Props> = AnyZodObject extends Schema ? {} extends Props ? {
+    inputProps?: z.input<Schema> & Props;
+} : {
+    inputProps: Props;
+} : {} extends Props ? {
+    inputProps: z.input<Schema>;
+} : {
+    inputProps: z.input<Schema> & Props;
+};
+type MandatoryRenderMediaOnWebOptions<Schema extends AnyZodObject, Props extends Record<string, unknown>> = {
+    composition: CompositionCalculateMetadataOrExplicit<Schema, Props>;
+};
+export type RenderMediaOnWebProgress = {
+    renderedFrames: number;
+    encodedFrames: number;
+};
+export type RenderMediaOnWebResult = {
+    getBlob: () => Promise<Blob>;
+    internalState: InternalState;
+};
+export type RenderMediaOnWebProgressCallback = (progress: RenderMediaOnWebProgress) => void;
+export type WebRendererHardwareAcceleration = 'no-preference' | 'prefer-hardware' | 'prefer-software';
+type OptionalRenderMediaOnWebOptions<Schema extends AnyZodObject> = {
+    delayRenderTimeoutInMilliseconds: number;
+    logLevel: LogLevel;
+    schema: Schema | undefined;
+    mediaCacheSizeInBytes: number | null;
+    videoCodec: WebRendererVideoCodec;
+    audioCodec: WebRendererAudioCodec | null;
+    audioBitrate: number | WebRendererQuality;
+    container: WebRendererContainer;
+    signal: AbortSignal | null;
+    onProgress: RenderMediaOnWebProgressCallback | null;
+    hardwareAcceleration: WebRendererHardwareAcceleration;
+    keyframeIntervalInSeconds: number;
+    videoBitrate: number | WebRendererQuality;
+    frameRange: FrameRange | null;
+    transparent: boolean;
+    onArtifact: WebRendererOnArtifact | null;
+    onFrame: OnFrameCallback | null;
+    outputTarget: WebRendererOutputTarget | null;
+    licenseKey: string | null;
+    isProduction: boolean;
+    muted: boolean;
+    scale: number;
+};
+export type RenderMediaOnWebOptions<Schema extends AnyZodObject, Props extends Record<string, unknown>> = MandatoryRenderMediaOnWebOptions<Schema, Props> & Partial<OptionalRenderMediaOnWebOptions<Schema>> & InputPropsIfHasProps<Schema, Props>;
+export declare const renderMediaOnWeb: <Schema extends AnyZodObject, Props extends Record<string, unknown>>(options: RenderMediaOnWebOptions<Schema, Props>) => Promise<RenderMediaOnWebResult>;
+export {};

remotion/node_modules/@remotion/web-renderer/dist/render-operations-queue.d.ts

@@ -0,0 +1,3 @@
+export declare const onlyOneRenderAtATimeQueue: {
+    ref: Promise<unknown>;
+};

remotion/node_modules/@remotion/web-renderer/dist/render-still-on-web.d.ts

@@ -0,0 +1,46 @@
+import { type LogLevel } from 'remotion';
+import type { AnyZodObject } from 'zod';
+import type { WebRendererOnArtifact } from './artifact';
+import type { CompositionCalculateMetadataOrExplicit } from './props-if-has-props';
+import type { InputPropsIfHasProps } from './render-media-on-web';
+export type RenderStillOnWebImageFormat = 'png' | 'jpeg' | 'webp';
+type MandatoryRenderStillOnWebOptions<Schema extends AnyZodObject, Props extends Record<string, unknown>> = {
+    frame: number;
+    imageFormat: RenderStillOnWebImageFormat;
+} & {
+    composition: CompositionCalculateMetadataOrExplicit<Schema, Props>;
+};
+type OptionalRenderStillOnWebOptions<Schema extends AnyZodObject> = {
+    delayRenderTimeoutInMilliseconds: number;
+    logLevel: LogLevel;
+    schema: Schema | undefined;
+    mediaCacheSizeInBytes: number | null;
+    signal: AbortSignal | null;
+    onArtifact: WebRendererOnArtifact | null;
+    licenseKey: string | null;
+    scale: number;
+    isProduction: boolean;
+};
+export type RenderStillOnWebOptions<Schema extends AnyZodObject, Props extends Record<string, unknown>> = MandatoryRenderStillOnWebOptions<Schema, Props> & Partial<OptionalRenderStillOnWebOptions<Schema>> & InputPropsIfHasProps<Schema, Props>;
+export declare const renderStillOnWeb: <Schema extends AnyZodObject, Props extends Record<string, unknown>>(options: RenderStillOnWebOptions<Schema, Props>) => Promise<{
+    blob: Blob;
+    internalState: {
+        getDrawn3dPixels: () => number;
+        getPrecomposedTiles: () => number;
+        addPrecompose: ({ canvasWidth, canvasHeight, }: {
+            canvasWidth: number;
+            canvasHeight: number;
+        }) => void;
+        helperCanvasState: import("./internal-state").HelperCanvasState;
+        [Symbol.dispose]: () => void;
+        getWaitForReadyTime: () => number;
+        addWaitForReadyTime: (time: number) => void;
+        getAddSampleTime: () => number;
+        addAddSampleTime: (time: number) => void;
+        getCreateFrameTime: () => number;
+        addCreateFrameTime: (time: number) => void;
+        getAudioMixingTime: () => number;
+        addAudioMixingTime: (time: number) => void;
+    };
+}>;
+export {};

remotion/node_modules/@remotion/web-renderer/dist/resolve-audio-codec.d.ts

@@ -0,0 +1,13 @@
+import { type Quality } from 'mediabunny';
+import type { CanRenderIssue } from './can-render-types';
+import { type WebRendererAudioCodec, type WebRendererContainer } from './mediabunny-mappings';
+export type ResolveAudioCodecResult = {
+    codec: WebRendererAudioCodec | null;
+    issues: CanRenderIssue[];
+};
+export declare const resolveAudioCodec: (options: {
+    container: WebRendererContainer;
+    requestedCodec: WebRendererAudioCodec | null | undefined;
+    userSpecifiedAudioCodec: boolean;
+    bitrate: number | Quality;
+}) => Promise<ResolveAudioCodecResult>;

remotion/node_modules/@remotion/web-renderer/dist/send-telemetry-event.d.ts

@@ -0,0 +1,7 @@
+export declare const sendUsageEvent: ({ licenseKey, succeeded, apiName, isStill, isProduction, }: {
+    licenseKey: string | null;
+    succeeded: boolean;
+    apiName: string;
+    isStill: boolean;
+    isProduction: boolean;
+}) => Promise<void>;

remotion/node_modules/@remotion/web-renderer/dist/take-screenshot.d.ts

@@ -0,0 +1,25 @@
+export declare const createLayer: ({ element, scale, logLevel, internalState, onlyBackgroundClipText, cutout, }: {
+    element: HTMLElement | SVGElement;
+    scale: number;
+    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
+    internalState: {
+        getDrawn3dPixels: () => number;
+        getPrecomposedTiles: () => number;
+        addPrecompose: ({ canvasWidth, canvasHeight, }: {
+            canvasWidth: number;
+            canvasHeight: number;
+        }) => void;
+        helperCanvasState: import("./internal-state").HelperCanvasState;
+        [Symbol.dispose]: () => void;
+        getWaitForReadyTime: () => number;
+        addWaitForReadyTime: (time: number) => void;
+        getAddSampleTime: () => number;
+        addAddSampleTime: (time: number) => void;
+        getCreateFrameTime: () => number;
+        addCreateFrameTime: (time: number) => void;
+        getAudioMixingTime: () => number;
+        addAudioMixingTime: (time: number) => void;
+    };
+    onlyBackgroundClipText: boolean;
+    cutout: DOMRect;
+}) => Promise<OffscreenCanvasRenderingContext2D>;

remotion/node_modules/@remotion/web-renderer/dist/throttle-progress.d.ts

@@ -0,0 +1,10 @@
+import type { RenderMediaOnWebProgressCallback } from './render-media-on-web';
+export type ThrottledProgressResult = {
+    throttled: RenderMediaOnWebProgressCallback;
+    [Symbol.dispose]: () => void;
+};
+/**
+ * Creates a throttled version of a progress callback that ensures it's not called
+ * more frequently than the specified interval (default: 250ms)
+ */
+export declare const createThrottledProgressCallback: (callback: RenderMediaOnWebProgressCallback | null, throttleMs?: number) => ThrottledProgressResult | null;

remotion/node_modules/@remotion/web-renderer/dist/tree-walker-cleanup-after-children.d.ts

@@ -0,0 +1,5 @@
+export declare const createTreeWalkerCleanupAfterChildren: (treeWalker: TreeWalker) => {
+    checkCleanUpAtBeginningOfIteration: () => void;
+    addCleanup: (element: Node, cleanupFn: () => void) => void;
+    [Symbol.dispose]: () => void;
+};

remotion/node_modules/@remotion/web-renderer/dist/update-time.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import type { LogLevel } from 'remotion';
+export type TimeUpdaterRef = {
+    update: (frame: number) => void;
+};
+export declare const UpdateTime: React.FC<{
+    readonly children: React.ReactNode;
+    readonly audioEnabled: boolean;
+    readonly videoEnabled: boolean;
+    readonly logLevel: LogLevel;
+    readonly compId: string;
+    readonly initialFrame: number;
+    readonly timeUpdater: React.RefObject<TimeUpdaterRef | null>;
+}>;

remotion/node_modules/@remotion/web-renderer/dist/validate-dimensions.d.ts

@@ -0,0 +1,7 @@
+import type { CanRenderIssue } from './can-render-types';
+import type { WebRendererVideoCodec } from './mediabunny-mappings';
+export declare const validateDimensions: (options: {
+    width: number;
+    height: number;
+    codec: WebRendererVideoCodec;
+}) => CanRenderIssue | null;

remotion/node_modules/@remotion/web-renderer/dist/validate-scale.d.ts

@@ -0,0 +1 @@
+export declare const validateScale: (scale: unknown) => void;

remotion/node_modules/@remotion/web-renderer/dist/validate-video-frame.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Validates and processes a VideoFrame returned from an onFrame callback
+ */
+export type OnFrameCallback = (frame: VideoFrame) => VideoFrame | Promise<VideoFrame>;
+export type ValidateVideoFrameOptions = {
+    originalFrame: VideoFrame;
+    returnedFrame: VideoFrame;
+    expectedWidth: number;
+    expectedHeight: number;
+    expectedTimestamp: number;
+};
+/**
+ * Validates that a VideoFrame returned from onFrame callback matches expected dimensions and timestamp
+ * If validation fails, closes both frames and throws an error
+ */
+export declare const validateVideoFrame: ({ originalFrame, returnedFrame, expectedWidth, expectedHeight, expectedTimestamp, }: ValidateVideoFrameOptions) => VideoFrame;

remotion/node_modules/@remotion/web-renderer/dist/wait-for-ready.d.ts

@@ -0,0 +1,27 @@
+import type { DelayRenderScope } from 'remotion';
+import type { BackgroundKeepalive } from './background-keepalive';
+export declare const waitForReady: ({ timeoutInMilliseconds, scope, signal, apiName, internalState, keepalive, }: {
+    timeoutInMilliseconds: number;
+    scope: DelayRenderScope;
+    signal: AbortSignal | null;
+    apiName: "renderMediaOnWeb" | "renderStillOnWeb";
+    internalState: {
+        getDrawn3dPixels: () => number;
+        getPrecomposedTiles: () => number;
+        addPrecompose: ({ canvasWidth, canvasHeight, }: {
+            canvasWidth: number;
+            canvasHeight: number;
+        }) => void;
+        helperCanvasState: import("./internal-state").HelperCanvasState;
+        [Symbol.dispose]: () => void;
+        getWaitForReadyTime: () => number;
+        addWaitForReadyTime: (time: number) => void;
+        getAddSampleTime: () => number;
+        addAddSampleTime: (time: number) => void;
+        getCreateFrameTime: () => number;
+        addCreateFrameTime: (time: number) => void;
+        getAudioMixingTime: () => number;
+        addAudioMixingTime: (time: number) => void;
+    } | null;
+    keepalive: BackgroundKeepalive | null;
+}) => Promise<void>;

remotion/node_modules/@remotion/web-renderer/dist/walk-over-node.d.ts

@@ -0,0 +1,28 @@
+import type { ProcessNodeReturnValue } from './drawing/process-node';
+export declare const walkOverNode: ({ node, context, logLevel, parentRect, internalState, rootElement, onlyBackgroundClipText, scale, }: {
+    node: Node;
+    context: OffscreenCanvasRenderingContext2D;
+    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
+    parentRect: DOMRect;
+    internalState: {
+        getDrawn3dPixels: () => number;
+        getPrecomposedTiles: () => number;
+        addPrecompose: ({ canvasWidth, canvasHeight, }: {
+            canvasWidth: number;
+            canvasHeight: number;
+        }) => void;
+        helperCanvasState: import("./internal-state").HelperCanvasState;
+        [Symbol.dispose]: () => void;
+        getWaitForReadyTime: () => number;
+        addWaitForReadyTime: (time: number) => void;
+        getAddSampleTime: () => number;
+        addAddSampleTime: (time: number) => void;
+        getCreateFrameTime: () => number;
+        addCreateFrameTime: (time: number) => void;
+        getAudioMixingTime: () => number;
+        addAudioMixingTime: (time: number) => void;
+    };
+    rootElement: HTMLElement | SVGElement;
+    onlyBackgroundClipText: boolean;
+    scale: number;
+}) => Promise<ProcessNodeReturnValue>;

remotion/node_modules/@remotion/web-renderer/dist/walk-tree.d.ts

@@ -0,0 +1 @@
+export declare function skipToNextNonDescendant(treeWalker: TreeWalker): boolean;

remotion/node_modules/@remotion/web-renderer/dist/web-fs-target.d.ts

@@ -0,0 +1,7 @@
+import type { StreamTargetChunk } from 'mediabunny';
+export declare const cleanupStaleOpfsFiles: () => Promise<void>;
+export declare const createWebFsTarget: () => Promise<{
+    stream: WritableStream<StreamTargetChunk>;
+    getBlob: () => Promise<File>;
+    close: () => Promise<void>;
+}>;

remotion/node_modules/@remotion/web-renderer/dist/with-resolvers.d.ts

@@ -0,0 +1,10 @@
+export interface WithResolvers<T> {
+    promise: Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+}
+export declare const withResolvers: <T>() => {
+    promise: Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+};