@remotion/gif 4.0.0-webhook.27 → 4.1.0-alpha1

package/dist/esm/index.mjs

@@ -0,0 +1,1281 @@
+import { Internals, useCurrentFrame, useVideoConfig, delayRender, continueRender } from 'remotion';
+import { jsx } from 'react/jsx-runtime';
+import { useState, useMemo, useCallback, useEffect, forwardRef, useRef, useImperativeHandle } from 'react';
+
+class QuickLRU {
+    /**
+    Simple ["Least Recently Used" (LRU) cache](https://en.m.wikipedia.org/wiki/Cache_replacement_policies#Least_Recently_Used_.28LRU.29).
+
+    The instance is an [`Iterable`](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Iteration_protocols) of `[key, value]` pairs so you can use it directly in a [`for…of`](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Statements/for...of) loop.
+
+    @example
+    ```
+    import { QuickLRU } from 'quick-lru-ts';
+
+    const lru = new QuickLRU({maxSize: 1000});
+
+    lru.set('🦄', '🌈');
+
+    lru.has('🦄');
+    //=> true
+
+    lru.get('🦄');
+    //=> '🌈'
+    ```
+    */
+    constructor(options) {
+        if (!(options.maxSize && options.maxSize > 0)) {
+            throw new TypeError('`maxSize` must be a number greater than 0');
+        }
+        if (typeof options.maxAge === 'number' && options.maxAge === 0) {
+            throw new TypeError('`maxAge` must be a number greater than 0');
+        }
+        this.maxSize = options.maxSize;
+        this.maxAge = options.maxAge || Number.POSITIVE_INFINITY;
+        this.onEviction = options.onEviction;
+        this.cache = new Map();
+        this.oldCache = new Map();
+        this._size = 0;
+    }
+    _emitEvictions(cache) {
+        if (typeof this.onEviction !== 'function') {
+            return;
+        }
+        for (const [key, item] of cache) {
+            this.onEviction(key, item.value);
+        }
+    }
+    _deleteIfExpired(key, item) {
+        if (item === undefined)
+            return true;
+        if (typeof item.expiry === 'number' && item.expiry <= Date.now()) {
+            if (typeof this.onEviction === 'function') {
+                this.onEviction(key, item.value);
+            }
+            return this.delete(key);
+        }
+        return false;
+    }
+    _getOrDeleteIfExpired(key, item) {
+        const deleted = this._deleteIfExpired(key, item);
+        if (deleted === false) {
+            return item.value;
+        }
+    }
+    _getItemValue(key, item) {
+        if (item === undefined)
+            return undefined;
+        return item.expiry ? this._getOrDeleteIfExpired(key, item) : item.value;
+    }
+    _peek(key, cache) {
+        const item = cache.get(key);
+        return this._getItemValue(key, item);
+    }
+    _set(key, value) {
+        this.cache.set(key, value);
+        this._size++;
+        if (this._size >= this.maxSize) {
+            this._size = 0;
+            this._emitEvictions(this.oldCache);
+            this.oldCache = this.cache;
+            this.cache = new Map();
+        }
+    }
+    _moveToRecent(key, item) {
+        this.oldCache.delete(key);
+        this._set(key, item);
+    }
+    *_entriesAscending() {
+        for (const item of this.oldCache) {
+            const [key, value] = item;
+            if (!this.cache.has(key)) {
+                const deleted = this._deleteIfExpired(key, value);
+                if (deleted === false) {
+                    yield item;
+                }
+            }
+        }
+        for (const item of this.cache) {
+            const [key, value] = item;
+            const deleted = this._deleteIfExpired(key, value);
+            if (deleted === false) {
+                yield item;
+            }
+        }
+    }
+    /**
+    Get an item.
+
+    @returns The stored item or `undefined`.
+    */
+    get(key) {
+        if (this.cache.has(key)) {
+            const item = this.cache.get(key);
+            return this._getItemValue(key, item);
+        }
+        if (this.oldCache.has(key)) {
+            const item = this.oldCache.get(key);
+            if (this._deleteIfExpired(key, item) === false) {
+                this._moveToRecent(key, item);
+                return item.value;
+            }
+        }
+    }
+    set(key, value, { maxAge = this.maxAge } = {}) {
+        const expiry = typeof maxAge === 'number' && maxAge !== Number.POSITIVE_INFINITY
+            ? Date.now() + maxAge
+            : undefined;
+        if (this.cache.has(key)) {
+            this.cache.set(key, {
+                value,
+                expiry,
+            });
+        }
+        else {
+            this._set(key, { value, expiry });
+        }
+    }
+    has(key) {
+        if (this.cache.has(key)) {
+            return !this._deleteIfExpired(key, this.cache.get(key));
+        }
+        if (this.oldCache.has(key)) {
+            return !this._deleteIfExpired(key, this.oldCache.get(key));
+        }
+        return false;
+    }
+    peek(key) {
+        if (this.cache.has(key)) {
+            return this._peek(key, this.cache);
+        }
+        if (this.oldCache.has(key)) {
+            return this._peek(key, this.oldCache);
+        }
+    }
+    delete(key) {
+        const deleted = this.cache.delete(key);
+        if (deleted) {
+            this._size--;
+        }
+        return this.oldCache.delete(key) || deleted;
+    }
+    clear() {
+        this.cache.clear();
+        this.oldCache.clear();
+        this._size = 0;
+    }
+    resize(maxSize) {
+        if (!(maxSize && maxSize > 0)) {
+            throw new TypeError('`maxSize` must be a number greater than 0');
+        }
+        const items = [...this._entriesAscending()];
+        const removeCount = items.length - maxSize;
+        if (removeCount < 0) {
+            this.cache = new Map(items);
+            this.oldCache = new Map();
+            this._size = items.length;
+        }
+        else {
+            if (removeCount > 0) {
+                this._emitEvictions(items.slice(0, removeCount));
+            }
+            this.oldCache = new Map(items.slice(removeCount));
+            this.cache = new Map();
+            this._size = 0;
+        }
+        this.maxSize = maxSize;
+    }
+    *keys() {
+        for (const [key] of this) {
+            yield key;
+        }
+    }
+    *values() {
+        for (const [, value] of this) {
+            yield value;
+        }
+    }
+    *[Symbol.iterator]() {
+        for (const item of this.cache) {
+            const [key, value] = item;
+            const deleted = this._deleteIfExpired(key, value);
+            if (deleted === false) {
+                yield [key, value.value];
+            }
+        }
+        for (const item of this.oldCache) {
+            const [key, value] = item;
+            if (!this.cache.has(key)) {
+                const deleted = this._deleteIfExpired(key, value);
+                if (deleted === false) {
+                    yield [key, value.value];
+                }
+            }
+        }
+    }
+    /**
+    Iterable for all entries, starting with the newest (descending in recency).
+    */
+    *entriesDescending() {
+        let items = [...this.cache];
+        for (let i = items.length - 1; i >= 0; --i) {
+            const item = items[i];
+            const [key, value] = item;
+            const deleted = this._deleteIfExpired(key, value);
+            if (deleted === false) {
+                yield [key, value.value];
+            }
+        }
+        items = [...this.oldCache];
+        for (let i = items.length - 1; i >= 0; --i) {
+            const item = items[i];
+            const [key, value] = item;
+            if (!this.cache.has(key)) {
+                const deleted = this._deleteIfExpired(key, value);
+                if (deleted === false) {
+                    yield [key, value.value];
+                }
+            }
+        }
+    }
+    *entriesAscending() {
+        for (const [key, value] of this._entriesAscending()) {
+            yield [key, value.value];
+        }
+    }
+    get size() {
+        if (!this._size) {
+            return this.oldCache.size;
+        }
+        let oldCacheSize = 0;
+        for (const key of this.oldCache.keys()) {
+            if (!this.cache.has(key)) {
+                oldCacheSize++;
+            }
+        }
+        return Math.min(this._size + oldCacheSize, this.maxSize);
+    }
+}
+
+const volatileGifCache = new QuickLRU({ maxSize: 30 });
+const manuallyManagedGifCache = new Map();
+
+const parse$1 = (stream, schema, result = {}, parent = result) => {
+    if (Array.isArray(schema)) {
+        schema.forEach((partSchema) => {
+            return parse$1(stream, partSchema, result, parent);
+        });
+    }
+    else if (typeof schema === 'function') {
+        schema(stream, result, parent, parse$1);
+    }
+    else {
+        // @ts-expect-error
+        const key = Object.keys(schema)[0];
+        // @ts-expect-error
+        if (Array.isArray(schema[key])) {
+            // @ts-expect-error
+            parent[key] = {};
+            // @ts-expect-error
+            parse$1(stream, schema[key], result, parent[key]);
+        }
+        else {
+            // @ts-expect-error
+            parent[key] = schema[key](stream, result, parent, parse$1);
+        }
+    }
+    return result;
+};
+const loop = (schema, continueFunc) => {
+    return function (stream, result, parent, _parse) {
+        const arr = [];
+        let lastStreamPos = stream.pos;
+        while (continueFunc(stream, result, parent)) {
+            const newParent = {};
+            _parse(stream, schema, result, newParent); // cases when whole file is parsed but no termination is there and stream position is not getting updated as well
+            // it falls into infinite recursion, null check to avoid the same
+            if (stream.pos === lastStreamPos) {
+                break;
+            }
+            lastStreamPos = stream.pos;
+            arr.push(newParent);
+        }
+        return arr;
+    };
+};
+const conditional = (schema, conditionFunc) => (stream, result, parent, parseFn) => {
+    if (conditionFunc(stream, result, parent)) {
+        parseFn(stream, schema, result, parent);
+    }
+};
+
+/* eslint-disable no-bitwise */
+// Default stream and parsers for Uint8TypedArray data type
+const buildStream = (uint8Data) => ({
+    data: uint8Data,
+    pos: 0,
+});
+const readByte = () => (stream) => {
+    return stream.data[stream.pos++];
+};
+const peekByte = (offset = 0) => (stream) => {
+    return stream.data[stream.pos + offset];
+};
+const readBytes = (length) => (stream) => {
+    // eslint-disable-next-line no-return-assign
+    return stream.data.subarray(stream.pos, (stream.pos += length));
+};
+const peekBytes = (length) => (stream) => {
+    return stream.data.subarray(stream.pos, stream.pos + length);
+};
+const readString = (length) => (stream) => {
+    return Array.from(readBytes(length)(stream))
+        .map((value) => String.fromCharCode(value))
+        .join('');
+};
+const readUnsigned = (littleEndian) => (stream) => {
+    const bytes = readBytes(2)(stream);
+    return littleEndian ? (bytes[1] << 8) + bytes[0] : (bytes[0] << 8) + bytes[1];
+};
+const readArray = (byteSize, totalOrFunc) => (stream, result, parent) => {
+    const total = typeof totalOrFunc === 'function'
+        ? totalOrFunc(stream, result, parent)
+        : totalOrFunc;
+    const parser = readBytes(byteSize);
+    const arr = new Array(total);
+    for (let i = 0; i < total; i++) {
+        arr[i] = parser(stream);
+    }
+    return arr;
+};
+const subBitsTotal = (bits, startIndex, length) => {
+    let result = 0;
+    for (let i = 0; i < length; i++) {
+        result += Number(bits[startIndex + i] && 2 ** (length - i - 1));
+    }
+    return result;
+};
+const readBits = (schema) => (stream) => {
+    const byte = readByte()(stream);
+    // convert the byte to bit array
+    const bits = new Array(8);
+    for (let i = 0; i < 8; i++) {
+        bits[7 - i] = Boolean(byte & (1 << i));
+    }
+    // convert the bit array to values based on the schema
+    // @ts-expect-error
+    return Object.keys(schema).reduce((res, key) => {
+        // @ts-expect-error
+        const def = schema[key];
+        if (def.length) {
+            res[key] = subBitsTotal(bits, def.index, def.length);
+        }
+        else {
+            res[key] = bits[def.index];
+        }
+        return res;
+    }, {});
+};
+
+// a set of 0x00 terminated subblocks
+const subBlocksSchema = {
+    blocks: (stream) => {
+        const terminator = 0x00;
+        const chunks = [];
+        const streamSize = stream.data.length;
+        let total = 0;
+        for (let size = readByte()(stream); size !== terminator; size = readByte()(stream)) {
+            // size becomes undefined for some case when file is corrupted and  terminator is not proper
+            // null check to avoid recursion
+            if (!size)
+                break;
+            // catch corrupted files with no terminator
+            if (stream.pos + size >= streamSize) {
+                const availableSize = streamSize - stream.pos;
+                chunks.push(readBytes(availableSize)(stream));
+                total += availableSize;
+                break;
+            }
+            chunks.push(readBytes(size)(stream));
+            total += size;
+        }
+        const result = new Uint8Array(total);
+        let offset = 0;
+        for (let i = 0; i < chunks.length; i++) {
+            result.set(chunks[i], offset);
+            offset += chunks[i].length;
+        }
+        return result;
+    },
+};
+// global control extension
+const gceSchema = conditional({
+    gce: [
+        { codes: readBytes(2) },
+        { byteSize: readByte() },
+        {
+            extras: readBits({
+                future: { index: 0, length: 3 },
+                disposal: { index: 3, length: 3 },
+                userInput: { index: 6 },
+                transparentColorGiven: { index: 7 },
+            }),
+        },
+        { delay: readUnsigned(true) },
+        { transparentColorIndex: readByte() },
+        { terminator: readByte() },
+    ],
+}, (stream) => {
+    const codes = peekBytes(2)(stream);
+    return codes[0] === 0x21 && codes[1] === 0xf9;
+});
+// image pipeline block
+const imageSchema = conditional({
+    image: [
+        { code: readByte() },
+        {
+            descriptor: [
+                { left: readUnsigned(true) },
+                { top: readUnsigned(true) },
+                { width: readUnsigned(true) },
+                { height: readUnsigned(true) },
+                {
+                    lct: readBits({
+                        exists: { index: 0 },
+                        interlaced: { index: 1 },
+                        sort: { index: 2 },
+                        future: { index: 3, length: 2 },
+                        size: { index: 5, length: 3 },
+                    }),
+                },
+            ],
+        },
+        conditional({
+            lct: readArray(3, (_stream, _result, parent) => {
+                return 2 ** (parent.descriptor.lct.size + 1);
+            }),
+        }, (_stream, _result, parent) => {
+            return parent.descriptor.lct.exists;
+        }),
+        { data: [{ minCodeSize: readByte() }, subBlocksSchema] },
+    ],
+}, (stream) => {
+    return peekByte()(stream) === 0x2c;
+});
+// plain text block
+const textSchema = conditional({
+    text: [
+        { codes: readBytes(2) },
+        { blockSize: readByte() },
+        {
+            preData: (stream, _result, parent) => readBytes(parent.text.blockSize)(stream),
+        },
+        subBlocksSchema,
+    ],
+}, (stream) => {
+    const codes = peekBytes(2)(stream);
+    return codes[0] === 0x21 && codes[1] === 0x01;
+});
+// application block
+const applicationSchema = conditional({
+    application: [
+        { codes: readBytes(2) },
+        { blockSize: readByte() },
+        {
+            id: (stream, _result, parent) => readString(parent.blockSize)(stream),
+        },
+        subBlocksSchema,
+    ],
+}, (stream) => {
+    const codes = peekBytes(2)(stream);
+    return codes[0] === 0x21 && codes[1] === 0xff;
+});
+// comment block
+const commentSchema = conditional({
+    comment: [{ codes: readBytes(2) }, subBlocksSchema],
+}, (stream) => {
+    const codes = peekBytes(2)(stream);
+    return codes[0] === 0x21 && codes[1] === 0xfe;
+});
+const GIF = [
+    { header: [{ signature: readString(3) }, { version: readString(3) }] },
+    {
+        lsd: [
+            { width: readUnsigned(true) },
+            { height: readUnsigned(true) },
+            {
+                gct: readBits({
+                    exists: { index: 0 },
+                    resolution: { index: 1, length: 3 },
+                    sort: { index: 4 },
+                    size: { index: 5, length: 3 },
+                }),
+            },
+            { backgroundColorIndex: readByte() },
+            { pixelAspectRatio: readByte() },
+        ],
+    },
+    conditional({
+        gct: readArray(3, (_stream, result) => 2 ** (result.lsd.gct.size + 1)),
+    }, (_stream, result) => result.lsd.gct.exists),
+    // content frames
+    {
+        frames: loop([gceSchema, applicationSchema, commentSchema, imageSchema, textSchema], (stream) => {
+            const nextCode = peekByte()(stream);
+            // rather than check for a terminator, we should check for the existence
+            // of an ext or image block to avoid infinite loops
+            // var terminator = 0x3B;
+            // return nextCode !== terminator;
+            return nextCode === 0x21 || nextCode === 0x2c;
+        }),
+    },
+];
+
+/**
+ * Deinterlace function from https://github.com/shachaf/jsgif
+ */
+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;
+};
+
+/* 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
+ */
+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;
+};
+
+const parseGIF = (arrayBuffer) => {
+    const byteData = new Uint8Array(arrayBuffer);
+    return parse$1(buildStream(byteData), GIF);
+};
+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;
+};
+
+const decompressFrames = (parsedGif) => {
+    return parsedGif.frames
+        .filter((f) => {
+        return !('application' in f);
+    })
+        .map((f) => {
+        const fr = f.image
+            ? decompressFrame(f, parsedGif.gct)
+            : null;
+        return fr;
+    })
+        .filter(Boolean)
+        .map((f) => f);
+};
+
+const validateAndFix = (gif) => {
+    let currentGce = null;
+    for (const frame of gif.frames) {
+        currentGce = frame.gce ? frame.gce : currentGce;
+        // fix loosing graphic control extension for same frames
+        if ('image' in frame && !('gce' in frame) && currentGce !== null) {
+            frame.gce = currentGce;
+        }
+    }
+};
+const parse = (src, { signal, }) => fetch(src, { signal })
+    .then((resp) => {
+    var _a;
+    if (!((_a = resp.headers.get('Content-Type')) === null || _a === void 0 ? void 0 : _a.includes('image/gif')))
+        throw Error(`Wrong content type: "${resp.headers.get('Content-Type')}"`);
+    return resp.arrayBuffer();
+})
+    .then((buffer) => parseGIF(buffer))
+    .then((gif) => {
+    validateAndFix(gif);
+    return gif;
+})
+    .then((gif) => Promise.all([
+    decompressFrames(gif),
+    { width: gif.lsd.width, height: gif.lsd.height },
+]))
+    .then(([frames, options]) => {
+    const readyFrames = [];
+    const size = options.width * options.height * 4;
+    let canvas = new Uint8ClampedArray(size);
+    for (let i = 0; i < frames.length; ++i) {
+        const frame = frames[i];
+        // Read about different disposal types
+        // https://giflib.sourceforge.net/whatsinagif/animation_and_transparency.html
+        const prevCanvas = frames[i].disposalType === 3 ? canvas.slice() : null;
+        readyFrames.push(putPixels(canvas, frame, options));
+        // Disposal type 2: The canvas should be restored to the background color
+        if (frames[i].disposalType === 2) {
+            canvas = new Uint8ClampedArray(size);
+        }
+        // Disposal type 3: The decoder should restore the canvas to its previous state before the current image was drawn
+        else if (frames[i].disposalType === 3) {
+            if (!prevCanvas) {
+                throw Error('Disposal type 3 without previous frame');
+            }
+            canvas = prevCanvas;
+        }
+        // Disposal type 1: Draw the next image on top of it
+        else {
+            canvas = readyFrames[i].slice();
+        }
+    }
+    return {
+        ...options,
+        loaded: true,
+        delays: frames.map((frame) => frame.delay),
+        frames: readyFrames,
+    };
+});
+const putPixels = (typedArray, frame, gifSize) => {
+    const { width, height, top: dy, left: dx } = frame.dims;
+    const offset = dy * gifSize.width + dx;
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            const pPos = y * width + x;
+            const colorIndex = frame.pixels[pPos];
+            if (colorIndex !== frame.transparentIndex) {
+                const taPos = offset + y * gifSize.width + x;
+                const color = frame.colorTable[colorIndex];
+                typedArray[taPos * 4] = color[0];
+                typedArray[taPos * 4 + 1] = color[1];
+                typedArray[taPos * 4 + 2] = color[2];
+                typedArray[taPos * 4 + 3] =
+                    colorIndex === frame.transparentIndex ? 0 : 255;
+            }
+        }
+    }
+    return typedArray;
+};
+const generate = (info) => {
+    return {
+        ...info,
+        frames: info.frames.map((buffer) => {
+            const image = new ImageData(info.width, info.height);
+            image.data.set(new Uint8ClampedArray(buffer));
+            return image;
+        }),
+    };
+};
+
+// Auto-generated by build.mjs
+const src = 
+// eslint-disable-next-line no-template-curly-in-string
+'"use strict";(()=>{var P=(t,r,e={},n=e)=>{if(Array.isArray(r))r.forEach(o=>P(t,o,e,n));else if(typeof r=="function")r(t,e,n,P);else{let o=Object.keys(r)[0];Array.isArray(r[o])?(n[o]={},P(t,r[o],e,n[o])):n[o]=r[o](t,e,n,P)}return e},M=(t,r)=>function(e,n,o,c){let s=[],a=e.pos;for(;r(e,n,o);){let i={};if(c(e,t,n,i),e.pos===a)break;a=e.pos,s.push(i)}return s},g=(t,r)=>(e,n,o,c)=>{r(e,n,o)&&c(e,t,n,o)};var W=t=>({data:t,pos:0}),m=()=>t=>t.data[t.pos++],U=(t=0)=>r=>r.data[r.pos+t],f=t=>r=>r.data.subarray(r.pos,r.pos+=t),k=t=>r=>r.data.subarray(r.pos,r.pos+t),v=t=>r=>Array.from(f(t)(r)).map(e=>String.fromCharCode(e)).join(""),b=t=>r=>{let e=f(2)(r);return t?(e[1]<<8)+e[0]:(e[0]<<8)+e[1]},E=(t,r)=>(e,n,o)=>{let c=typeof r=="function"?r(e,n,o):r,s=f(t),a=new Array(c);for(let i=0;i<c;i++)a[i]=s(e);return a},$=(t,r,e)=>{let n=0;for(let o=0;o<e;o++)n+=Number(t[r+o]&&2**(e-o-1));return n},I=t=>r=>{let e=m()(r),n=new Array(8);for(let o=0;o<8;o++)n[7-o]=Boolean(e&1<<o);return Object.keys(t).reduce((o,c)=>{let s=t[c];return s.length?o[c]=$(n,s.index,s.length):o[c]=n[s.index],o},{})};var z={blocks:t=>{let e=[],n=t.data.length,o=0;for(let a=m()(t);a!==0&&a;a=m()(t)){if(t.pos+a>=n){let i=n-t.pos;e.push(f(i)(t)),o+=i;break}e.push(f(a)(t)),o+=a}let c=new Uint8Array(o),s=0;for(let a=0;a<e.length;a++)c.set(e[a],s),s+=e[a].length;return c}},q=g({gce:[{codes:f(2)},{byteSize:m()},{extras:I({future:{index:0,length:3},disposal:{index:3,length:3},userInput:{index:6},transparentColorGiven:{index:7}})},{delay:b(!0)},{transparentColorIndex:m()},{terminator:m()}]},t=>{let r=k(2)(t);return r[0]===33&&r[1]===249}),H=g({image:[{code:m()},{descriptor:[{left:b(!0)},{top:b(!0)},{width:b(!0)},{height:b(!0)},{lct:I({exists:{index:0},interlaced:{index:1},sort:{index:2},future:{index:3,length:2},size:{index:5,length:3}})}]},g({lct:E(3,(t,r,e)=>2**(e.descriptor.lct.size+1))},(t,r,e)=>e.descriptor.lct.exists),{data:[{minCodeSize:m()},z]}]},t=>U()(t)===44),J=g({text:[{codes:f(2)},{blockSize:m()},{preData:(t,r,e)=>f(e.text.blockSize)(t)},z]},t=>{let r=k(2)(t);return r[0]===33&&r[1]===1}),Q=g({application:[{codes:f(2)},{blockSize:m()},{id:(t,r,e)=>v(e.blockSize)(t)},z]},t=>{let r=k(2)(t);return r[0]===33&&r[1]===255}),V=g({comment:[{codes:f(2)},z]},t=>{let r=k(2)(t);return r[0]===33&&r[1]===254}),K=[{header:[{signature:v(3)},{version:v(3)}]},{lsd:[{width:b(!0)},{height:b(!0)},{gct:I({exists:{index:0},resolution:{index:1,length:3},sort:{index:4},size:{index:5,length:3}})},{backgroundColorIndex:m()},{pixelAspectRatio:m()}]},g({gct:E(3,(t,r)=>2**(r.lsd.gct.size+1))},(t,r)=>r.lsd.gct.exists),{frames:M([q,Q,V,H,J],t=>{let r=U()(t);return r===33||r===44})}];var X=(t,r)=>{let e=new Array(t.length),n=t.length/r,o=function(i,d){let u=t.slice(d*r,(d+1)*r);e.splice(...[i*r,r].concat(u))},c=[0,4,2,1],s=[8,8,4,2],a=0;for(let i=0;i<4;i++)for(let d=c[i];d<n;d+=s[i])o(d,a),a++;return e};var Z=(t,r,e)=>{let c=e,s,a,i,d,u;var w;let l,p;var C,S,h,_,G;let x=new Array(e),B=new Array(4096),T=new Array(4096),F=new Array(4096+1),R=t,y=1<<R,O=y+1;for(s=y+2,u=-1,i=R+1,a=(1<<i)-1,l=0;l<y;l++)B[l]=0,T[l]=l;var C,w,S,h,G,_;for(C=w=S=h=G=_=0,p=0;p<c;){if(h===0){if(w<i){C+=r[_]<<w,w+=8,_++;continue}if(l=C&a,C>>=i,w-=i,l>s||l===O)break;if(l===y){i=R+1,a=(1<<i)-1,s=y+2,u=-1;continue}if(u===-1){F[h++]=T[l],u=l,S=l;continue}for(d=l,l===s&&(F[h++]=S,l=u);l>y;)F[h++]=T[l],l=B[l];S=T[l]&255,F[h++]=S,s<4096&&(B[s]=u,T[s]=S,s++,!(s&a)&&s<4096&&(i++,a+=s)),u=d}h--,x[G++]=F[h],p++}for(p=G;p<c;p++)x[p]=0;return x};var j=t=>{let r=new Uint8Array(t);return P(W(r),K)},D=(t,r)=>{var s,a;if(!t.image){console.warn("gif frame does not have associated image.");return}let{image:e}=t,n=e.descriptor.width*e.descriptor.height,o=Z(e.data.minCodeSize,e.data.blocks,n);return(s=e.descriptor.lct)!=null&&s.interlaced&&(o=X(o,e.descriptor.width)),{pixels:o,dims:{top:t.image.descriptor.top,left:t.image.descriptor.left,width:t.image.descriptor.width,height:t.image.descriptor.height},colorTable:(a=e.descriptor.lct)!=null&&a.exists?e.lct:r,delay:(t.gce.delay||10)*10,disposalType:t.gce.extras.disposal,transparentIndex:t.gce.extras.transparentColorGiven?t.gce.transparentColorIndex:-1}};var L=t=>t.frames.filter(r=>!("application"in r)).map(r=>r.image?D(r,t.gct):null).filter(Boolean).map(r=>r);var Y=t=>{let r=null;for(let e of t.frames)r=e.gce?e.gce:r,"image"in e&&!("gce"in e)&&r!==null&&(e.gce=r)},N=(t,{signal:r})=>fetch(t,{signal:r}).then(e=>{var n;if(!((n=e.headers.get("Content-Type"))!=null&&n.includes("image/gif")))throw Error(`Wrong content type: "${e.headers.get("Content-Type")}"`);return e.arrayBuffer()}).then(e=>j(e)).then(e=>(Y(e),e)).then(e=>Promise.all([L(e),{width:e.lsd.width,height:e.lsd.height}])).then(([e,n])=>{let o=[],c=n.width*n.height*4,s=new Uint8ClampedArray(c);for(let a=0;a<e.length;++a){let i=e[a],d=e[a].disposalType===3?s.slice():null;if(o.push(ee(s,i,n)),e[a].disposalType===2)s=new Uint8ClampedArray(c);else if(e[a].disposalType===3){if(!d)throw Error("Disposal type 3 without previous frame");s=d}else s=o[a].slice()}return{...n,loaded:!0,delays:e.map(a=>a.delay),frames:o}}),ee=(t,r,e)=>{let{width:n,height:o,top:c,left:s}=r.dims,a=c*e.width+s;for(let i=0;i<o;i++)for(let d=0;d<n;d++){let u=i*n+d,l=r.pixels[u];if(l!==r.transparentIndex){let p=a+i*e.width+d,x=r.colorTable[l];t[p*4]=x[0],t[p*4+1]=x[1],t[p*4+2]=x[2],t[p*4+3]=l===r.transparentIndex?0:255}}return t};var A=new Map;self.addEventListener("message",t=>{let{type:r,src:e}=t.data||t;switch(r){case"parse":{if(!A.has(e)){let n=new AbortController,o={signal:n.signal};A.set(e,n),N(e,o).then(c=>{self.postMessage(Object.assign(c,{src:e}),c.frames.map(s=>s.buffer))}).catch(c=>{self.postMessage({src:e,error:c,loaded:!0})}).finally(()=>{A.delete(e)})}break}case"cancel":{A.has(e)&&(A.get(e).abort(),A.delete(e));break}default:break}});})();\n';
+
+const makeWorker = () => {
+    const blob = new Blob([src], { type: 'application/javascript' });
+    const url = URL.createObjectURL(blob);
+    const worker = new Worker(url);
+    URL.revokeObjectURL(url);
+    return worker;
+};
+
+const parseGif = async ({ src, controller, }) => {
+    const raw = await parse(src, { signal: controller.signal });
+    return generate(raw);
+};
+const parseWithWorker = (src) => {
+    const worker = makeWorker();
+    let handler = null;
+    const prom = new Promise((resolve, reject) => {
+        handler = (e) => {
+            const message = e.data || e;
+            if (message.src === src) {
+                if (message.error) {
+                    reject(new Error(message.error));
+                }
+                else {
+                    const data = message.error ? message : generate(message);
+                    resolve(data);
+                    worker.terminate();
+                }
+            }
+        };
+        worker.addEventListener('message', handler);
+        worker.postMessage({ src, type: 'parse' });
+    });
+    return {
+        prom,
+        cancel: () => {
+            worker.postMessage({ src, type: 'cancel' });
+            worker.removeEventListener('message', handler);
+            worker.terminate();
+        },
+    };
+};
+
+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)
+ */
+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);
+};
+
+let elementSizeHooks = [];
+const useElementSize = (ref) => {
+    const [size, setSize] = useState(null);
+    const observer = useMemo(() => {
+        if (typeof ResizeObserver === 'undefined') {
+            return null;
+        }
+        return new ResizeObserver((entries) => {
+            // The contentRect returns the width without any `scale()`'s being applied. The height is wrong
+            const { contentRect } = entries[0];
+            // The clientRect returns the size with `scale()` being applied.
+            const newSize = entries[0].target.getClientRects();
+            if (!(newSize === null || newSize === void 0 ? void 0 : newSize[0])) {
+                setSize(null);
+                return;
+            }
+            const probableCssParentScale = newSize[0].width / contentRect.width;
+            const width = newSize[0].width * (1 / probableCssParentScale);
+            const height = newSize[0].height * (1 / probableCssParentScale);
+            setSize({
+                width,
+                height,
+            });
+        });
+    }, []);
+    const updateSize = useCallback(() => {
+        if (!ref.current) {
+            return;
+        }
+        const rect = ref.current.getClientRects();
+        if (!rect[0]) {
+            setSize(null);
+            return;
+        }
+        setSize({
+            width: rect[0].width,
+            height: rect[0].height,
+        });
+    }, [ref]);
+    useEffect(() => {
+        if (!observer) {
+            return;
+        }
+        updateSize();
+        const { current } = ref;
+        if (ref.current) {
+            observer.observe(ref.current);
+        }
+        return () => {
+            if (current) {
+                observer.unobserve(current);
+            }
+        };
+    }, [observer, ref, updateSize]);
+    useEffect(() => {
+        elementSizeHooks.push(updateSize);
+        return () => {
+            elementSizeHooks = elementSizeHooks.filter((e) => e !== updateSize);
+        };
+    }, [updateSize]);
+    return 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;
+};
+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 }));
+});
+
+const isCorsError = (error) => {
+    return (
+    // Chrome
+    error.message.includes('Failed to fetch') ||
+        // Safari
+        error.message.includes('Load failed') ||
+        // Firefox
+        error.message.includes('NetworkError when attempting to fetch resource'));
+};
+
+const resolveGifSource = (src) => {
+    return new URL(src, typeof window === 'undefined' ? undefined : window.location.origin).href;
+};
+
+function useCurrentGifIndex(delays, loopBehavior) {
+    const currentFrame = useCurrentFrame();
+    const videoConfig = useVideoConfig();
+    const duration = useMemo(() => {
+        if (delays.length !== 0) {
+            return delays.reduce((sum, delay) => sum + (delay !== null && delay !== void 0 ? delay : 0), 0);
+        }
+        return 1;
+    }, [delays]);
+    if (delays.length === 0) {
+        return 0;
+    }
+    const time = (currentFrame / videoConfig.fps) * 1000;
+    if (loopBehavior === 'pause-after-finish' && time >= duration) {
+        return delays.length - 1;
+    }
+    if (loopBehavior === 'unmount-after-finish' && time >= duration) {
+        return -1;
+    }
+    let currentTime = time % duration;
+    for (let i = 0; i < delays.length; i++) {
+        const delay = delays[i];
+        if (currentTime < delay) {
+            return i;
+        }
+        currentTime -= delay;
+    }
+    return 0;
+}
+
+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 }));
+});
+
+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 }));
+});
+
+/**
+ * @description Displays a GIF that synchronizes with Remotions useCurrentFrame().
+ * @see [Documentation](https://www.remotion.dev/docs/gif/gif)
+ */
+const Gif = forwardRef((props, ref) => {
+    const env = Internals.useRemotionEnvironment();
+    if (env === 'rendering') {
+        return jsx(GifForRendering, { ...props, ref: ref });
+    }
+    return jsx(GifForDevelopment, { ...props, ref: ref });
+});
+
+/**
+ * @description Returns an object with two entries: waitUntilDone() that returns a Promise which can be awaited and free() which will cancel preloading or free up the memory if the GIF is not being used anymore.
+ * @see [Documentation](https://www.remotion.dev/docs/gif/preload-gif)
+ */
+const preloadGif = (src) => {
+    const resolvedSrc = resolveGifSource(src);
+    if (volatileGifCache.has(resolvedSrc)) {
+        return {
+            waitUntilDone: () => Promise.resolve(),
+            free: () => volatileGifCache.delete(resolvedSrc),
+        };
+    }
+    if (manuallyManagedGifCache.has(resolvedSrc)) {
+        return {
+            waitUntilDone: () => Promise.resolve(),
+            free: () => manuallyManagedGifCache.delete(resolvedSrc),
+        };
+    }
+    const { prom, cancel } = parseWithWorker(resolvedSrc);
+    let deleted = false;
+    prom.then((p) => {
+        if (!deleted) {
+            manuallyManagedGifCache.set(resolvedSrc, p);
+        }
+    });
+    return {
+        waitUntilDone: () => prom.then(() => undefined),
+        free: () => {
+            cancel();
+            deleted = true;
+            manuallyManagedGifCache.delete(resolvedSrc);
+        },
+    };
+};
+
+export { Gif, getGifDurationInSeconds, preloadGif };