@remotion/gif 4.1.0-alpha11 → 4.1.0-alpha12

package/.rollup.cache/Users/jonathanburger/remotion/packages/gif/dist/esm/Gif.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import type { RemotionGifProps } from './props';
+/**
+ * @description Displays a GIF that synchronizes with Remotions useCurrentFrame().
+ * @see [Documentation](https://www.remotion.dev/docs/gif/gif)
+ */
+export declare const Gif: import("react").ForwardRefExoticComponent<RemotionGifProps & import("react").RefAttributes<HTMLCanvasElement>>;

package/.rollup.cache/Users/jonathanburger/remotion/packages/gif/dist/esm/Gif.js

@@ -0,0 +1,16 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef } from 'react';
+import { Internals } from 'remotion';
+import { GifForDevelopment } from './GifForDevelopment';
+import { GifForRendering } from './GifForRendering';
+/**
+ * @description Displays a GIF that synchronizes with Remotions useCurrentFrame().
+ * @see [Documentation](https://www.remotion.dev/docs/gif/gif)
+ */
+export const Gif = forwardRef((props, ref) => {
+    const env = Internals.useRemotionEnvironment();
+    if (env === 'rendering') {
+        return _jsx(GifForRendering, { ...props, ref: ref });
+    }
+    return _jsx(GifForDevelopment, { ...props, ref: ref });
+});

package/.rollup.cache/Users/jonathanburger/remotion/packages/gif/dist/esm/GifForDevelopment.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import type { RemotionGifProps } from './props';
+export declare const GifForDevelopment: import("react").ForwardRefExoticComponent<RemotionGifProps & import("react").RefAttributes<HTMLCanvasElement>>;

package/.rollup.cache/Users/jonathanburger/remotion/packages/gif/dist/esm/GifForDevelopment.js

@@ -0,0 +1,78 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef, useEffect, useRef, useState } from 'react';
+import { continueRender, delayRender } from 'remotion';
+import { Canvas } from './canvas';
+import { manuallyManagedGifCache, volatileGifCache } from './gif-cache';
+import { isCorsError } from './is-cors-error';
+import { parseWithWorker } from './react-tools';
+import { resolveGifSource } from './resolve-gif-source';
+import { useCurrentGifIndex } from './useCurrentGifIndex';
+export const GifForDevelopment = forwardRef(({ src, width, height, onError, loopBehavior = 'loop', onLoad, fit = 'fill', ...props }, ref) => {
+    const resolvedSrc = resolveGifSource(src);
+    const [state, update] = useState(() => {
+        var _a;
+        const parsedGif = (_a = volatileGifCache.get(resolvedSrc)) !== null && _a !== void 0 ? _a : manuallyManagedGifCache.get(resolvedSrc);
+        if (parsedGif === undefined) {
+            return {
+                delays: [],
+                frames: [],
+                width: 0,
+                height: 0,
+            };
+        }
+        return parsedGif;
+    });
+    const [error, setError] = useState(null);
+    const [id] = useState(() => delayRender(`Rendering <Gif/> with src="${resolvedSrc}"`));
+    const currentOnLoad = useRef(onLoad);
+    const currentOnError = useRef(onError);
+    currentOnLoad.current = onLoad;
+    currentOnError.current = onError;
+    useEffect(() => {
+        let done = false;
+        let aborted = false;
+        const { prom, cancel } = parseWithWorker(resolvedSrc);
+        const newHandle = delayRender('Loading <Gif /> with src=' + resolvedSrc);
+        prom
+            .then((parsed) => {
+            var _a;
+            (_a = currentOnLoad.current) === null || _a === void 0 ? void 0 : _a.call(currentOnLoad, parsed);
+            update(parsed);
+            volatileGifCache.set(resolvedSrc, parsed);
+            done = true;
+            continueRender(newHandle);
+            continueRender(id);
+        })
+            .catch((err) => {
+            if (aborted) {
+                continueRender(newHandle);
+                return;
+            }
+            if (currentOnError.current) {
+                currentOnError.current(err);
+            }
+            else {
+                setError(err);
+            }
+        });
+        return () => {
+            if (!done) {
+                aborted = true;
+                cancel();
+            }
+            continueRender(newHandle);
+        };
+    }, [id, resolvedSrc]);
+    if (error) {
+        console.error(error.stack);
+        if (isCorsError(error)) {
+            throw new Error(`Failed to render GIF with source ${src}: "${error.message}". You must enable CORS for this URL.`);
+        }
+        throw new Error(`Failed to render GIF with source ${src}: "${error.message}".`);
+    }
+    const index = useCurrentGifIndex(state.delays, loopBehavior);
+    if (index === -1) {
+        return null;
+    }
+    return (_jsx(Canvas, { fit: fit, index: index, frames: state.frames, width: width, height: height, ...props, ref: ref }));
+});

