wtfgif 1.2.0

package/dist/native/oneOff.d.ts

@@ -0,0 +1 @@
+export { decodeGifFramesRgba, remuxGifPixelPerfect, reencodeGifPixelPerfect, } from "./runtime";

package/dist/native/runtime.d.ts

@@ -0,0 +1,27 @@
+import type { WasmCoreModule } from "../types";
+export interface NativeDecodedRgbaFrames {
+    width: number;
+    height: number;
+    frameCount: number;
+    pixels: Uint8Array;
+}
+export interface NativeAddonModule {
+    decodeFramesRgba: (gifData: Uint8Array) => NativeDecodedRgbaFrames;
+    encodeIndexedFast: (indexedFrames: Uint8Array, width: number, height: number, frameCount: number, palette: Uint32Array, delays: Uint16Array, loopCount: number, delta: boolean) => Uint8Array;
+    encodeRgbaFast: (rgbaFrames: Uint8Array, width: number, height: number, frameCount: number, palette: Uint32Array, delays: Uint16Array, loopCount: number, delta: boolean) => Uint8Array;
+    reencodeGifFast: (gifData: Uint8Array) => Uint8Array;
+}
+export declare function decodeGifFramesRgba(gifData: Uint8Array): NativeDecodedRgbaFrames;
+export declare function reencodeGifPixelPerfect(gifData: Uint8Array): Uint8Array;
+export declare let remuxGifPixelPerfect: (gifData: Uint8Array) => Uint8Array;
+export declare function prepareWasmOneOffApi(module: WasmCoreModule | null): void;
+export declare function setNativeAddonModule(module: NativeAddonModule | null): void;
+export declare function getNativeAddonModule(): NativeAddonModule | null;
+export declare function getNativeAddonStatus(): {
+    name: string;
+    available: boolean;
+};
+export declare function getFastBackendStatus(): {
+    name: "wtfgif-rust-native" | "wtfgif-rust-wasm" | null;
+    available: boolean;
+};

package/dist/types.d.ts

