@cjser/sindresorhus__gifkit 0.1.0-cjser.2

package/index.js

@@ -0,0 +1,118 @@
+import {decodeGIF} from './source/decode.js';
+import {encodeGIF} from './source/encode.js';
+import {renderGIFFrames} from './source/render.js';
+import {buildQuantizedIndexedImage} from './source/quantize.js';
+import {
+	isUint8Array,
+	isUint8ClampedArray,
+	requireNonZeroUnsigned16,
+	requireFiniteNumberInRange,
+	requirePositiveFiniteNumber,
+	normalizeRedGreenBlueAlphaPixels,
+} from './source/validate.js';
+import {rejectRenamedLoopCount} from './source/loop-count.js';
+
+export {decodeGIF} from './source/decode.js';
+export {encodeGIF} from './source/encode.js';
+export {renderGIFFrameSequence, renderGIFFrames} from './source/render.js';
+export {indexedImage} from './source/quantize.js';
+
+export function decodeAnimatedGIF(inputBytes, options = {}) {
+	const gif = decodeGIF(inputBytes, options);
+	const rendered = renderGIFFrames(gif, {
+		background: options.background ?? 'transparent',
+		strict: options.strict,
+	});
+
+	return {
+		width: rendered.width,
+		height: rendered.height,
+		...(rendered.playCount !== undefined && {playCount: rendered.playCount}),
+		frames: rendered.frames.map(frame => ({
+			pixels: frame.pixels,
+			delay: frame.delay,
+		})),
+	};
+}
+
+export function encodeAnimatedGIF(frames, options = {}) {
+	if (!Array.isArray(frames) || frames.length === 0) {
+		throw new TypeError('frames must be a non-empty array');
+	}
+
+	const width = requireNonZeroUnsigned16(options.width, 'width');
+	const height = requireNonZeroUnsigned16(options.height, 'height');
+	const quality = requireFiniteNumberInRange(options.quality ?? 0.8, 0, 1, 'quality');
+	rejectRenamedLoopCount(options);
+	const hasFrameDelays = frames.some(frame => isAnimationFrameObject(frame) && frame.delay !== undefined);
+	if (options.fps !== undefined && hasFrameDelays) {
+		throw new Error('fps cannot be combined with per-frame delay');
+	}
+
+	if (options.fps === undefined && frames.some(frame => !isAnimationFrameObject(frame) || frame.delay === undefined)) {
+		throw new Error('fps is required unless every frame has a delay');
+	}
+
+	const frameDelay = options.fps === undefined
+		? undefined
+		: 1 / requirePositiveFiniteNumber(options.fps, 'fps');
+
+	const blocks = frames.map((frame, index) => {
+		const pixels = normalizeAnimationFramePixels(frame, width * height * 4, `frames[${index}]`);
+		const delay = frameDelay ?? requireFiniteNumberInRange(frame.delay, 0, 655.35, `frames[${index}].delay`);
+		const imageBlock = {
+			type: 'rgbaImage',
+			width,
+			height,
+			graphicControlExtension: {
+				delay,
+			},
+		};
+
+		if (quality === 1) {
+			return {
+				...imageBlock,
+				pixels,
+			};
+		}
+
+		const quantizedImage = buildQuantizedIndexedImage(pixels, {quality});
+		return {
+			type: 'image',
+			width,
+			height,
+			pixels: quantizedImage.pixels,
+			colorTable: quantizedImage.colorTable,
+			graphicControlExtension: {
+				delay,
+				transparentColorIndex: quantizedImage.transparentColorIndex,
+			},
+		};
+	});
+
+	const gif = {
+		width,
+		height,
+		blocks,
+	};
+	if (options.playCount !== undefined) {
+		gif.playCount = options.playCount;
+	}
+
+	return encodeGIF(gif);
+}
+
+function normalizeAnimationFramePixels(frame, expectedLength, fieldName) {
+	const pixels = isAnimationFrameObject(frame)
+		? frame.pixels
+		: frame;
+	return normalizeRedGreenBlueAlphaPixels(pixels, expectedLength, fieldName);
+}
+
+function isAnimationFrameObject(frame) {
+	return frame !== null
+		&& typeof frame === 'object'
+		&& !isUint8Array(frame)
+		&& !isUint8ClampedArray(frame)
+		&& !Array.isArray(frame);
+}

