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

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[];
+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/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 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;
+}

package/dist/cjs/lru/index.js

@@ -0,0 +1,258 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuickLRU = void 0;
+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);
+    }
+}
+exports.QuickLRU = QuickLRU;

package/dist/{parse-generate.d.ts → cjs/parse-generate.d.ts}

@@ -8,7 +8,7 @@ export declare const parse: (src: string, { signal, }: {
     width: number;
     height: number;
 }>;
-declare type ParserCallbackArgs = {
+type ParserCallbackArgs = {
     width: number;
     height: number;
     delays: number[];