@@ -0,0 +1,171 @@
+export interface WasmCoreInstance {
+    width: () => number;
+    height: () => number;
+    frame_count: () => number;
+    metadata_json: () => string;
+    decode_frame_indices: (frameIndex: number) => Uint8Array;
+    decode_frame_rgba: (frameIndex: number) => Uint8Array;
+    decode_frame_bgra: (frameIndex: number) => Uint8Array;
+    decode_all_rgba?: () => Uint32Array;
+    reencode_gif_pixel_perfect?: () => Uint8Array;
+    prepare_composited_rgba: (requestedFrames: Uint8Array) => Uint32Array;
+    prepare_composited_bgra: (requestedFrames: Uint8Array) => Uint32Array;
+    prepare_composited_delta_rgba: (requestedFrames: Uint8Array) => Uint32Array;
+    prepare_composited_delta_bgra: (requestedFrames: Uint8Array) => Uint32Array;
+    free: () => void;
+}
+export interface WasmCoreModule {
+    WtfGifCore: new (data: Uint8Array) => WasmCoreInstance;
+    core_version?: () => string;
+    parse_metadata_json?: (data: Uint8Array) => string;
+    decode_frame_indices?: (data: Uint8Array, frameIndex: number) => Uint8Array;
+    decode_frame_rgba?: (data: Uint8Array, frameIndex: number) => Uint8Array;
+    decode_frame_bgra?: (data: Uint8Array, frameIndex: number) => Uint8Array;
+    decode_all_rgba?: (data: Uint8Array) => Uint32Array;
+    reencode_gif_pixel_perfect?: (data: Uint8Array) => Uint8Array;
+    remux_gif_pixel_perfect?: (data: Uint8Array) => Uint8Array;
+    prepare_reencode_hot_path?: () => void;
+    reencode_hot_path_primer?: (side: number, frameCount: number) => Uint8Array;
+    remux_hot_path_primer?: () => Uint8Array;
+    prepare_composited_rgba?: (data: Uint8Array, requestedFrames: Uint8Array) => Uint32Array;
+    prepare_composited_bgra?: (data: Uint8Array, requestedFrames: Uint8Array) => Uint32Array;
+    prepare_composited_delta_rgba?: (data: Uint8Array, requestedFrames: Uint8Array) => Uint32Array;
+    prepare_composited_delta_bgra?: (data: Uint8Array, requestedFrames: Uint8Array) => Uint32Array;
+    encode_indexed_lzw?: (indexStream: Uint8Array, minCodeSize: number, colorCount: number) => Uint8Array;
+    encode_indexed_gif?: (indexStream: Uint8Array, width: number, height: number, frameCount: number, paletteRgb: Uint32Array, delay: number, loopCount: number) => Uint8Array;
+    encode_indexed_gif_with_delays?: (indexStream: Uint8Array, width: number, height: number, frameCount: number, paletteRgb: Uint32Array, delays: Uint16Array, loopCount: number) => Uint8Array;
+    encode_indexed_literal_gif?: (indexStream: Uint8Array, width: number, height: number, frameCount: number, paletteRgb: Uint32Array, delay: number, loopCount: number) => Uint8Array;
+    encode_indexed_literal_gif_with_delays?: (indexStream: Uint8Array, width: number, height: number, frameCount: number, paletteRgb: Uint32Array, delays: Uint16Array, loopCount: number) => Uint8Array;
+    encode_indexed_literal_delta_gif?: (indexStream: Uint8Array, width: number, height: number, frameCount: number, paletteRgb: Uint32Array, delay: number, loopCount: number) => Uint8Array;
+    encode_indexed_literal_delta_gif_with_delays?: (indexStream: Uint8Array, width: number, height: number, frameCount: number, paletteRgb: Uint32Array, delays: Uint16Array, loopCount: number) => Uint8Array;
+    encode_indexed_delta_gif?: (indexStream: Uint8Array, width: number, height: number, frameCount: number, paletteRgb: Uint32Array, delay: number, loopCount: number) => Uint8Array;
+    encode_indexed_delta_gif_with_delays?: (indexStream: Uint8Array, width: number, height: number, frameCount: number, paletteRgb: Uint32Array, delays: Uint16Array, loopCount: number) => Uint8Array;
+    encode_rgba_gif?: (rgbaStream: Uint8Array, width: number, height: number, frameCount: number, paletteRgb: Uint32Array, delay: number, loopCount: number, deltas: boolean) => Uint8Array;
+    encode_rgba_gif_with_options?: (rgbaStream: Uint8Array, width: number, height: number, frameCount: number, paletteRgb: Uint32Array, delays: Uint16Array, loopCount: number, deltas: boolean, alphaThreshold: number) => Uint8Array;
+    encode_rgba_literal_gif?: (rgbaStream: Uint8Array, width: number, height: number, frameCount: number, paletteRgb: Uint32Array, delay: number, loopCount: number) => Uint8Array;
+    encode_rgba_literal_gif_with_options?: (rgbaStream: Uint8Array, width: number, height: number, frameCount: number, paletteRgb: Uint32Array, delays: Uint16Array, loopCount: number, alphaThreshold: number) => Uint8Array;
+    encode_rgba_literal_delta_gif?: (rgbaStream: Uint8Array, width: number, height: number, frameCount: number, paletteRgb: Uint32Array, delay: number, loopCount: number) => Uint8Array;
+    encode_rgba_literal_delta_gif_with_options?: (rgbaStream: Uint8Array, width: number, height: number, frameCount: number, paletteRgb: Uint32Array, delays: Uint16Array, loopCount: number, alphaThreshold: number) => Uint8Array;
+}
+export interface PooledDecoderTables {
+    decTable: Int32Array;
+    stack: Uint8Array;
+    firstByte: Int16Array;
+}
+/**
+ * The byte-container contract used by omggif.
+ *
+ * Arrays, Uint8Array instances, and Node Buffers all satisfy this interface.
+ */
+export interface GifBinary {
+    readonly length: number;
+    [index: number]: number;
+}
+export type GifPixelBuffer = number[] | Uint8Array | Uint8ClampedArray;
+export type PaletteRGB = number[];
+export interface GifOptions {
+    background?: number;
+    loop?: number | null;
+    palette?: PaletteRGB | null;
+}
+export interface FrameOptions {
+    delay?: number;
+    disposal?: number;
+    palette?: PaletteRGB | null;
+    transparent?: number | null;
+}
+export type PreparedFrameFormat = "rgba" | "bgra";
+export type PreparedFrameCacheMode = "auto" | "indices" | "rgba" | "sparse-rgba" | "composited";
+export type PreparedFrameBackendPreference = "auto" | "javascript" | "native";
+export type PreparedFrameDedupeMode = "none" | "adjacent" | "all";
+export interface PrepareFramesOptions {
+    format?: PreparedFrameFormat;
+    composited?: boolean;
+    cache?: PreparedFrameCacheMode;
+    frameIndices?: readonly number[];
+    maxBytes?: number;
+    backend?: PreparedFrameBackendPreference;
+    deltas?: boolean;
+    dedupe?: PreparedFrameDedupeMode;
+}
+export interface PreparedGifFrame {
+    index: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    delay: number;
+    disposal: number;
+    byteLength: number;
+    isFullCanvas: boolean;
+    changedX?: number;
+    changedY?: number;
+    changedWidth?: number;
+    changedHeight?: number;
+    changedPixels?: Uint32Array | undefined;
+    pixels?: Uint32Array;
+    colors?: Uint32Array;
+    spans?: Uint32Array;
+    positions?: Uint32Array;
+    indices?: Uint8Array;
+    palette?: Uint32Array;
+}
+export interface PreparedGifFrames {
+    width: number;
+    height: number;
+    format: PreparedFrameFormat;
+    composited: boolean;
+    frames: PreparedGifFrame[];
+    byteLength: number;
+    maxBytes: number | null;
+    getFrame: (index: number) => PreparedGifFrame | undefined;
+    getFramePixels: (index: number) => Uint32Array | undefined;
+    getFrameBytes: (index: number) => Uint8Array | undefined;
+    copyFrame: (index: number, target: Uint8Array | Uint32Array) => void;
+    createPlayer: (target?: Uint8Array | Uint32Array) => PreparedGifPlayer;
+    dispose: () => void;
+}
+export interface PreparedGifPlayer {
+    target: Uint32Array;
+    currentIndex: number;
+    drawFrame: (index: number) => Uint32Array;
+    next: () => Uint32Array;
+    reset: () => void;
+}
+export interface GifDecodeBackendStatus {
+    name: string;
+    available: boolean;
+}
+export interface GifDecodeBackend {
+    name: string;
+    isAvailable: () => boolean;
+    prepareFrames?: (gifData: Uint8Array, options: Required<Pick<PrepareFramesOptions, "format" | "composited">> & PrepareFramesOptions) => PreparedGifFrames | null;
+}
+/** Frame metadata compatible with omggif's public Frame type. */
+export interface Frame {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    has_local_palette: boolean;
+    palette_offset: number | null;
+    palette_size: number | null;
+    data_offset: number;
+    data_length: number;
+    transparent_index: number | null;
+    interlaced: boolean;
+    delay: number;
+    disposal: number;
+}
+export type FrameInfo = Frame & {
+    min_code_size: number;
+    codes?: Uint8Array;
+    indices?: Uint8Array;
+    pal32rgba?: Uint32Array;
+    pal32bgra?: Uint32Array;
+    rgbaColors?: Uint32Array;
+    bgraColors?: Uint32Array;
+    opaqueSpans?: Uint32Array;
+    opaquePositions?: Uint32Array;
+    decodeCount?: number;
+};