package/.rollup.cache/Users/jonathanburger/remotion/packages/gif/dist/esm/GifForRendering.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import type { RemotionGifProps } from './props';
+export declare const GifForRendering: import("react").ForwardRefExoticComponent<RemotionGifProps & import("react").RefAttributes<HTMLCanvasElement>>;

package/.rollup.cache/Users/jonathanburger/remotion/packages/gif/dist/esm/GifForRendering.js

@@ -0,0 +1,82 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef, useEffect, useRef, useState } from 'react';
+import { continueRender, delayRender } from 'remotion';
+import { Canvas } from './canvas';
+import { volatileGifCache } from './gif-cache';
+import { isCorsError } from './is-cors-error';
+import { parseGif } from './react-tools';
+import { resolveGifSource } from './resolve-gif-source';
+import { useCurrentGifIndex } from './useCurrentGifIndex';
+export const GifForRendering = forwardRef(({ src, width, height, onLoad, onError, loopBehavior = 'loop', fit = 'fill', ...props }, ref) => {
+    const resolvedSrc = resolveGifSource(src);
+    const [state, update] = useState(() => {
+        const parsedGif = volatileGifCache.get(resolvedSrc);
+        if (parsedGif === undefined) {
+            return {
+                delays: [],
+                frames: [],
+                width: 0,
+                height: 0,
+            };
+        }
+        return parsedGif;
+    });
+    const [error, setError] = useState(null);
+    const [id] = useState(() => delayRender(`Rendering <Gif/> with src="${resolvedSrc}"`));
+    useEffect(() => {
+        return () => {
+            continueRender(id);
+        };
+    }, [id]);
+    const index = useCurrentGifIndex(state.delays, loopBehavior);
+    const currentOnLoad = useRef(onLoad);
+    const currentOnError = useRef(onError);
+    currentOnLoad.current = onLoad;
+    currentOnError.current = onError;
+    useEffect(() => {
+        const controller = new AbortController();
+        let done = false;
+        let aborted = false;
+        const newHandle = delayRender('Loading <Gif /> with src=' + resolvedSrc);
+        parseGif({ controller, src: resolvedSrc })
+            .then((parsed) => {
+            var _a;
+            (_a = currentOnLoad.current) === null || _a === void 0 ? void 0 : _a.call(currentOnLoad, parsed);
+            update(parsed);
+            volatileGifCache.set(resolvedSrc, parsed);
+            done = true;
+            continueRender(newHandle);
+            continueRender(id);
+        })
+            .catch((err) => {
+            if (aborted) {
+                continueRender(newHandle);
+                return;
+            }
+            if (currentOnError.current) {
+                currentOnError.current(err);
+            }
+            else {
+                setError(err);
+            }
+        });
+        return () => {
+            if (!done) {
+                aborted = true;
+                controller.abort();
+            }
+            continueRender(newHandle);
+        };
+    }, [id, resolvedSrc]);
+    if (error) {
+        console.error(error.stack);
+        if (isCorsError(error)) {
+            throw new Error(`Failed to render GIF with source ${src}: "${error.message}". You must enable CORS for this URL.`);
+        }
+        throw new Error(`Failed to render GIF with source ${src}: "${error.message}". Render with --log=verbose to see the full stack.`);
+    }
+    if (index === -1) {
+        return null;
+    }
+    return (_jsx(Canvas, { fit: fit, index: index, frames: state.frames, width: width, height: height, ...props, ref: ref }));
+});

package/.rollup.cache/Users/jonathanburger/remotion/packages/gif/dist/esm/canvas.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+import type { GifFillMode } from './props';
+type Props = {
+    index: number;
+    frames: ImageData[];
+    width?: number;
+    height?: number;
+    fit: GifFillMode;
+    className?: string;
+    style?: React.CSSProperties;
+};
+export declare const Canvas: import("react").ForwardRefExoticComponent<Props & import("react").RefAttributes<unknown>>;
+export {};