package/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+
+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/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "@cjser/sindresorhus__gifkit",
+  "version": "0.1.0-cjser.2",
+  "description": "Encode, decode, and render GIF files",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://code.moenext.com/3rdeye/cjser.git"
+  },
+  "funding": "https://github.com/sponsors/sindresorhus",
+  "author": {
+    "name": "Sindre Sorhus",
+    "email": "sindresorhus@gmail.com",
+    "url": "https://sindresorhus.com"
+  },
+  "type": "module",
+  "exports": {
+    "types": "./index.d.ts",
+    "require": "./dist-cjser/index.cjs",
+    "default": "./index.js"
+  },
+  "sideEffects": false,
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "benchmark": "node benchmark.js",
+    "test": "xo && node --test && tsd"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "source",
+    "dist-cjser"
+  ],
+  "keywords": [
+    "gif",
+    "graphics",
+    "image",
+    "encoder",
+    "decoder",
+    "render"
+  ],
+  "devDependencies": {
+    "jimp": "^1.6.1",
+    "tempy": "^3.2.0",
+    "tsd": "^0.33.0",
+    "xo": "^4.0.0"
+  },
+  "xo": {
+    "rules": {
+      "no-bitwise": "off",
+      "max-lines": "off",
+      "unicorn/no-break-in-nested-loop": "off",
+      "unicorn/no-useless-spread": "off",
+      "node-test/no-conditional-assertion": "off"
+    }
+  },
+  "types": "./index.d.ts",
+  "main": "./dist-cjser/index.cjs",
+  "cjser": {
+    "sourceVersion": "0.1.0",
+    "cjserVersion": 2,
+    "original": {
+      "name": "@sindresorhus/gifkit",
+      "version": "0.1.0",
+      "exports": {
+        "types": "./index.d.ts",
+        "default": "./index.js"
+      },
+      "repository": "sindresorhus/gifkit",
+      "files": [
+        "index.js",
+        "index.d.ts",
+        "source"
+      ],
+      "scripts": {
+        "benchmark": "node benchmark.js",
+        "test": "xo && node --test && tsd"
+      }
+    }
+  }
+}

package/readme.md