package/dist/utils/netscape.d.ts

@@ -0,0 +1,16 @@
+import { GifBinary } from "../types";
+export declare const NETSCAPE_APPLICATION_ID: Uint8Array<ArrayBuffer>;
+/**
+ * Write a Netscape loop count application extension to the buffer.
+ * Returns the new buffer position after the extension.
+ */
+export declare function writeNetscapeLoopCount(buf: GifBinary, p: number, loopCount: number): number;
+/**
+ * Attempt to read a Netscape loop count application extension starting
+ * at the given position. If the extension matches, returns the loop count
+ * and the next buffer position; otherwise returns null.
+ */
+export declare function readNetscapeLoopCount(buf: Uint8Array, p: number): {
+    loopCount: number;
+    nextPos: number;
+} | null;

package/dist/utils/palette.d.ts

@@ -0,0 +1,4 @@
+import { PaletteRGB } from "../types";
+export declare function log2Pow2(n: number): number;
+export declare function checkPalette(pal: PaletteRGB): number;
+export declare function buildPal32(buf: Uint8Array, paletteOffset: number, paletteSize: number, order: "rgba" | "bgra", transparentIndex?: number | null): Uint32Array;

package/dist/utils/subblocks.d.ts

@@ -0,0 +1,4 @@
+export declare function concatSubBlocks(buf: Uint8Array, offset: number): {
+    bytes: Uint8Array;
+    mcs: number;
+};