package/.rollup.cache/Users/jonathanburger/remotion/packages/gif/dist/esm/canvas.js

@@ -0,0 +1,93 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef, useEffect, useImperativeHandle, useRef, useState, } from 'react';
+import { useElementSize } from './use-element-size';
+const calcArgs = (fit, frameSize, canvasSize) => {
+    switch (fit) {
+        case 'fill': {
+            return [
+                0,
+                0,
+                frameSize.width,
+                frameSize.height,
+                0,
+                0,
+                canvasSize.width,
+                canvasSize.height,
+            ];
+        }
+        case 'contain': {
+            const ratio = Math.min(canvasSize.width / frameSize.width, canvasSize.height / frameSize.height);
+            const centerX = (canvasSize.width - frameSize.width * ratio) / 2;
+            const centerY = (canvasSize.height - frameSize.height * ratio) / 2;
+            return [
+                0,
+                0,
+                frameSize.width,
+                frameSize.height,
+                centerX,
+                centerY,
+                frameSize.width * ratio,
+                frameSize.height * ratio,
+            ];
+        }
+        case 'cover': {
+            const ratio = Math.max(canvasSize.width / frameSize.width, canvasSize.height / frameSize.height);
+            const centerX = (canvasSize.width - frameSize.width * ratio) / 2;
+            const centerY = (canvasSize.height - frameSize.height * ratio) / 2;
+            return [
+                0,
+                0,
+                frameSize.width,
+                frameSize.height,
+                centerX,
+                centerY,
+                frameSize.width * ratio,
+                frameSize.height * ratio,
+            ];
+        }
+        default:
+            throw new Error('Unknown fit: ' + fit);
+    }
+};
+const makeCanvas = () => {
+    if (typeof document === 'undefined') {
+        return null;
+    }
+    const canvas = document.createElement('canvas');
+    const ctx = canvas.getContext('2d');
+    canvas.width = 0;
+    canvas.height = 0;
+    return ctx;
+};
+export const Canvas = forwardRef(({ index, frames, width, height, fit, className, style }, ref) => {
+    const canvasRef = useRef(null);
+    const [tempCtx] = useState(() => {
+        return makeCanvas();
+    });
+    const size = useElementSize(canvasRef);
+    useImperativeHandle(ref, () => {
+        return canvasRef.current;
+    }, []);
+    useEffect(() => {
+        var _a;
+        if (!size) {
+            return;
+        }
+        const imageData = frames[index];
+        const ctx = (_a = canvasRef.current) === null || _a === void 0 ? void 0 : _a.getContext('2d');
+        if (imageData && tempCtx && ctx) {
+            if (tempCtx.canvas.width < imageData.width ||
+                tempCtx.canvas.height < imageData.height) {
+                tempCtx.canvas.width = imageData.width;
+                tempCtx.canvas.height = imageData.height;
+            }
+            if (size.width > 0 && size.height > 0) {
+                ctx.clearRect(0, 0, size.width, size.height);
+                tempCtx.clearRect(0, 0, tempCtx.canvas.width, tempCtx.canvas.height);
+            }
+            tempCtx.putImageData(imageData, 0, 0);
+            ctx.drawImage(tempCtx.canvas, ...calcArgs(fit, imageData, { width: size.width, height: size.height }));
+        }
+    }, [index, frames, fit, tempCtx, size]);
+    return (_jsx("canvas", { ref: canvasRef, className: className, style: style, width: width !== null && width !== void 0 ? width : size === null || size === void 0 ? void 0 : size.width, height: height !== null && height !== void 0 ? height : size === null || size === void 0 ? void 0 : size.height }));
+});