@@ -0,0 +1,294 @@
+# gifkit
+
+> Encode, decode, and render GIF files
+
+This package is a small JavaScript GIF toolkit. It can decode GIF87a/GIF89a files into structured blocks, encode structured GIF descriptions back to bytes, and render image blocks to RGBA pixels.
+
+## Install
+
+```sh
+npm install @sindresorhus/gifkit
+```
+
+## Usage
+
+```js
+import {decodeAnimatedGIF, encodeAnimatedGIF} from '@sindresorhus/gifkit';
+
+const bytes = encodeAnimatedGIF(frames, {
+	width: 640,
+	height: 480,
+	fps: 14,
+	playCount: 5,
+	quality: 0.7,
+});
+
+const animation = decodeAnimatedGIF(bytes);
+
+console.log(animation.frames[0].pixels);
+console.log(animation.frames[0].delay);
+```
+
+> [!NOTE]
+> If you accept untrusted input in a server context, it's up to you to enforce limits like timeouts and memory usage.
+
+## Common recipes
+
+### Encode RGBA frames to a GIF
+
+```js
+import {encodeAnimatedGIF} from '@sindresorhus/gifkit';
+
+const bytes = encodeAnimatedGIF(frames, {
+	width: 640,
+	height: 480,
+	fps: 14,
+	playCount: 5,
+	quality: 0.7,
+});
+```
+
+GIF stores frame timing in 0.01 second increments, so `fps` and `delay` values are rounded.
+
+For photos and screenshots, keep the default `quality` or lower it. Use `quality: 1` only when every frame already has at most 256 exact colors.
+
+### Decode a GIF to RGBA frames
+
+```js
+import {decodeAnimatedGIF} from '@sindresorhus/gifkit';
+
+const animation = decodeAnimatedGIF(bytes);
+
+console.log(animation.width);
+console.log(animation.height);
+console.log(animation.frames[0].pixels);
+console.log(animation.frames[0].delay);
+```
+
+### Decode and encode again
+
+```js
+import {decodeAnimatedGIF, encodeAnimatedGIF} from '@sindresorhus/gifkit';
+
+const animation = decodeAnimatedGIF(bytes);
+
+const options = {
+	width: animation.width,
+	height: animation.height,
+};
+
+if (animation.playCount !== undefined) {
+	options.playCount = animation.playCount;
+}
+
+const newBytes = encodeAnimatedGIF(animation.frames, options);
+```
+
+### Use per-frame delays
+
+```js
+import {encodeAnimatedGIF} from '@sindresorhus/gifkit';
+
+const bytes = encodeAnimatedGIF([
+	{pixels: frame1, delay: 0.1},
+	{pixels: frame2, delay: 0.2},
+], {
+	width: 640,
+	height: 480,
+	playCount: 5,
+	quality: 0.7,
+});
+```
+
+## API
+
+### `decodeGIF(inputBytes, options?)`
+
+Decodes a `Uint8Array` containing a GIF file and returns a structured GIF object with logical-screen metadata, extension blocks, image blocks, color tables, and decoded indexed pixels.
+
+Options:
+
+- `strict` - Default: `true`. Reject reserved bits, malformed extension sequencing, and trailing bytes. Use `false` for best-effort decoding.
+
+Decoding enforces internal pixel, block-count, data sub-block-count, and data payload byte limits to avoid resource exhaustion.
+
+### `decodeAnimatedGIF(inputBytes, options?)`
+
+Decodes an animated GIF to rendered full-frame RGBA frames. This is the easiest API when you want image buffers and frame timing instead of GIF internals.
+
+```js
+import {decodeAnimatedGIF} from '@sindresorhus/gifkit';
+
+const animation = decodeAnimatedGIF(bytes);
+
+console.log(animation.width);
+console.log(animation.height);
+console.log(animation.playCount);
+console.log(animation.frames[0].pixels);
+console.log(animation.frames[0].delay);
+```
+
+Returns:
+
+- `width` / `height` - Logical screen size.
+- `playCount` - Total animation plays. `'forever'` means infinite playback. Omitted when no loop extension was present.
+- `frames` - Rendered full-frame RGBA frames.
+- `frames[].pixels` - `Uint8ClampedArray` of flat RGBA bytes: `[red, green, blue, alpha, ...]`.
+- `frames[].delay` - Frame delay in seconds. GIF stores delays in 0.01 second increments.
+
+Options:
+
+- `background` - Default: `'transparent'`. Use `'gif'` to render the logical-screen background color.
+- `strict` - Default: `true`. Reject malformed decode data and render data like color indexes outside the active color table. Use `false` for best-effort decoding and rendering.
+
+### `encodeAnimatedGIF(frames, options)`
+
+Encodes RGBA frames as an animated GIF. This is the easiest API when you have a list of image buffers and want a normal animation.
+
+```js
+import {encodeAnimatedGIF} from '@sindresorhus/gifkit';
+
+const bytes = encodeAnimatedGIF(frames, {
+	width: 640,
+	height: 480,
+	fps: 14,
+	playCount: 5,
+	quality: 0.7,
+});
+```
+
+Options:
+
+- `width` / `height` - Required. Frame size.
+- `fps` - Frames per second for uniform timing. Cannot be combined with per-frame `delay`. GIF stores delays in 0.01 second increments, so timing is rounded to the nearest increment.
+- `playCount` - Total animation plays. Finite values must be integers from `1` to `65_536`. Use `'forever'` for infinite playback. Omit it to omit the loop extension. `playCount: 1` also omits the loop extension because that matches default GIF playback.
+- `quality` - Default: `0.8`. `0...1`, where lower values quantize each frame more aggressively to fit GIF’s 256-color palette. Quantization is per-frame and does not dither. For photos and screenshots, keep the default or lower it. Use `1` only when every frame already has at most 256 exact colors.
+
+Frames can be `Uint8Array` or `Uint8ClampedArray` RGBA pixels. Pixels are flat RGBA bytes: `[red, green, blue, alpha, ...]`.
+
+For per-frame timing, use frame objects with `pixels` and `delay` in seconds. Delays are rounded to GIF’s 0.01 second increments:
+
+```js
+const bytes = encodeAnimatedGIF([
+	{pixels: frame1, delay: 0.1},
+	{pixels: frame2, delay: 0.2},
+], {
+	width: 640,
+	height: 480,
+	playCount: 5,
+	quality: 0.7,
+});
+```
+
+### `encodeGIF(gif)`
+
+Encodes a structured GIF object to a `Uint8Array`. Use `image` blocks when you already have indexed pixels and a palette. Use `rgbaImage` blocks when you have flat RGBA bytes that fit GIF’s 256-color model.
+
+The `gif` object has this shape:
+
+- `width` / `height` - Required. Logical screen size.
+- `globalColorTable` - Optional. Global palette as flat RGB bytes (`[red, green, blue, ...]`), a `Uint8Array`, or RGB triplets (`[[red, green, blue], ...]`).
+- `backgroundColorIndex` - Optional. Palette index used as the logical-screen background color. Requires `globalColorTable`.
+- `playCount` - Total animation plays. Finite values must be integers from `1` to `65_536`. Use `'forever'` for infinite playback. Omit it to omit the loop extension. `playCount: 1` also omits the loop extension because that matches default GIF playback.
+- `blocks` - Structured GIF blocks in file order.
+
+Encoded GIFs are always written as GIF89a.
+
+Block types:
+
+- Indexed image block: `{type: 'image', width, height, pixels, colorTable?}`. `pixels` is one palette index per pixel and uses the image `colorTable` or GIF `globalColorTable`. `left` and `top` are optional image offsets and default to `0`. Advanced fields include `isInterlaced`.
+- RGBA image block: `{type: 'rgbaImage', width, height, pixels}`. `pixels` is flat RGBA bytes: `[red, green, blue, alpha, ...]`. gifkit builds a color table from the pixels, so this only works when the image has at most 256 colors and alpha values are fully transparent or fully opaque. `transparentColor` is the RGB palette value stored for transparent pixels.
+- Graphic control metadata for an image block: `graphicControlExtension: {disposalMethod?, delay?, transparentColorIndex?}`. `delay` is in seconds. `transparentColorIndex` is a palette index, or `undefined` for no transparent color. `disposalMethod` is exposed so structured GIF data can be preserved or re-encoded. It controls what happens to the current frame’s pixels before the next frame is drawn: `'unspecified'` leaves the choice to the decoder, `'keep'` keeps the pixels, `'restoreBackground'` clears them to the background, and `'restorePrevious'` restores the previous canvas. Rendered pixels already have this applied, so most users do not need to read or set it.
+- Comment extension: `{type: 'commentExtension', data}`. Strings must be ASCII.
+- Application extension: `{type: 'applicationExtension', identifier, authenticationCode, data?}`. `authenticationCode` accepts a 3-byte string or byte array. Decoded Netscape loop extensions also expose `isNetscapeLoopingExtension` and `playCount`. When encoding an explicit Netscape application extension block, finite `playCount` values must be from `2` to `65_536` because `1` is represented by omitting the loop extension.
+
+Encoding enforces internal pixel, block-count, encode work cost, data payload byte, and total encoded byte limits to avoid resource exhaustion.
+
+Extension payload strings must contain only ASCII characters. Use `Uint8Array` for binary extension data.
+
+### `renderGIFFrameSequence(gif, options?)`
+
+Renders image blocks as an iterable sequence of full logical-screen RGBA frames while applying transparency and disposal methods. Use this for playback or large GIFs where materializing every rendered frame would be wasteful.
+
+```js
+import {decodeGIF, renderGIFFrameSequence} from '@sindresorhus/gifkit';
+
+const gif = decodeGIF(bytes, {strict: false});
+
+for (const frame of renderGIFFrameSequence(gif, {strict: false})) {
+	console.log(frame.pixels);
+	console.log(frame.delay);
+}
+```
+
+Options:
+
+- `background` - Default: `'gif'`. Use `'transparent'` to render the logical-screen background as transparent.
+- `strict` - Default: `true`. Reject malformed render data like color indexes outside the active color table.
+- `repeat` - Default: `true`. Repeat according to GIF `playCount` metadata. Missing metadata means one pass, a finite number means that many total passes, and `'forever'` means infinite playback. Set to `false` to render exactly one pass.
+- `signal` - Optional abort signal. When aborted, iteration ends.
+
+Yields:
+
+- `left` / `top` - Frame source offset in logical-screen pixels.
+- `width` / `height` - Frame source size.
+- `delay` - Frame delay in seconds.
+- `disposalMethod` - Advanced GIF compositing metadata kept so rendered frames can still be related back to the original GIF structure.
+- `pixels` - `Uint8ClampedArray` of rendered full logical-screen RGBA bytes.
+- `index` - Zero-based image-frame index within the current pass.
+- `loopIndex` - Zero-based repetition index for this frame.
+
+### `renderGIFFrames(gif, options?)`
+
+Renders image blocks to full logical-screen RGBA frames while applying transparency and disposal methods. Most users should use `decodeAnimatedGIF()` instead; use this when you need decoded GIF structure and rendered pixels.
+
+Options:
+
+- `background` - Default: `'gif'`. Use `'transparent'` to render the logical-screen background as transparent.
+- `strict` - Default: `true`. Reject malformed render data like color indexes outside the active color table.
+
+Returns:
+
+- `width` / `height` - Logical screen size.
+- `playCount` - Total animation plays. `'forever'` means infinite playback. Omitted when no loop extension was present.
+- `frames` - Rendered full logical-screen RGBA frames.
+- `frames[].left` / `frames[].top` - Frame source offset in logical-screen pixels.
+- `frames[].width` / `frames[].height` - Frame source size.
+- `frames[].delay` - Frame delay in seconds.
+- `frames[].disposalMethod` - Advanced GIF compositing metadata kept so rendered frames can still be related back to the original GIF structure. `'unspecified'` leaves the choice to the decoder, `'keep'` keeps the pixels, `'restoreBackground'` clears them to the background, and `'restorePrevious'` restores the previous canvas before the next frame is drawn. gifkit already applies this when producing `frames[].pixels`, so use it only if you need to inspect or preserve the original animation metadata.
+- `frames[].pixels` - `Uint8ClampedArray` of rendered full logical-screen RGBA bytes.
+
+Rendering enforces internal logical-screen, rendered-output, render block-count, and image-block pixel limits to avoid huge allocations.
+
+### `indexedImage(pixels, options?)`
+
+Use this when you have raw RGBA pixels, for example from a canvas or image decoder, and want the `pixels` and `colorTable` needed for an image block. It only works when the pixels already fit GIF’s palette model.
+
+Converts RGBA pixels to GIF indexed pixels and a power-of-two color table without quantizing or dithering. Each unique opaque RGB color becomes a palette entry. All fully transparent pixels share one palette entry and set `transparentColorIndex`.
+
+Throws if the image exceeds the internal pixel limit, uses more than 256 palette entries, or uses partial alpha. GIF only supports fully transparent or fully opaque pixels.
+
+Options:
+
+- `transparentColor` - Default: `[0, 0, 0]`. RGB value stored in the palette entry used for transparent pixels.
+
+```js
+import {indexedImage} from '@sindresorhus/gifkit';
+
+const image = indexedImage(new Uint8ClampedArray([
+	255, 0, 0, 255,
+	0, 0, 0, 0,
+]));
+
+console.log(image.pixels);
+console.log(image.colorTable);
+```
+
+## Intentionally unsupported GIF spec features
+
+gifkit focuses on GIF features that are useful in modern JavaScript workflows. It intentionally does not expose the GIF user-input flag, pixel aspect ratio byte, color-resolution metadata, color-table sort flags, or Plain Text Extension rendering/encoding. These are legacy display-era features, are rarely present in real GIFs, and are easy to misunderstand. Unknown extensions, including Plain Text Extensions, are preserved as `unknownExtension` blocks.
+
+## cjser
+
+This package is a CommonJS-compatible build generated by cjser for projects that still need `require()` support. The source version matches the original npm package version, with a cjser prerelease suffix for this generated build.
+Original repository: https://github.com/sindresorhus/gifkit