package/dist/wasm/coreBackend.d.ts

@@ -0,0 +1,2 @@
+import { GifDecodeBackend } from "../types";
+export declare function createWasmCoreDecodeBackend(): GifDecodeBackend;

package/dist/wasm/runtime.d.ts

@@ -0,0 +1,24 @@
+import { WasmCoreModule } from "../types";
+export type WasmWebModule = WasmCoreModule & {
+    default?: (moduleOrPath?: unknown) => Promise<unknown>;
+};
+export declare function setWasmCoreModule(module: WasmCoreModule | null): void;
+export declare function getWasmCoreModule(): WasmCoreModule | null;
+export declare const initializeGlobalWasm: (moduleOrPath?: unknown) => Promise<void>;
+export declare function initializeWasmModule(module: WasmWebModule, moduleOrPath?: unknown): Promise<void>;
+export declare function getWasmFeatures(): {
+    supported: boolean;
+    simd: boolean;
+    threads: boolean;
+};
+export declare function getWasmStatus(): {
+    supported: boolean;
+    simd: boolean;
+    threads: boolean;
+    initialized: boolean;
+    workerPoolAvailable: boolean;
+};
+export declare function getWasmInitPromise(): Promise<void> | null;
+export declare function setWasmInitPromise(promise: Promise<void> | null): void;
+export declare function isWasmReady(): boolean;
+export declare function cleanupWasm(): void;

package/dist/wasm-core/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/wasm-core/wtfgif_core.d.ts

