wtfgif 1.2.0

package/BENCHMARKS.md

@@ -0,0 +1,185 @@
+# Benchmarks
+
+Performance claims are only meaningful when the backend, cache state, fixtures,
+and correctness checks are explicit.
+
+## MakeEmoji pixel-perfect timing export
+
+This reproduces MakeEmoji's current export after its preview frames have been
+decoded: each RGBA frame is quantized with MakeEmoji's `image-q` settings and
+written with `omggif`. It compares that path with a one-shot wtfgif timing edit
+and with a GIF compiled while the upload loads.
+
+```bash
+BENCH_ITERATIONS=5 BENCH_WARMUP_ITERATIONS=2 \
+npm run bench:makeemoji-retime
+```
+
+Five measured samples per implementation and fixture, with two warmups:
+
+| Fixture | One-shot parse + retime | Page-load compiled retime |
+| --- | ---: | ---: |
+| 18d | 1,110.2x | 4,225.9x |
+| Clap | 321.6x | 951.5x |
+| Homer | 9,418.9x | 29,954.7x |
+| Chipmunk | 6,706.7x | 27,473.8x |
+| GIGACHAD | 5,386.7x | 12,998.1x |
+| NODDERS | 1,414.5x | 3,158.2x |
+| Proud | 5,005.4x | 32,190.9x |
+| catJAM | 3,953.6x | 6,151.6x |
+| excuseme | 4,922.4x | 10,105.7x |
+| party_blob | 7,268.6x | 16,010.2x |
+| partyparrot | 600.4x | 1,643.9x |
+| tenor | 26,241.3x | 72,672.1x |
+| **Geometric mean** | **3,338.5x** | **9,469.6x** |
+
+Every wtfgif output had the requested delays and exact composited RGBA pixels.
+The unit suite separately verifies that original compressed frame data is
+retained. MakeEmoji's current quantize-and-reencode output was pixel-perfect on
+only 2 of 12 fixtures.
+
+This result comes from doing less work, not from a faster quantizer: timing
+changes do not require decoding or recompressing the image stream.
+
+The page-load compiled column is the intended web path and the >100x contract.
+Cold one-shot results on tiny GIFs are more sensitive to JavaScript startup,
+JIT, and microsecond timer noise; a separate three-sample filtered run observed
+a 59.3x one-shot outlier while the compiled edit remained 782.5x.
+
+The same benchmark exercises strict reverse and MakeEmoji-style boomerang on
+fixtures whose full-canvas/disposal structure proves that frame order is
+independent:
+
+| Operation | Slowest accepted fixture | Geometric mean |
+| --- | ---: | ---: |
+| Reverse | 5,329.5x | 18,054.3x |
+| Boomerang | 6,866.7x | 21,720.1x |
+
+The structural path compares each output frame with its mapped source frame,
+including exact composited RGBA and delay values. Fixtures that cannot be
+proven independent are rejected and excluded, rather than silently rewritten.
+
+## Experimental cold pixel-perfect reencoding
+
+The current research checkpoint starts a fresh process for each sample and
+reencodes every GIF image descriptor with the experimental native addon. The
+timer excludes the decoded-pixel verification that follows each sample. Every
+output and source GIF is then decoded and compared; any pixel mismatch aborts
+the run.
+
+Command:
+
+```bash
+BENCH_ITERATIONS=31 BENCH_REENCODE_ONLY=1 npm run bench
+```
+
+31 fresh-process samples per implementation and fixture:
+
+| Fixture | wtfgif faster than omggif |
+| --- | ---: |
+| 18d | 142.65x |
+| Clap | 100.97x |
+| Homer | 191.85x |
+| Chip | 200.35x |
+| GIG | 180.09x |
+| NOD | 111.37x |
+| Proud | 229.79x |
+| cat | 180.53x |
+| excuse | 117.74x |
+| blob | 126.32x |
+| parrot | 149.29x |
+| tenor | 214.14x |
+| Geometric mean | 156.69x |
+
+These are experimental-addon results on the development machine, not a promise
+for the portable npm package or other hardware. The 1.0.0 npm artifact ships
+JavaScript and WebAssembly; it does not ship a prebuilt native addon.
+
+## Page-load-prepared portable pixel-perfect remux
+
+This is the web product benchmark. Wasm initialization and generic hot-path
+preparation happen before the clock, as they would during page load. Each timed
+sample is still the first real GIF processed in a fresh process. Preparation
+uses unrelated generated GIFs and cannot cache a fixture's input or output.
+
+wtfgif validates and rewrites the GIF container while preserving original LZW
+frame payloads. omggif decodes and freshly recompresses the frames. The
+externally tested contract is the same—an owned GIF with identical decoded
+pixels—but the algorithms intentionally differ.
+
+```bash
+BENCH_ITERATIONS=31 BENCH_REENCODE_ONLY=1 \
+WTFGIF_BENCH_BACKEND=wasm \
+WTFGIF_PREPARE_WASM_AT_PAGE_LOAD=1 \
+WTFGIF_REENCODE_MODE=remux npm run bench
+```
+
+| Fixture | wtfgif faster than omggif |
+| --- | ---: |
+| 18d | 738.64x |
+| Clap | 309.84x |
+| Homer | 983.53x |
+| Chip | 768.77x |
+| GIG | 607.23x |
+| NOD | 512.23x |
+| Proud | 681.13x |
+| cat | 519.37x |
+| excuse | 480.06x |
+| blob | 955.88x |
+| parrot | 244.09x |
+| tenor | 1,238.09x |
+| Geometric mean | 609.73x |
+
+Every fixture clears 100x. The slowest is partyparrot at 244.09x.
+
+The excluded initialization plus generic preparation cost was measured
+separately across 31 fresh processes on the same machine: 8.64 ms median,
+9.86 ms p95, and 9.91 ms maximum.
+
+## Cold portable Rust/WebAssembly reencoding
+
+The same pixel-perfect Rust reencoder now runs in browsers, Cloudflare Workers,
+Vercel Edge, and Node through WebAssembly.
+
+```bash
+BENCH_ITERATIONS=31 BENCH_REENCODE_ONLY=1 \
+WTFGIF_BENCH_BACKEND=wasm npm run bench
+```
+
+| Fixture | wtfgif faster than omggif |
+| --- | ---: |
+| 18d | 8.19x |
+| Clap | 1.23x |
+| Homer | 14.68x |
+| Chip | 17.70x |
+| GIG | 15.44x |
+| NOD | 8.60x |
+| Proud | 20.00x |
+| cat | 14.42x |
+| excuse | 9.60x |
+| blob | 9.74x |
+| parrot | 3.38x |
+| tenor | 16.00x |
+| Geometric mean | 9.45x |
+
+These are first-call numbers in 31 fresh Node processes per implementation and
+fixture. They include Wasm's first-call cost and use no warmup. Browser and edge
+support is separately exercised by real-browser, Cloudflare workerd, and Vercel
+Edge VM smoke tests.
+
+Page-load preparation improves fresh LZW recompression, but it does not remove
+the actual LZW decode and encode work. Profiling found decoding responsible for
+roughly 57–85% of its hot runtime and literal reencoding for roughly 15–43%.
+The remux API avoids both stages by preserving the original compressed payload.
+
+## Correctness gates
+
+- Source and reencoded decoded pixels must match exactly for every timed sample.
+- Source and remuxed decoded pixels must match exactly for every timed sample.
+- A randomized parity stress run covered 200 generated GIFs across 4, 16, 64,
+  128, and 256 colors, global palettes, and identical local palettes.
+- Unit tests compare reader and writer behavior with omggif across the fixture
+  corpus.
+
+Record new results here only with the exact command, sample count, environment,
+backend, and correctness gate.