package/source/byte-stream.js

@@ -0,0 +1,141 @@
+import {
+	asciiTextEncoder,
+	asciiTextDecoder,
+	uint8ArraySubarray,
+	defaultMaximumEncodedByteLength,
+} from './constants.js';
+import {
+	isUint8Array,
+	toUint8ArrayView,
+	requireByte,
+	requireUnsigned16,
+	requireByteLengthWithinLimit,
+} from './validate.js';
+
+export class GIFByteReader {
+	#inputBytes;
+	#offset = 0;
+	#length;
+
+	constructor(inputBytes) {
+		if (!isUint8Array(inputBytes)) {
+			throw new TypeError('Expected inputBytes to be a Uint8Array');
+		}
+
+		this.#inputBytes = toUint8ArrayView(inputBytes);
+		this.#length = this.#inputBytes.length;
+	}
+
+	get offset() {
+		return this.#offset;
+	}
+
+	get length() {
+		return this.#length;
+	}
+
+	readByte() {
+		if (this.#offset >= this.#length) {
+			throw new Error('Unexpected end of data');
+		}
+
+		const value = this.#inputBytes[this.#offset];
+		this.#offset += 1;
+		return value;
+	}
+
+	readBytes(length) {
+		if (!Number.isSafeInteger(length) || length < 0) {
+			throw new Error(`Invalid byte length ${length}`);
+		}
+
+		if (this.#offset + length > this.#length) {
+			throw new Error('Unexpected end of data');
+		}
+
+		const value = Uint8Array.from(uint8ArraySubarray.call(this.#inputBytes, this.#offset, this.#offset + length));
+		this.#offset += length;
+		return value;
+	}
+
+	readBytesInto(target, targetOffset, length) {
+		if (!Number.isSafeInteger(length) || length < 0) {
+			throw new Error(`Invalid byte length ${length}`);
+		}
+
+		if (this.#offset + length > this.#length) {
+			throw new Error('Unexpected end of data');
+		}
+
+		target.set(uint8ArraySubarray.call(this.#inputBytes, this.#offset, this.#offset + length), targetOffset);
+		this.#offset += length;
+	}
+
+	readUnsignedLittleEndian16() {
+		const leastSignificantByte = this.readByte();
+		const mostSignificantByte = this.readByte();
+		return leastSignificantByte | (mostSignificantByte << 8);
+	}
+
+	readAsciiString(length) {
+		return asciiTextDecoder.decode(this.readBytes(length));
+	}
+}
+
+export class GIFByteWriter {
+	#bytes = new Uint8Array(1024);
+	#byteLength = 0;
+
+	#ensureCapacity(requiredCapacity) {
+		if (requiredCapacity <= this.#bytes.length) {
+			return;
+		}
+
+		const nextCapacity = Math.min(defaultMaximumEncodedByteLength, Math.max(requiredCapacity, this.#bytes.length * 2));
+		const nextBytes = new Uint8Array(nextCapacity);
+		nextBytes.set(uint8ArraySubarray.call(this.#bytes, 0, this.#byteLength));
+		this.#bytes = nextBytes;
+	}
+
+	writeByte(value) {
+		requireByteLengthWithinLimit(this.#byteLength + 1, defaultMaximumEncodedByteLength, 'encoded GIF');
+		this.#ensureCapacity(this.#byteLength + 1);
+		this.#bytes[this.#byteLength] = requireByte(value, 'byte');
+		this.#byteLength += 1;
+	}
+
+	writeBytes(values) {
+		if (isUint8Array(values)) {
+			const bytes = toUint8ArrayView(values);
+			requireByteLengthWithinLimit(this.#byteLength + bytes.length, defaultMaximumEncodedByteLength, 'encoded GIF');
+			this.#ensureCapacity(this.#byteLength + bytes.length);
+			this.#bytes.set(bytes, this.#byteLength);
+			this.#byteLength += bytes.length;
+			return;
+		}
+
+		requireByteLengthWithinLimit(this.#byteLength + values.length, defaultMaximumEncodedByteLength, 'encoded GIF');
+		this.#ensureCapacity(this.#byteLength + values.length);
+		for (const value of values) {
+			this.writeByte(value);
+		}
+	}
+
+	writeUnsignedLittleEndian16(value) {
+		const normalizedValue = requireUnsigned16(value, 'unsigned16');
+		this.writeByte(normalizedValue & 0xFF);
+		this.writeByte((normalizedValue >> 8) & 0xFF);
+	}
+
+	writeAsciiString(value) {
+		const encodedValue = asciiTextEncoder.encode(value);
+
+		for (const byte of encodedValue) {
+			this.writeByte(byte);
+		}
+	}
+
+	toUint8Array() {
+		return this.#bytes.slice(0, this.#byteLength);
+	}
+}

package/source/constants.js

@@ -0,0 +1,36 @@
+export const asciiTextEncoder = new TextEncoder();
+export const asciiTextDecoder = new TextDecoder('ascii', {fatal: false});
+export const uint8ArraySubarray = Uint8Array.prototype.subarray;
+
+export const extensionIntroducer = 0x21;
+export const imageSeparator = 0x2C;
+export const trailerByte = 0x3B;
+
+export const graphicControlExtensionLabel = 0xF9;
+export const commentExtensionLabel = 0xFE;
+export const plainTextExtensionLabel = 0x01;
+export const appExtensionLabel = 0xFF;
+
+export const netscapeLoopingAppIdentifier = 'NETSCAPE';
+export const netscapeLoopingAppAuthenticationCode = '2.0';
+export const netscapeLoopingAppAuthenticationCodeBytes = asciiTextEncoder.encode(netscapeLoopingAppAuthenticationCode);
+export const defaultMaximumPixelCount = 100_000_000;
+export const defaultMaximumRenderPixelCount = 16_777_216;
+export const defaultMaximumIndexedImagePixelCount = 16_777_216;
+export const defaultMaximumBlockCount = 100_000;
+export const defaultMaximumDataSubBlockCount = 300_000;
+export const defaultMaximumDataPayloadByteLength = 64 * 1024 * 1024;
+export const defaultMaximumEncodeWorkCost = defaultMaximumPixelCount;
+export const defaultMaximumEncodedByteLength = 256 * 1024 * 1024;
+
+// The fast render path writes packed 32-bit RGBA values, which only maps to Uint8ClampedArray byte order on little-endian platforms.
+const endiannessProbe = new Uint32Array([0x0A_0B_0C_0D]);
+
+export const isLittleEndian = new Uint8Array(endiannessProbe.buffer, endiannessProbe.byteOffset, endiannessProbe.byteLength)[0] === 0x0D;
+
+export const disposalMethodNames = [
+	'unspecified',
+	'keep',
+	'restoreBackground',
+	'restorePrevious',
+];