package/.rollup.cache/Users/jonathanburger/remotion/packages/gif/dist/esm/get-gif-duration-in-seconds.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @description Gets the duration in seconds of a GIF
+ * @see [Documentation](https://www.remotion.dev/docs/gif/get-gif-duration-in-seconds)
+ */
+export declare const getGifDurationInSeconds: (src: string) => Promise<number>;

package/.rollup.cache/Users/jonathanburger/remotion/packages/gif/dist/esm/get-gif-duration-in-seconds.js

@@ -0,0 +1,30 @@
+import { Internals } from 'remotion';
+import { manuallyManagedGifCache, volatileGifCache } from './gif-cache';
+import { parseGif, parseWithWorker } from './react-tools';
+const calcDuration = (parsed) => {
+    return (parsed.delays.reduce((sum, delay) => sum + delay, 0) / 1000);
+};
+/**
+ * @description Gets the duration in seconds of a GIF
+ * @see [Documentation](https://www.remotion.dev/docs/gif/get-gif-duration-in-seconds)
+ */
+export const getGifDurationInSeconds = async (src) => {
+    var _a;
+    const resolvedSrc = new URL(src, window.location.origin).href;
+    const inCache = (_a = volatileGifCache.get(resolvedSrc)) !== null && _a !== void 0 ? _a : manuallyManagedGifCache.get(resolvedSrc);
+    if (inCache) {
+        return calcDuration(inCache);
+    }
+    if (Internals.getRemotionEnvironment() === 'rendering') {
+        const renderingParsed = parseWithWorker(resolvedSrc);
+        const resolved = await renderingParsed.prom;
+        volatileGifCache.set(resolvedSrc, resolved);
+        return calcDuration(resolved);
+    }
+    const parsed = await parseGif({
+        src: resolvedSrc,
+        controller: new AbortController(),
+    });
+    volatileGifCache.set(resolvedSrc, parsed);
+    return calcDuration(parsed);
+};

package/.rollup.cache/Users/jonathanburger/remotion/packages/gif/dist/esm/gif-cache.d.ts

@@ -0,0 +1,4 @@
+import { QuickLRU } from './lru/index';
+import type { GifState } from './props';
+export declare const volatileGifCache: QuickLRU<string, GifState>;
+export declare const manuallyManagedGifCache: Map<string, GifState>;

package/.rollup.cache/Users/jonathanburger/remotion/packages/gif/dist/esm/gif-cache.js

@@ -0,0 +1,3 @@
+import { QuickLRU } from './lru/index';
+export const volatileGifCache = new QuickLRU({ maxSize: 30 });
+export const manuallyManagedGifCache = new Map();

package/.rollup.cache/Users/jonathanburger/remotion/packages/gif/dist/esm/gifuct/deinterlace.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Deinterlace function from https://github.com/shachaf/jsgif
+ */
+export declare const deinterlace: (pixels: number[], width: number) => any[];

package/.rollup.cache/Users/jonathanburger/remotion/packages/gif/dist/esm/gifuct/deinterlace.js

@@ -0,0 +1,22 @@
+/**
+ * Deinterlace function from https://github.com/shachaf/jsgif
+ */
+export const deinterlace = (pixels, width) => {
+    const newPixels = new Array(pixels.length);
+    const rows = pixels.length / width;
+    const cpRow = function (toRow, _fromRow) {
+        const fromPixels = pixels.slice(_fromRow * width, (_fromRow + 1) * width);
+        newPixels.splice(...[toRow * width, width].concat(fromPixels));
+    };
+    // See appendix E.
+    const offsets = [0, 4, 2, 1];
+    const steps = [8, 8, 4, 2];
+    let fromRow = 0;
+    for (let pass = 0; pass < 4; pass++) {
+        for (let toRow = offsets[pass]; toRow < rows; toRow += steps[pass]) {
+            cpRow(toRow, fromRow);
+            fromRow++;
+        }
+    }
+    return newPixels;
+};

package/.rollup.cache/Users/jonathanburger/remotion/packages/gif/dist/esm/gifuct/index.d.ts

@@ -0,0 +1,4 @@
+import type { Frame, ParsedFrameWithoutPatch, ParsedGif } from './types';
+export declare const parseGIF: (arrayBuffer: ArrayBuffer) => ParsedGif;
+export declare const decompressFrame: (frame: Frame, gct: [number, number, number][]) => ParsedFrameWithoutPatch | undefined;
+export declare const decompressFrames: (parsedGif: ParsedGif) => (ParsedFrameWithoutPatch | undefined)[];

package/.rollup.cache/Users/jonathanburger/remotion/packages/gif/dist/esm/gifuct/index.js

@@ -0,0 +1,48 @@
+import { GIF } from '../js-binary-schema-parser/gif';
+import { parse } from '../js-binary-schema-parser/parser';
+import { buildStream } from '../js-binary-schema-parser/uint8-parser';
+import { deinterlace } from './deinterlace';
+import { lzw } from './lzw';
+export const parseGIF = (arrayBuffer) => {
+    const byteData = new Uint8Array(arrayBuffer);
+    return parse(buildStream(byteData), GIF);
+};
+export const decompressFrame = (frame, gct) => {
+    var _a, _b;
+    if (!frame.image) {
+        console.warn('gif frame does not have associated image.');
+        return;
+    }
+    const { image } = frame;
+    // get the number of pixels
+    const totalPixels = image.descriptor.width * image.descriptor.height;
+    // do lzw decompression
+    let pixels = lzw(image.data.minCodeSize, image.data.blocks, totalPixels);
+    // deal with interlacing if necessary
+    if ((_a = image.descriptor.lct) === null || _a === void 0 ? void 0 : _a.interlaced) {
+        pixels = deinterlace(pixels, image.descriptor.width);
+    }
+    const resultImage = {
+        pixels,
+        dims: {
+            top: frame.image.descriptor.top,
+            left: frame.image.descriptor.left,
+            width: frame.image.descriptor.width,
+            height: frame.image.descriptor.height,
+        },
+        colorTable: ((_b = image.descriptor.lct) === null || _b === void 0 ? void 0 : _b.exists)
+            ? image.lct
+            : gct,
+        delay: (frame.gce.delay || 10) * 10,
+        disposalType: frame.gce.extras.disposal,
+        transparentIndex: frame.gce.extras.transparentColorGiven
+            ? frame.gce.transparentColorIndex
+            : -1,
+    };
+    return resultImage;
+};
+export const decompressFrames = (parsedGif) => {
+    return parsedGif.frames
+        .filter((f) => !('application' in f))
+        .map((f) => decompressFrame(f, parsedGif.gct));
+};

package/.rollup.cache/Users/jonathanburger/remotion/packages/gif/dist/esm/gifuct/lzw.d.ts

@@ -0,0 +1,5 @@
+/**
+ * javascript port of java LZW decompression
+ * Original java author url: https://gist.github.com/devunwired/4479231
+ */
+export declare const lzw: (minCodeSize: number, data: number[], pixelCount: number) => any[];

package/.rollup.cache/Users/jonathanburger/remotion/packages/gif/dist/esm/gifuct/lzw.js

@@ -0,0 +1,115 @@
+/* eslint-disable no-multi-assign */
+/* eslint-disable no-redeclare */
+/* eslint-disable no-bitwise */
+/* eslint-disable no-var */
+/**
+ * javascript port of java LZW decompression
+ * Original java author url: https://gist.github.com/devunwired/4479231
+ */
+export const lzw = (minCodeSize, data, pixelCount) => {
+    const MAX_STACK_SIZE = 4096;
+    const nullCode = -1;
+    const npix = pixelCount;
+    let available;
+    let code_mask;
+    let code_size;
+    let in_code;
+    let old_code;
+    var bits;
+    let code;
+    let i;
+    var datum;
+    var first;
+    var top;
+    var bi;
+    var pi;
+    const dstPixels = new Array(pixelCount);
+    const prefix = new Array(MAX_STACK_SIZE);
+    const suffix = new Array(MAX_STACK_SIZE);
+    const pixelStack = new Array(MAX_STACK_SIZE + 1);
+    // Initialize GIF data stream decoder.
+    const data_size = minCodeSize;
+    const clear = 1 << data_size;
+    const end_of_information = clear + 1;
+    available = clear + 2;
+    old_code = nullCode;
+    code_size = data_size + 1;
+    code_mask = (1 << code_size) - 1;
+    for (code = 0; code < clear; code++) {
+        prefix[code] = 0;
+        suffix[code] = code;
+    }
+    // Decode GIF pixel stream.
+    var datum;
+    var bits;
+    var first;
+    var top;
+    var pi;
+    var bi;
+    datum = bits = first = top = pi = bi = 0;
+    for (i = 0; i < npix;) {
+        if (top === 0) {
+            if (bits < code_size) {
+                // get the next byte
+                datum += data[bi] << bits;
+                bits += 8;
+                bi++;
+                continue;
+            }
+            // Get the next code.
+            code = datum & code_mask;
+            datum >>= code_size;
+            bits -= code_size;
+            // Interpret the code
+            if (code > available || code === end_of_information) {
+                break;
+            }
+            if (code === clear) {
+                // Reset decoder.
+                code_size = data_size + 1;
+                code_mask = (1 << code_size) - 1;
+                available = clear + 2;
+                old_code = nullCode;
+                continue;
+            }
+            if (old_code === nullCode) {
+                pixelStack[top++] = suffix[code];
+                old_code = code;
+                first = code;
+                continue;
+            }
+            in_code = code;
+            if (code === available) {
+                pixelStack[top++] = first;
+                code = old_code;
+            }
+            while (code > clear) {
+                pixelStack[top++] = suffix[code];
+                code = prefix[code];
+            }
+            first = suffix[code] & 0xff;
+            pixelStack[top++] = first;
+            // add a new string to the table, but only if space is available
+            // if not, just continue with current table until a clear code is found
+            // (deferred clear code implementation as per GIF spec)
+            if (available < MAX_STACK_SIZE) {
+                prefix[available] = old_code;
+                suffix[available] = first;
+                available++;
+                if ((available & code_mask) === 0 && available < MAX_STACK_SIZE) {
+                    code_size++;
+                    code_mask += available;
+                }
+            }
+            old_code = in_code;
+        }
+        // Pop a pixel off the pixel stack.
+        top--;
+        dstPixels[pi++] = pixelStack[top];
+        i++;
+    }
+    for (i = pi; i < npix; i++) {
+        dstPixels[i] = 0; // clear missing pixels
+    }
+    return dstPixels;
+};

package/.rollup.cache/Users/jonathanburger/remotion/packages/gif/dist/esm/gifuct/types.d.ts

@@ -0,0 +1,96 @@
+type Dimensions = {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+};
+export type Application = {
+    application: {
+        blockSize: number;
+        blocks: number[];
+        codes: number[];
+        id: string;
+    };
+};
+type Lct = {
+    exists: boolean;
+    future: number;
+    interlaced: boolean;
+    size: number;
+    sort: boolean;
+};
+export type Frame = {
+    gce: {
+        byteSize: number;
+        codes: number[];
+        delay: number;
+        terminator: number;
+        transparentColorIndex: number;
+        extras: {
+            userInput: boolean;
+            transparentColorGiven: boolean;
+            future: number;
+            disposal: number;
+        };
+    };
+    image: {
+        code: number;
+        data: {
+            minCodeSize: number;
+            blocks: number[];
+        };
+        descriptor: {
+            top: number;
+            left: number;
+            width: number;
+            height: number;
+            lct: Lct;
+        };
+        lct: [number, number, number][] | undefined;
+    };
+};
+export type ParsedFrame = {
+    dims: {
+        width: number;
+        height: number;
+        top: number;
+        left: number;
+    };
+    colorTable: [number, number, number][];
+    delay: number;
+    disposalType: number;
+    patch: Uint8ClampedArray;
+    pixels: number[];
+    transparentIndex: number;
+};
+export type ParsedFrameWithoutPatch = Omit<ParsedFrame, 'patch'>;
+export type ParsedGif = {
+    frames: (Application | Frame)[];
+    gct: [number, number, number][];
+    header: {
+        signature: string;
+        version: string;
+    };
+    lsd: {
+        backgroundColorIndex: number;
+        gct: {
+            exists: boolean;
+            resolution: number;
+            size: number;
+            sort: boolean;
+        };
+        height: number;
+        width: number;
+        pixelAspectRatio: number;
+    };
+};
+export type Image = {
+    pixels: number[];
+    dims: Dimensions;
+    delay?: number;
+    transparentIndex?: number;
+    colorTable?: [number, number, number][] | Lct;
+    disposalType?: unknown;
+    patch?: Uint8ClampedArray;
+};
+export {};

package/.rollup.cache/Users/jonathanburger/remotion/packages/gif/dist/esm/gifuct/types.js

@@ -0,0 +1 @@
+export {};

package/.rollup.cache/Users/jonathanburger/remotion/packages/gif/dist/esm/index.d.ts

@@ -0,0 +1,4 @@
+export { getGifDurationInSeconds } from './get-gif-duration-in-seconds';
+export { Gif } from './Gif';
+export { preloadGif } from './preload-gif';
+export { GifFillMode, RemotionGifProps } from './props';

package/.rollup.cache/Users/jonathanburger/remotion/packages/gif/dist/esm/index.js

@@ -0,0 +1,3 @@
+export { getGifDurationInSeconds } from './get-gif-duration-in-seconds';
+export { Gif } from './Gif';
+export { preloadGif } from './preload-gif';

package/.rollup.cache/Users/jonathanburger/remotion/packages/gif/dist/esm/is-cors-error.d.ts

@@ -0,0 +1 @@
+export declare const isCorsError: (error: Error) => boolean;