package/CHANGELOG.md

@@ -0,0 +1,54 @@
+# Changelog
+
+All notable changes to wtfgif are documented here.
+
+## 1.2.0 - 2026-07-19
+
+- Add `compileGif()`, an immutable compiled-GIF representation that retains
+  original palettes, frame rectangles, extensions, and compressed LZW data.
+- Add `CompiledGif.withDelays()` and `retimeGifPixelPerfect()` for timing edits
+  that patch metadata without decoding, quantizing, or recompressing pixels.
+- Add `CompiledGif.withLoop()` with Netscape and ANIMEXTS loop support.
+- Add strict `reverseFrames()` and MakeEmoji-compatible `boomerangFrames()`
+  linker paths for structurally independent full-canvas animations.
+- Preserve exact pixels and compressed frame payloads across the real fixture
+  corpus, including local palettes, interlacing, transparency, disposal,
+  comments, and application extensions.
+- Add a MakeEmoji-shaped timing export benchmark. The page-load-compiled path
+  measured at least 951x faster on every fixture.
+- Benchmark proven-safe reverse at least 5,329x faster and boomerang at least
+  6,866x faster while checking exact mapped pixels and delays.
+
+## 1.1.0 - 2026-07-19
+
+- Run the pixel-perfect one-shot Rust reencoder and all-frame RGBA decoder
+  through WebAssembly in browsers and edge runtimes.
+- Add static Wasm initialization for Cloudflare Workers and Vercel Edge.
+- Add `remuxGifPixelPerfect()`, a portable lossless Rust/Wasm path that
+  preserves original compressed frame payloads and exceeds 100x on every
+  page-load-prepared benchmark fixture.
+- Prepare generic Wasm and public API hot paths during explicit page-load
+  initialization.
+- Add explicit `rust` and `wasm` encoder backend choices plus fast-backend
+  status reporting.
+- Validate real reencoding and decoded-pixel parity in the packaged browser
+  build, Cloudflare workerd, Vercel Edge VM, and the full GIF corpus.
+- Add an interactive GitHub Pages race across all 12 benchmark fixtures with
+  live browser timing and post-timer full RGBA parity verification.
+
+## 1.0.0 - 2026-07-19
+
+First public release.
+
+### Highlights
+
+- Drop-in `GifReader` and `GifWriter` APIs for core omggif usage, including
+  plain arrays, typed arrays, Node buffers, CommonJS, ESM, and TypeScript.
+- Portable JavaScript fallback plus packaged WebAssembly builds for Node and
+  browsers.
+- Higher-level helpers for indexed and RGBA frame encoding, composited frame
+  preparation, delta frames, and configurable compression.
+- Pixel-parity tests against omggif and installed-tarball validation across
+  CommonJS, ESM, browser exports, and WebAssembly loading.
+- Experimental injectable Node addon for one-off decode and pixel-perfect
+  reencoding research. Prebuilt native binaries are not part of 1.0.0.