@@ -0,0 +1,81 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export class WtfGifCore {
+    free(): void;
+    [Symbol.dispose](): void;
+    decode_all_rgba(): Uint32Array;
+    decode_frame_bgra(frame_index: number): Uint8Array;
+    decode_frame_indices(frame_index: number): Uint8Array;
+    decode_frame_rgba(frame_index: number): Uint8Array;
+    frame_count(): number;
+    height(): number;
+    metadata_json(): string;
+    constructor(data: Uint8Array);
+    prepare_composited_bgra(requested_frames: Uint8Array): Uint32Array;
+    prepare_composited_delta_bgra(requested_frames: Uint8Array): Uint32Array;
+    prepare_composited_delta_rgba(requested_frames: Uint8Array): Uint32Array;
+    prepare_composited_rgba(requested_frames: Uint8Array): Uint32Array;
+    reencode_gif_pixel_perfect(): Uint8Array;
+    width(): number;
+}
+
+export function core_version(): string;
+
+export function decode_all_rgba(data: Uint8Array): Uint32Array;
+
+export function decode_frame_bgra(data: Uint8Array, frame_index: number): Uint8Array;
+
+export function decode_frame_indices(data: Uint8Array, frame_index: number): Uint8Array;
+
+export function decode_frame_rgba(data: Uint8Array, frame_index: number): Uint8Array;
+
+export function encode_indexed_delta_gif(index_stream: Uint8Array, width: number, height: number, frame_count: number, palette_rgb: Uint32Array, delay: number, loop_count: number): Uint8Array;
+
+export function encode_indexed_delta_gif_with_delays(index_stream: Uint8Array, width: number, height: number, frame_count: number, palette_rgb: Uint32Array, delays: Uint16Array, loop_count: number): Uint8Array;
+
+export function encode_indexed_gif(index_stream: Uint8Array, width: number, height: number, frame_count: number, palette_rgb: Uint32Array, delay: number, loop_count: number): Uint8Array;
+
+export function encode_indexed_gif_with_delays(index_stream: Uint8Array, width: number, height: number, frame_count: number, palette_rgb: Uint32Array, delays: Uint16Array, loop_count: number): Uint8Array;
+
+export function encode_indexed_literal_delta_gif(index_stream: Uint8Array, width: number, height: number, frame_count: number, palette_rgb: Uint32Array, delay: number, loop_count: number): Uint8Array;
+
+export function encode_indexed_literal_delta_gif_with_delays(index_stream: Uint8Array, width: number, height: number, frame_count: number, palette_rgb: Uint32Array, delays: Uint16Array, loop_count: number): Uint8Array;
+
+export function encode_indexed_literal_gif(index_stream: Uint8Array, width: number, height: number, frame_count: number, palette_rgb: Uint32Array, delay: number, loop_count: number): Uint8Array;
+
+export function encode_indexed_literal_gif_with_delays(index_stream: Uint8Array, width: number, height: number, frame_count: number, palette_rgb: Uint32Array, delays: Uint16Array, loop_count: number): Uint8Array;
+
+export function encode_indexed_lzw(index_stream: Uint8Array, min_code_size: number, color_count: number): Uint8Array;
+
+export function encode_rgba_gif(rgba_stream: Uint8Array, width: number, height: number, frame_count: number, palette_rgb: Uint32Array, delay: number, loop_count: number, deltas: boolean): Uint8Array;
+
+export function encode_rgba_gif_with_options(rgba_stream: Uint8Array, width: number, height: number, frame_count: number, palette_rgb: Uint32Array, delays: Uint16Array, loop_count: number, deltas: boolean, alpha_threshold: number): Uint8Array;
+
+export function encode_rgba_literal_delta_gif(rgba_stream: Uint8Array, width: number, height: number, frame_count: number, palette_rgb: Uint32Array, delay: number, loop_count: number): Uint8Array;
+
+export function encode_rgba_literal_delta_gif_with_options(rgba_stream: Uint8Array, width: number, height: number, frame_count: number, palette_rgb: Uint32Array, delays: Uint16Array, loop_count: number, alpha_threshold: number): Uint8Array;
+
+export function encode_rgba_literal_gif(rgba_stream: Uint8Array, width: number, height: number, frame_count: number, palette_rgb: Uint32Array, delay: number, loop_count: number): Uint8Array;
+
+export function encode_rgba_literal_gif_with_options(rgba_stream: Uint8Array, width: number, height: number, frame_count: number, palette_rgb: Uint32Array, delays: Uint16Array, loop_count: number, alpha_threshold: number): Uint8Array;
+
+export function parse_metadata_json(data: Uint8Array): string;
+
+export function prepare_composited_bgra(data: Uint8Array, requested_frames: Uint8Array): Uint32Array;
+
+export function prepare_composited_delta_bgra(data: Uint8Array, requested_frames: Uint8Array): Uint32Array;
+
+export function prepare_composited_delta_rgba(data: Uint8Array, requested_frames: Uint8Array): Uint32Array;
+
+export function prepare_composited_rgba(data: Uint8Array, requested_frames: Uint8Array): Uint32Array;
+
+export function prepare_reencode_hot_path(): void;
+
+export function reencode_gif_pixel_perfect(data: Uint8Array): Uint8Array;
+
+export function reencode_hot_path_primer(side: number, frame_count: number): Uint8Array;
+
+export function remux_gif_pixel_perfect(data: Uint8Array): Uint8Array;
+
+export function remux_hot_path_primer(): Uint8Array;