@remotion/gif 4.1.0-alpha10 → 4.1.0-alpha12

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

@@ -0,0 +1,9 @@
+export 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'));
+};

package/.rollup.cache/Users/jonathanburger/remotion/packages/gif/dist/esm/js-binary-schema-parser/gif.d.ts

@@ -0,0 +1,51 @@
+import type { ParsedGif } from '../gifuct/types';
+import type { Stream } from './uint8-parser';
+export declare const GIF: (((stream: Stream, result: ParsedGif, parent: ParsedGif, parseFn: (st: Stream, schema: unknown, result: ParsedGif, parent: ParsedGif) => void) => void) | {
+    header: ({
+        signature: (stream: Stream) => string;
+        version?: undefined;
+    } | {
+        version: (stream: Stream) => string;
+        signature?: undefined;
+    })[];
+    lsd?: undefined;
+    frames?: undefined;
+} | {
+    lsd: ({
+        width: (stream: Stream) => number;
+        height?: undefined;
+        gct?: undefined;
+        backgroundColorIndex?: undefined;
+        pixelAspectRatio?: undefined;
+    } | {
+        height: (stream: Stream) => number;
+        width?: undefined;
+        gct?: undefined;
+        backgroundColorIndex?: undefined;
+        pixelAspectRatio?: undefined;
+    } | {
+        gct: (stream: Stream) => Record<string, number | boolean>;
+        width?: undefined;
+        height?: undefined;
+        backgroundColorIndex?: undefined;
+        pixelAspectRatio?: undefined;
+    } | {
+        backgroundColorIndex: (stream: Stream) => number;
+        width?: undefined;
+        height?: undefined;
+        gct?: undefined;
+        pixelAspectRatio?: undefined;
+    } | {
+        pixelAspectRatio: (stream: Stream) => number;
+        width?: undefined;
+        height?: undefined;
+        gct?: undefined;
+        backgroundColorIndex?: undefined;
+    })[];
+    header?: undefined;
+    frames?: undefined;
+} | {
+    frames: (stream: Stream, result: unknown, parent: unknown, _parse: (st: Stream, schema: unknown, result: unknown, parent: unknown) => void) => unknown[];
+    header?: undefined;
+    lsd?: undefined;
+})[];

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

@@ -0,0 +1,155 @@
+import { conditional, loop } from './parser';
+import { peekByte, peekBytes, readArray, readBits, readByte, readBytes, readString, readUnsigned, } from './uint8-parser';
+// 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;
+});
+export 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;
+        }),
+    },
+];

package/.rollup.cache/Users/jonathanburger/remotion/packages/gif/dist/esm/js-binary-schema-parser/parser.d.ts

@@ -0,0 +1,9 @@
+import type { ParsedGif } from '../gifuct/types';
+import type { Stream } from './uint8-parser';
+export declare const parse: <T extends Record<string, T>>(stream: Stream, schema: GifSchema, result?: T, parent?: T) => GifSchema;
+export declare const loop: <R>(schema: GifSchema, continueFunc: (st: Stream, r: R, p: R) => boolean) => (stream: Stream, result: R, parent: R, _parse: ParseFn<R>) => R[];
+type ConditionalFunction<T> = (st: Stream, result: T, parent: T) => boolean;
+type ParseFn<T> = (st: Stream, schema: GifSchema, result: T, parent: T) => void;
+export type GifSchema = unknown | ParsedGif;
+export declare const conditional: <T>(schema: GifSchema, conditionFunc: ConditionalFunction<T>) => (stream: Stream, result: T, parent: T, parseFn: ParseFn<T>) => void;
+export {};

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

@@ -0,0 +1,48 @@
+export const parse = (stream, schema, result = {}, parent = result) => {
+    if (Array.isArray(schema)) {
+        schema.forEach((partSchema) => {
+            return parse(stream, partSchema, result, parent);
+        });
+    }
+    else if (typeof schema === 'function') {
+        schema(stream, result, parent, parse);
+    }
+    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(stream, schema[key], result, parent[key]);
+        }
+        else {
+            // @ts-expect-error
+            parent[key] = schema[key](stream, result, parent, parse);
+        }
+    }
+    return result;
+};
+export 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;
+    };
+};
+export const conditional = (schema, conditionFunc) => (stream, result, parent, parseFn) => {
+    if (conditionFunc(stream, result, parent)) {
+        parseFn(stream, schema, result, parent);
+    }
+};

package/.rollup.cache/Users/jonathanburger/remotion/packages/gif/dist/esm/js-binary-schema-parser/uint8-parser.d.ts