package/CONTRIBUTING.md

@@ -0,0 +1,27 @@
+# Contributing
+
+Bug reports and focused pull requests are welcome.
+
+## Setup
+
+wtfgif requires Node 20.16 or newer and the stable Rust toolchain. Install
+`wasm-pack`, then install dependencies:
+
+```bash
+cargo install wasm-pack --locked
+npm ci
+```
+
+## Before opening a pull request
+
+Run the complete release gate:
+
+```bash
+npm run check
+```
+
+Changes to decoding or encoding must include a regression test. Compatibility
+changes should compare behavior with omggif when applicable. Performance
+changes should preserve decoded pixels and report the command, fixture set, and
+whether the measurement used a warm process, cold process, WebAssembly, or the
+experimental native addon.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Matt Popovich
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,166 @@
+# wtfgif
+
+An `omggif`-compatible GIF reader and writer, plus pixel-perfect fast paths
+that avoid rebuilding pixels when the requested edit does not require it.
+
+**[Run the browser benchmark →](https://mpopv.github.io/wtfgif/)**
+
+```bash
+npm install wtfgif
+```
+
+## Replace omggif
+
+For the core `GifReader` and `GifWriter` API, change the import:
+
+```diff
+- import { GifReader, GifWriter } from "omggif";
++ import { GifReader, GifWriter } from "wtfgif";
+```
+
+CommonJS and TypeScript are supported:
+
+```js
+const { GifReader, GifWriter } = require("wtfgif");
+```
+
+This is the compatibility path. It accepts the same indexed pixels, palettes,
+frame rectangles, delays, transparency, and disposal options used by omggif.
+It does not promise a 100x speedup for arbitrary new pixels.
+
+## The 100x fast paths
+
+wtfgif is fastest when pixels are already valid GIF data and the edit can be
+expressed as a container change:
+
+| Operation | Fixtures | Slowest speedup | Correctness |
+| --- | ---: | ---: | --- |
+| Compiled timing edit | 12/12 | **951.5x** | Exact pixels, delays, and original LZW payloads |
+| Prepared Wasm remux | 12/12 | **244.09x** | Exact decoded animation |
+| Strict frame reverse | 2/12 eligible | **5,329.5x** | Exact mapped pixels and delays |
+| Strict boomerang | 2/12 eligible | **6,866.7x** | Exact mapped pixels and delays |
+
+These are not claims that every wtfgif call is 100x faster. They are results
+for the named operations across the accepted benchmark fixtures. Timing,
+reverse, and boomerang are compared with MakeEmoji's `image-q` + `omggif`
+export; remux is compared with `omggif` decode + fresh encode. See
+[BENCHMARKS.md](BENCHMARKS.md) for commands, fixtures, sample counts, cold
+results, and correctness gates.
+
+## Edit timing without touching pixels
+
+Compile once when a GIF is loaded:
+
+```ts
+import { compileGif } from "wtfgif";
+
+const gif = compileGif(inputGif);
+```
+
+Export new frame delays later. GIF delays are measured in centiseconds:
+
+```ts
+const outputGif = gif
+	.withDelays(Uint16Array.of(4, 8, 12, 8))
+	.toUint8Array();
+```
+
+`compileGif()` retains the original GIF structure and compressed image data.
+`withDelays()` changes only timing metadata, inserting a graphics control
+extension when one is missing. It never decodes, quantizes, or recompresses a
+frame.
+
+For a one-shot timing edit:
+
+```ts
+import { retimeGifPixelPerfect } from "wtfgif";
+
+const outputGif = retimeGifPixelPerfect(inputGif, delaysInCentiseconds);
+```
+
+These timing APIs are synchronous JavaScript. They need no Wasm initialization
+and run in Node, browsers, Web Workers, Cloudflare Workers, and Vercel Edge.
+
+## Reverse or boomerang proven-independent frames
+
+```ts
+const gif = compileGif(inputGif);
+
+if (gif.canReorderFrames) {
+	const reversed = gif.reverseFrames();
+	const boomerang = gif.boomerangFrames();
+	// A, B, C becomes A, B, C, C, B, A
+}
+```
+
+This path reorders complete compressed frame records. It deliberately rejects
+GIFs whose appearance can depend on the preceding frame, including unsafe
+partial-frame composition or metadata anchored between frames. A rejection is
+a request to use a real decode-and-render pipeline, not a malformed output.
+
+## Remux with Wasm
+
+Initialize Wasm once per JavaScript realm during page or worker startup:
+
+```ts
+import {
+	initializeWasmGlobally,
+	remuxGifPixelPerfect,
+} from "wtfgif";
+
+await initializeWasmGlobally();
+
+const outputGif = remuxGifPixelPerfect(inputGif);
+```
+
+`remuxGifPixelPerfect()` validates and rewrites the GIF container while
+preserving palettes and compressed frame payloads. It guarantees the displayed
+animation: dimensions, frames, timing, loop behavior, disposal, transparency,
+and decoded pixels. Non-rendering extension metadata such as comments is not
+part of its contract.
+
+Cloudflare Workers and Vercel Edge require static Wasm imports:
+
+```ts
+import {
+	initializeWasmModule,
+	remuxGifPixelPerfect,
+} from "wtfgif";
+import init, * as rust from "wtfgif/wasm-web";
+import wasm from "wtfgif/wasm-web/wasm";
+
+await initializeWasmModule({ ...rust, default: init }, wasm);
+```
+
+Initialization is not global across a website: the window and each Worker,
+Node process, or edge isolate are separate realms and must initialize their
+own module.
+
+## What is not 100x
+
+- `GifReader` and `GifWriter` are drop-in compatibility APIs, not universal
+  100x APIs.
+- Encoding arbitrary new pixels still requires palette selection and LZW
+  compression. Wasm initialization cannot make that work disappear.
+- `reencodeGifPixelPerfect()` performs fresh LZW encoding and is substantially
+  slower than remuxing.
+- Cold startup is excluded from the prepared-Wasm and compiled-edit results.
+  The measured Wasm initialization and preparation cost was 8.64 ms median;
+  one tiny-GIF timing run also produced a 59.3x cold one-shot outlier.
+- Reverse and boomerang are fast only when wtfgif can prove that raw frame
+  reordering preserves the rendered animation.
+
+The speedup comes from recognizing when an edit does not need a pixel pipeline.
+Instead of decode → quantize → recompress, wtfgif validates the structure and
+copies already-correct compressed bytes.
+
+## Verify
+
+```bash
+npm run check
+
+BENCH_ITERATIONS=5 BENCH_WARMUP_ITERATIONS=2 \
+npm run bench:makeemoji-retime
+```
+
+[MIT](LICENSE)

package/dist/compiled.d.ts

@@ -0,0 +1,77 @@
+import type { GifBinary } from "./types";
+/**
+ * A delay in GIF centiseconds, or one delay for every image frame.
+ */
+export type GifFrameDelays = number | ArrayLike<number>;
+/**
+ * A parsed GIF whose compressed image data and unrelated metadata can be
+ * copied without decoding or re-encoding pixels.
+ *
+ * Instances are immutable. Transformations share the parsed source layout;
+ * bytes are copied only when `toUint8Array()` is called.
+ */
+export declare class CompiledGif {
+    readonly width: number;
+    readonly height: number;
+    readonly frameCount: number;
+    readonly delays: readonly number[];
+    readonly loopCount: number | null;
+    readonly canReorderFrames: boolean;
+    private readonly layout;
+    private readonly requestedDelays;
+    private readonly requestedLoopCount;
+    private readonly hasLoopOverride;
+    private constructor();
+    /** Parse a GIF into an immutable compiled representation. */
+    static from(input: GifBinary): CompiledGif;
+    /**
+     * Return a compiled view with new per-frame delays.
+     *
+     * A scalar applies to every frame. An array-like value must have exactly
+     * one entry per image frame. Values are integer centiseconds in
+     * the GIF range 0...65535.
+     */
+    withDelays(delays: GifFrameDelays): CompiledGif;
+    /**
+     * Return a compiled view with a Netscape loop count.
+     *
+     * `0` means loop forever. If the source has no Netscape extension, a
+     * canonical extension is inserted without touching image data.
+     */
+    withLoop(loopCount: number): CompiledGif;
+    /**
+     * Reorder or duplicate structurally independent frames without decoding.
+     *
+     * This strict fast path accepts full-canvas frames that are either all
+     * opaque or all restore a canonical base with disposal 2/3. It throws for
+     * GIFs whose frame composition could depend on the original order.
+     */
+    reorderFrames(order: ArrayLike<number>): Uint8Array;
+    /** Reverse all frames through the proven-safe structural fast path. */
+    reverseFrames(): Uint8Array;
+    /**
+     * Append the complete reverse sequence, matching MakeEmoji's boomerang
+     * semantics: `[A, B, C, C, B, A]`.
+     */
+    boomerangFrames(): Uint8Array;
+    /**
+     * Materialize the transformed GIF.
+     *
+     * Existing delays and loop counts are patched in place. A frame without a
+     * graphic-control extension receives the minimal eight-byte extension.
+     */
+    toUint8Array(): Uint8Array;
+}
+/**
+ * Parse a GIF once so metadata-only transformations can reuse its original
+ * palettes, image descriptors, extensions, and compressed LZW sub-blocks.
+ */
+export declare function compileGif(input: GifBinary): CompiledGif;
+/**
+ * Rewrite frame delays without decoding or recompressing a single pixel.
+ */
+export declare function retimeGifPixelPerfect(input: GifBinary, delays: GifFrameDelays): Uint8Array;
+/** Reverse structurally independent GIF frames without touching pixel data. */
+export declare function reverseGifPixelPerfect(input: GifBinary): Uint8Array;
+/** Create a MakeEmoji-style forward-then-reverse GIF without pixel work. */
+export declare function boomerangGifPixelPerfect(input: GifBinary): Uint8Array;

package/dist/constants/gif.d.ts

@@ -0,0 +1,17 @@
+export declare const enum GIF {
+    G = 71,
+    I = 73,
+    F = 70,
+    _8 = 56,
+    _9 = 57,
+    A = 97,
+    EXT = 33,
+    IMG = 44,
+    TRAILER = 59,
+    GCE = 249,
+    APPLICATION = 255,
+    PLAINTEXT = 1,
+    COMMENT = 254,
+    NETSCAPE_LEN = 11,
+    MAX_CODE = 4096
+}

package/dist/decoder/pool.d.ts

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

package/dist/decoder/reader.d.ts

@@ -0,0 +1,80 @@
+import { FrameInfo, GifBinary, GifDecodeBackend, GifDecodeBackendStatus, GifPixelBuffer, PreparedGifFrames, PrepareFramesOptions } from "../types";
+export declare class GifReader {
+    private buf;
+    private width_;
+    private height_;
+    private globalPaletteOffset;
+    private globalPaletteSize;
+    private frames;
+    private loop_count;
+    private pooledTables;
+    private decTable;
+    private stack;
+    private firstByte;
+    private activePreparedFrames;
+    private static decodeBackend;
+    static createPooled(buf: GifBinary): GifReader;
+    static createUnpooled(buf: GifBinary): GifReader;
+    static setDecodeBackend(backend: GifDecodeBackend | null): void;
+    static getDecodeBackendStatus(): GifDecodeBackendStatus;
+    constructor(buf: GifBinary, _usePooling?: boolean);
+    get width(): number;
+    get height(): number;
+    /**
+     * Simplified LZW decoder that outputs palette indices instead of RGBA
+     */
+    private lzwDecodeToIndices;
+    numFrames(): number;
+    loopCount(): number | null;
+    frameInfo(i: number): FrameInfo;
+    private ensureDecoderTables;
+    private getFrameCodes;
+    private getFramePalette;
+    private getFrameIndices;
+    decodeAndBlitFrameBGRA(frameNum: number, pixels: GifPixelBuffer): void;
+    decodeAndBlitFrameRGBA(frameNum: number, pixels: GifPixelBuffer): void;
+    decodeFrameToTransferableRGBA(frameNum: number): ArrayBuffer;
+    decodeFrameToTransferableBGRA(frameNum: number): ArrayBuffer;
+    decodeFrameIntoBuffer(frameNum: number, buffer: ArrayBuffer, format?: "rgba" | "bgra"): void;
+    preparePlayback(options?: Omit<PrepareFramesOptions, "composited">): PreparedGifFrames;
+    prepareFrames(options?: PrepareFramesOptions): PreparedGifFrames;
+    prepareFramesAsync(options?: PrepareFramesOptions): Promise<PreparedGifFrames>;
+    decodeAndBlitCompositedFrameRGBA(frameNum: number, pixels: Uint8Array): void;
+    decodeAndBlitCompositedFrameBGRA(frameNum: number, pixels: Uint8Array): void;
+    private normalizePrepareFramesOptions;
+    private normalizeFrameIndices;
+    private prepareFramesWithBackend;
+    private createBackendPreparedFramesResult;
+    private prepareCompositedFrames;
+    private prepareUncompositedFrames;
+    private createPreparedFramesResult;
+    private createPreparedPlayer;
+    private copyPreparedFrame;
+    private copyPreparedFrame32;
+    private blitPreparedColors;
+    private blitPreparedIndices;
+    private getPreparedTarget32;
+    private applyFrameDisposal;
+    private clearFrameRect;
+    private static findChangedRect;
+    private static copyRectPixels;
+    private static blitRectPixels;
+    private enforcePreparedByteBudget;
+    private static hashPixels;
+    private static findMatchingPixels;
+    private static pixelsEqual;
+    dispose(): void;
+    private clearFrameCaches;
+    returnToPool(): void;
+    static getPoolStats(): {
+        available: number;
+        totalCreated: number;
+        hits: number;
+        misses: number;
+    };
+    private decodeAndBlitFrame32;
+    private decodeAndBlitCompatibleFrame;
+    private getFrameColors;
+    private blitFrameIndicesToCanvas;
+    private lzwDecodeToPixels;
+}

package/dist/encoder/writer.d.ts

@@ -0,0 +1,59 @@
+import { FrameOptions, GifBinary, GifOptions, PaletteRGB } from "../types";
+export type IndexedGifFrame = Uint8Array | number[];
+export type IndexedGifFrames = Uint8Array | IndexedGifFrame[];
+export type EncodeIndexedGifFramesBackend = "auto" | "rust" | "wasm" | "native" | "javascript";
+export type RgbaGifFrame = Uint8Array | Uint8ClampedArray;
+export type RgbaGifFrames = Uint8Array | Uint8ClampedArray | RgbaGifFrame[];
+export type GifFrameDelay = number | readonly number[] | Uint16Array;
+export type GifCompressionMode = "balanced" | "fast";
+export interface EncodeIndexedGifFramesOptions {
+    width: number;
+    height: number;
+    frames: IndexedGifFrames;
+    frameCount?: number;
+    palette: PaletteRGB;
+    delay?: GifFrameDelay;
+    loop?: number | null;
+    backend?: EncodeIndexedGifFramesBackend;
+    delta?: boolean;
+    compression?: GifCompressionMode;
+}
+export interface EncodeRgbaGifFramesOptions {
+    width: number;
+    height: number;
+    frames: RgbaGifFrames;
+    frameCount?: number;
+    palette?: PaletteRGB;
+    delay?: GifFrameDelay;
+    loop?: number | null;
+    backend?: EncodeIndexedGifFramesBackend;
+    delta?: boolean;
+    alphaThreshold?: number;
+    compression?: GifCompressionMode;
+}
+type IndexedPixels = IndexedGifFrame;
+export declare function encodeIndexedGifFrames(options: EncodeIndexedGifFramesOptions): Uint8Array;
+export declare function encodeRgbaGifFrames(options: EncodeRgbaGifFramesOptions): Uint8Array;
+export declare class GifWriter {
+    private buf;
+    readonly width: number;
+    readonly height: number;
+    private p;
+    private ended;
+    private loopCount;
+    private globalPalette;
+    private background;
+    private globalColorCount;
+    private previousIndexedFrame;
+    constructor(buf: GifBinary, width: number, height: number, gopts?: GifOptions);
+    addFrame(x: number, y: number, w: number, h: number, indexedPixels: IndexedPixels, opts?: FrameOptions): number;
+    addFrameDelta(indexedPixels: IndexedPixels, opts?: FrameOptions): number;
+    private writeFrame;
+    end(): number;
+    getOutputBuffer(): GifBinary;
+    setOutputBuffer(v: GifBinary): void;
+    getOutputBufferPosition(): number;
+    setOutputBufferPosition(v: number): void;
+    private updatePreviousIndexedFrame;
+}
+export {};