@remotion/gif 3.3.62 → 3.3.64

package/dist/{gif-cache.d.ts → cjs/gif-cache.d.ts}

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

package/dist/{gif-cache.js → cjs/gif-cache.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.manuallyManagedGifCache = exports.volatileGifCache = void 0;
-const lru_map_1 = require("lru_map");
-exports.volatileGifCache = new lru_map_1.LRUMap(30);
+const index_1 = require("./lru/index");
+exports.volatileGifCache = new index_1.QuickLRU({ maxSize: 30 });
 exports.manuallyManagedGifCache = new Map();

package/dist/{gifuct → cjs/gifuct}/index.d.ts

@@ -1,4 +1,4 @@
 import type { Frame, ParsedFrameWithoutPatch, ParsedGif } from './types';
-export declare const parseGIF: (arrayBuffer: ArrayBuffer) => any;
+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/dist/{gifuct → cjs/gifuct}/index.js

@@ -1,20 +1,14 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.decompressFrames = exports.decompressFrame = exports.parseGIF = void 0;
-// @ts-expect-error
-const js_binary_schema_parser_1 = require("js-binary-schema-parser");
-// @ts-expect-error
-const uint8_1 = require("js-binary-schema-parser/lib/parsers/uint8");
-// @ts-expect-error
-const gif_1 = __importDefault(require("js-binary-schema-parser/lib/schemas/gif"));
+const gif_1 = require("../js-binary-schema-parser/gif");
+const parser_1 = require("../js-binary-schema-parser/parser");
+const uint8_parser_1 = require("../js-binary-schema-parser/uint8-parser");
 const deinterlace_1 = require("./deinterlace");
 const lzw_1 = require("./lzw");
 const parseGIF = (arrayBuffer) => {
     const byteData = new Uint8Array(arrayBuffer);
-    return (0, js_binary_schema_parser_1.parse)((0, uint8_1.buildStream)(byteData), gif_1.default);
+    return (0, parser_1.parse)((0, uint8_parser_1.buildStream)(byteData), gif_1.GIF);
 };
 exports.parseGIF = parseGIF;
 const decompressFrame = (frame, gct) => {

package/dist/{gifuct → cjs/gifuct}/types.d.ts

@@ -4,7 +4,7 @@ declare type Dimensions = {
     width: number;
     height: number;
 };
-declare type Application = {
+export declare type Application = {
     application: {
         blockSize: number;
         blocks: number[];

package/dist/cjs/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/dist/cjs/js-binary-schema-parser/gif.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GIF = void 0;
+const parser_1 = require("./parser");
+const uint8_parser_1 = require("./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 = (0, uint8_parser_1.readByte)()(stream); size !== terminator; size = (0, uint8_parser_1.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((0, uint8_parser_1.readBytes)(availableSize)(stream));
+                total += availableSize;
+                break;
+            }
+            chunks.push((0, uint8_parser_1.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 = (0, parser_1.conditional)({
+    gce: [
+        { codes: (0, uint8_parser_1.readBytes)(2) },
+        { byteSize: (0, uint8_parser_1.readByte)() },
+        {
+            extras: (0, uint8_parser_1.readBits)({
+                future: { index: 0, length: 3 },
+                disposal: { index: 3, length: 3 },
+                userInput: { index: 6 },
+                transparentColorGiven: { index: 7 },
+            }),
+        },
+        { delay: (0, uint8_parser_1.readUnsigned)(true) },
+        { transparentColorIndex: (0, uint8_parser_1.readByte)() },
+        { terminator: (0, uint8_parser_1.readByte)() },
+    ],
+}, (stream) => {
+    const codes = (0, uint8_parser_1.peekBytes)(2)(stream);
+    return codes[0] === 0x21 && codes[1] === 0xf9;
+});
+// image pipeline block
+const imageSchema = (0, parser_1.conditional)({
+    image: [
+        { code: (0, uint8_parser_1.readByte)() },
+        {
+            descriptor: [
+                { left: (0, uint8_parser_1.readUnsigned)(true) },
+                { top: (0, uint8_parser_1.readUnsigned)(true) },
+                { width: (0, uint8_parser_1.readUnsigned)(true) },
+                { height: (0, uint8_parser_1.readUnsigned)(true) },
+                {
+                    lct: (0, uint8_parser_1.readBits)({
+                        exists: { index: 0 },
+                        interlaced: { index: 1 },
+                        sort: { index: 2 },
+                        future: { index: 3, length: 2 },
+                        size: { index: 5, length: 3 },
+                    }),
+                },
+            ],
+        },
+        (0, parser_1.conditional)({
+            lct: (0, uint8_parser_1.readArray)(3, (_stream, _result, parent) => {
+                return 2 ** (parent.descriptor.lct.size + 1);
+            }),
+        }, (_stream, _result, parent) => {
+            return parent.descriptor.lct.exists;
+        }),
+        { data: [{ minCodeSize: (0, uint8_parser_1.readByte)() }, subBlocksSchema] },
+    ],
+}, (stream) => {
+    return (0, uint8_parser_1.peekByte)()(stream) === 0x2c;
+});
+// plain text block
+const textSchema = (0, parser_1.conditional)({
+    text: [
+        { codes: (0, uint8_parser_1.readBytes)(2) },
+        { blockSize: (0, uint8_parser_1.readByte)() },
+        {
+            preData: (stream, _result, parent) => (0, uint8_parser_1.readBytes)(parent.text.blockSize)(stream),
+        },
+        subBlocksSchema,
+    ],
+}, (stream) => {
+    const codes = (0, uint8_parser_1.peekBytes)(2)(stream);
+    return codes[0] === 0x21 && codes[1] === 0x01;
+});
+// application block
+const applicationSchema = (0, parser_1.conditional)({
+    application: [
+        { codes: (0, uint8_parser_1.readBytes)(2) },
+        { blockSize: (0, uint8_parser_1.readByte)() },
+        {
+            id: (stream, _result, parent) => (0, uint8_parser_1.readString)(parent.blockSize)(stream),
+        },
+        subBlocksSchema,
+    ],
+}, (stream) => {
+    const codes = (0, uint8_parser_1.peekBytes)(2)(stream);
+    return codes[0] === 0x21 && codes[1] === 0xff;
+});
+// comment block
+const commentSchema = (0, parser_1.conditional)({
+    comment: [{ codes: (0, uint8_parser_1.readBytes)(2) }, subBlocksSchema],
+}, (stream) => {
+    const codes = (0, uint8_parser_1.peekBytes)(2)(stream);
+    return codes[0] === 0x21 && codes[1] === 0xfe;
+});
+exports.GIF = [
+    { header: [{ signature: (0, uint8_parser_1.readString)(3) }, { version: (0, uint8_parser_1.readString)(3) }] },
+    {
+        lsd: [
+            { width: (0, uint8_parser_1.readUnsigned)(true) },
+            { height: (0, uint8_parser_1.readUnsigned)(true) },
+            {
+                gct: (0, uint8_parser_1.readBits)({
+                    exists: { index: 0 },
+                    resolution: { index: 1, length: 3 },
+                    sort: { index: 4 },
+                    size: { index: 5, length: 3 },
+                }),
+            },
+            { backgroundColorIndex: (0, uint8_parser_1.readByte)() },
+            { pixelAspectRatio: (0, uint8_parser_1.readByte)() },
+        ],
+    },
+    (0, parser_1.conditional)({
+        gct: (0, uint8_parser_1.readArray)(3, (_stream, result) => 2 ** (result.lsd.gct.size + 1)),
+    }, (_stream, result) => result.lsd.gct.exists),
+    // content frames
+    {
+        frames: (0, parser_1.loop)([gceSchema, applicationSchema, commentSchema, imageSchema, textSchema], (stream) => {
+            const nextCode = (0, uint8_parser_1.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/dist/cjs/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[];
+declare type ConditionalFunction<T> = (st: Stream, result: T, parent: T) => boolean;
+declare type ParseFn<T> = (st: Stream, schema: GifSchema, result: T, parent: T) => void;
+export declare 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/dist/cjs/js-binary-schema-parser/parser.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.conditional = exports.loop = exports.parse = void 0;
+const parse = (stream, schema, result = {}, parent = result) => {
+    if (Array.isArray(schema)) {
+        schema.forEach((partSchema) => {
+            return (0, exports.parse)(stream, partSchema, result, parent);
+        });
+    }
+    else if (typeof schema === 'function') {
+        schema(stream, result, parent, exports.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
+            (0, exports.parse)(stream, schema[key], result, parent[key]);
+        }
+        else {
+            // @ts-expect-error
+            parent[key] = schema[key](stream, result, parent, exports.parse);
+        }
+    }
+    return result;
+};
+exports.parse = parse;
+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;
+    };
+};
+exports.loop = loop;
+const conditional = (schema, conditionFunc) => (stream, result, parent, parseFn) => {
+    if (conditionFunc(stream, result, parent)) {
+        parseFn(stream, schema, result, parent);
+    }
+};
+exports.conditional = conditional;

package/dist/cjs/js-binary-schema-parser/uint8-parser.d.ts

@@ -0,0 +1,17 @@
+import type { GifSchema } from './parser';
+export declare 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/dist/cjs/js-binary-schema-parser/uint8-parser.js

@@ -0,0 +1,79 @@
+"use strict";
+/* eslint-disable no-bitwise */
+// Default stream and parsers for Uint8TypedArray data type
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readBits = exports.readArray = exports.readUnsigned = exports.readString = exports.peekBytes = exports.readBytes = exports.peekByte = exports.readByte = exports.buildStream = void 0;
+const buildStream = (uint8Data) => ({
+    data: uint8Data,
+    pos: 0,
+});
+exports.buildStream = buildStream;
+const readByte = () => (stream) => {
+    return stream.data[stream.pos++];
+};
+exports.readByte = readByte;
+const peekByte = (offset = 0) => (stream) => {
+    return stream.data[stream.pos + offset];
+};
+exports.peekByte = peekByte;
+const readBytes = (length) => (stream) => {
+    // eslint-disable-next-line no-return-assign
+    return stream.data.subarray(stream.pos, (stream.pos += length));
+};
+exports.readBytes = readBytes;
+const peekBytes = (length) => (stream) => {
+    return stream.data.subarray(stream.pos, stream.pos + length);
+};
+exports.peekBytes = peekBytes;
+const readString = (length) => (stream) => {
+    return Array.from((0, exports.readBytes)(length)(stream))
+        .map((value) => String.fromCharCode(value))
+        .join('');
+};
+exports.readString = readString;
+const readUnsigned = (littleEndian) => (stream) => {
+    const bytes = (0, exports.readBytes)(2)(stream);
+    return littleEndian ? (bytes[1] << 8) + bytes[0] : (bytes[0] << 8) + bytes[1];
+};
+exports.readUnsigned = readUnsigned;
+const readArray = (byteSize, totalOrFunc) => (stream, result, parent) => {
+    const total = typeof totalOrFunc === 'function'
+        ? totalOrFunc(stream, result, parent)
+        : totalOrFunc;
+    const parser = (0, exports.readBytes)(byteSize);
+    const arr = new Array(total);
+    for (let i = 0; i < total; i++) {
+        arr[i] = parser(stream);
+    }
+    return arr;
+};
+exports.readArray = readArray;
+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 = (0, exports.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;
+    }, {});
+};
+exports.readBits = readBits;

package/dist/cjs/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;
+}