@@ -0,0 +1,17 @@
+import type { GifSchema } from './parser';
+export type Stream = {
+    data: Uint8Array;
+    pos: number;
+};
+export declare const buildStream: (uint8Data: Uint8Array) => {
+    data: Uint8Array;
+    pos: number;
+};
+export declare const readByte: () => (stream: Stream) => number;
+export declare const peekByte: (offset?: number) => (stream: Stream) => number;
+export declare const readBytes: (length: number) => (stream: Stream) => Uint8Array;
+export declare const peekBytes: (length: number) => (stream: Stream) => Uint8Array;
+export declare const readString: (length: number) => (stream: Stream) => string;
+export declare const readUnsigned: (littleEndian: boolean) => (stream: Stream) => number;
+export declare const readArray: <T>(byteSize: number, totalOrFunc: number | ((st: Stream, r: T, p: T) => number)) => (stream: Stream, result: T, parent: T) => any[];
+export declare const readBits: (schema: GifSchema) => (stream: Stream) => Record<string, number | boolean>;

package/.rollup.cache/Users/jonathanburger/remotion/packages/gif/dist/esm/js-binary-schema-parser/uint8-parser.js

@@ -0,0 +1,67 @@
+/* eslint-disable no-bitwise */
+// Default stream and parsers for Uint8TypedArray data type
+export const buildStream = (uint8Data) => ({
+    data: uint8Data,
+    pos: 0,
+});
+export const readByte = () => (stream) => {
+    return stream.data[stream.pos++];
+};
+export const peekByte = (offset = 0) => (stream) => {
+    return stream.data[stream.pos + offset];
+};
+export const readBytes = (length) => (stream) => {
+    // eslint-disable-next-line no-return-assign
+    return stream.data.subarray(stream.pos, (stream.pos += length));
+};
+export const peekBytes = (length) => (stream) => {
+    return stream.data.subarray(stream.pos, stream.pos + length);
+};
+export const readString = (length) => (stream) => {
+    return Array.from(readBytes(length)(stream))
+        .map((value) => String.fromCharCode(value))
+        .join('');
+};
+export const readUnsigned = (littleEndian) => (stream) => {
+    const bytes = readBytes(2)(stream);
+    return littleEndian ? (bytes[1] << 8) + bytes[0] : (bytes[0] << 8) + bytes[1];
+};
+export 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;
+};
+export 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;
+    }, {});
+};

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

@@ -0,0 +1,101 @@
+export interface Options<KeyType, ValueType> {
+    /**
+    The maximum number of milliseconds an item should remain in the cache.
+
+    @default Infinity
+
+    By default, `maxAge` will be `Infinity`, which means that items will never expire.
+    Lazy expiration upon the next write or read call.
+
+    Individual expiration of an item can be specified by the `set(key, value, maxAge)` method.
+    */
+    readonly maxAge?: number;
+    /**
+    The maximum number of items before evicting the least recently used items.
+    */
+    readonly maxSize: number;
+    /**
+    Called right before an item is evicted from the cache.
+
+    Useful for side effects or for items like object URLs that need explicit cleanup (`revokeObjectURL`).
+    */
+    onEviction?: (key: KeyType, value: ValueType) => void;
+}
+export declare class QuickLRU<KeyType, ValueType> implements Iterable<[KeyType, ValueType]> {
+    /**
+    The maximum number of milliseconds an item should remain in the cache.
+
+    @default Infinity
+
+    By default, `maxAge` will be `Infinity`, which means that items will never expire.
+    Lazy expiration upon the next write or read call.
+
+    Individual expiration of an item can be specified by the `set(key, value, maxAge)` method.
+    */
+    maxAge: number;
+    /**
+    The maximum number of items before evicting the least recently used items.
+    */
+    maxSize: number;
+    /**
+    Called right before an item is evicted from the cache.
+
+    Useful for side effects or for items like object URLs that need explicit cleanup (`revokeObjectURL`).
+    */
+    onEviction?: (key: KeyType, value: ValueType) => void;
+    private _size;
+    private cache;
+    private oldCache;
+    /**
+    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: Options<KeyType, ValueType>);
+    private _emitEvictions;
+    private _deleteIfExpired;
+    private _getOrDeleteIfExpired;
+    private _getItemValue;
+    private _peek;
+    private _set;
+    private _moveToRecent;
+    private _entriesAscending;
+    /**
+    Get an item.
+
+    @returns The stored item or `undefined`.
+    */
+    get(key: KeyType): ValueType | undefined;
+    set(key: KeyType, value: ValueType, { maxAge }?: {
+        maxAge?: number;
+    }): void;
+    has(key: KeyType): boolean;
+    peek(key: KeyType): ValueType | undefined;
+    delete(key: KeyType): boolean;
+    clear(): void;
+    resize(maxSize: number): void;
+    keys(): Generator<KeyType, void, unknown>;
+    values(): Generator<ValueType, void, unknown>;
+    [Symbol.iterator](): IterableIterator<[KeyType, ValueType]>;
+    /**
+    Iterable for all entries, starting with the newest (descending in recency).
+    */
+    entriesDescending(): IterableIterator<[KeyType, ValueType]>;
+    entriesAscending(): Generator<(KeyType | ValueType)[], void, unknown>;
+    get size(): number;
+}