@cjser/sindresorhus__gifkit 0.1.0-cjser.2

package/dist-cjser/index.cjs

@@ -0,0 +1,2168 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/@cjser/sindresorhus__gifkit.tmp-26-1783615518957/index.js
+var index_exports = {};
+__export(index_exports, {
+  decodeAnimatedGIF: () => decodeAnimatedGIF,
+  decodeGIF: () => decodeGIF,
+  encodeAnimatedGIF: () => encodeAnimatedGIF,
+  encodeGIF: () => encodeGIF,
+  indexedImage: () => indexedImage,
+  renderGIFFrameSequence: () => renderGIFFrameSequence,
+  renderGIFFrames: () => renderGIFFrames
+});
+module.exports = __toCommonJS(index_exports);
+
+// packages/@cjser/sindresorhus__gifkit.tmp-26-1783615518957/source/constants.js
+var asciiTextEncoder = new TextEncoder();
+var asciiTextDecoder = new TextDecoder("ascii", { fatal: false });
+var uint8ArraySubarray = Uint8Array.prototype.subarray;
+var extensionIntroducer = 33;
+var imageSeparator = 44;
+var trailerByte = 59;
+var graphicControlExtensionLabel = 249;
+var commentExtensionLabel = 254;
+var plainTextExtensionLabel = 1;
+var appExtensionLabel = 255;
+var netscapeLoopingAppIdentifier = "NETSCAPE";
+var netscapeLoopingAppAuthenticationCode = "2.0";
+var netscapeLoopingAppAuthenticationCodeBytes = asciiTextEncoder.encode(netscapeLoopingAppAuthenticationCode);
+var defaultMaximumPixelCount = 1e8;
+var defaultMaximumRenderPixelCount = 16777216;
+var defaultMaximumIndexedImagePixelCount = 16777216;
+var defaultMaximumBlockCount = 1e5;
+var defaultMaximumDataSubBlockCount = 3e5;
+var defaultMaximumDataPayloadByteLength = 64 * 1024 * 1024;
+var defaultMaximumEncodeWorkCost = defaultMaximumPixelCount;
+var defaultMaximumEncodedByteLength = 256 * 1024 * 1024;
+var endiannessProbe = new Uint32Array([168496141]);
+var isLittleEndian = new Uint8Array(endiannessProbe.buffer, endiannessProbe.byteOffset, endiannessProbe.byteLength)[0] === 13;
+var disposalMethodNames = [
+  "unspecified",
+  "keep",
+  "restoreBackground",
+  "restorePrevious"
+];
+
+// packages/@cjser/sindresorhus__gifkit.tmp-26-1783615518957/source/validate.js
+var import_node_util = require("node:util");
+var typedArrayPrototype = Object.getPrototypeOf(Uint8Array.prototype);
+var typedArrayBufferGetter = Object.getOwnPropertyDescriptor(typedArrayPrototype, "buffer").get;
+var typedArrayByteOffsetGetter = Object.getOwnPropertyDescriptor(typedArrayPrototype, "byteOffset").get;
+var typedArrayByteLengthGetter = Object.getOwnPropertyDescriptor(typedArrayPrototype, "byteLength").get;
+function isUint8Array(value) {
+  return import_node_util.types.isUint8Array(value);
+}
+function isUint8ClampedArray(value) {
+  return import_node_util.types.isUint8ClampedArray(value);
+}
+function toUint8ArrayView(value) {
+  return new Uint8Array(
+    typedArrayBufferGetter.call(value),
+    typedArrayByteOffsetGetter.call(value),
+    typedArrayByteLengthGetter.call(value)
+  );
+}
+function normalizeByteArray(value, fieldName) {
+  const byteLength = value.length;
+  const bytes = new Uint8Array(byteLength);
+  let index = 0;
+  while (index < byteLength) {
+    bytes[index] = requireByte(value[index], `${fieldName}[${index}]`);
+    index += 1;
+  }
+  return bytes;
+}
+function areBytesEqual(leftBytes, rightBytes) {
+  if (leftBytes.length !== rightBytes.length) {
+    return false;
+  }
+  let index = 0;
+  while (index < leftBytes.length) {
+    if (leftBytes[index] !== rightBytes[index]) {
+      return false;
+    }
+    index += 1;
+  }
+  return true;
+}
+function isPowerOfTwo(value) {
+  return (value & value - 1) === 0;
+}
+function requireIntegerInRange(value, minimum, maximum, fieldName) {
+  if (!Number.isSafeInteger(value) || value < minimum || value > maximum) {
+    throw new Error(`${fieldName} must be an integer between ${minimum} and ${maximum}, got ${value}`);
+  }
+  return value;
+}
+function requireFiniteNumberInRange(value, minimum, maximum, fieldName) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < minimum || value > maximum) {
+    throw new Error(`${fieldName} must be a number between ${minimum} and ${maximum}, got ${value}`);
+  }
+  return value;
+}
+function requirePositiveFiniteNumber(value, fieldName) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    throw new Error(`${fieldName} must be a number greater than 0, got ${value}`);
+  }
+  return value;
+}
+function requireByte(value, fieldName) {
+  return requireIntegerInRange(value, 0, 255, fieldName);
+}
+function requireUnsigned16(value, fieldName) {
+  return requireIntegerInRange(value, 0, 65535, fieldName);
+}
+function requireNonZeroUnsigned16(value, fieldName) {
+  return requireIntegerInRange(value, 1, 65535, fieldName);
+}
+function requirePixelCountWithinLimit(width, height, maximumPixelCount, description) {
+  const pixelCount = width * height;
+  requirePixelCountValueWithinLimit(pixelCount, maximumPixelCount, description);
+  return pixelCount;
+}
+function requirePixelCountValueWithinLimit(pixelCount, maximumPixelCount, description) {
+  if (pixelCount > maximumPixelCount) {
+    throw new Error(`${description} has ${pixelCount} pixels, which exceeds the limit of ${maximumPixelCount}`);
+  }
+}
+function requireCountWithinLimit(count, maximumCount, description) {
+  if (count > maximumCount) {
+    throw new Error(`${description} ${count} exceeds the limit of ${maximumCount}`);
+  }
+}
+function requireByteLengthWithinLimit(byteLength, maximumByteLength, description) {
+  if (byteLength > maximumByteLength) {
+    throw new Error(`${description} has ${byteLength} bytes, which exceeds the limit of ${maximumByteLength}`);
+  }
+}
+function requireBlockObject(block) {
+  if (!block || typeof block !== "object") {
+    throw new TypeError("Each block must be an object");
+  }
+}
+function normalizeColorTable(value, fieldName) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (isUint8Array(value)) {
+    const bytes = toUint8ArrayView(value);
+    validateColorTableBytes(bytes, fieldName);
+    return bytes;
+  }
+  if (Array.isArray(value)) {
+    const flatBytes = normalizeColorTableArray(value, fieldName);
+    validateColorTableBytes(flatBytes, fieldName);
+    return flatBytes;
+  }
+  throw new TypeError(`${fieldName} must be undefined, a Uint8Array, a flat byte array, or an array of RGB triplets`);
+}
+function normalizeColorTableArray(value, fieldName) {
+  const colorTableLength = value.length;
+  if (colorTableLength === 0) {
+    throw new Error(`${fieldName} cannot be empty`);
+  }
+  if (colorTableLength > 768) {
+    throw new Error(`${fieldName} cannot contain more than 768 flat bytes or 256 RGB triplets`);
+  }
+  const flatEntryCount = colorTableLength / 3;
+  const canBeFlatByteArray = colorTableLength % 3 === 0 && flatEntryCount >= 2 && flatEntryCount <= 256 && isPowerOfTwo(flatEntryCount);
+  const canBeTripletArray = colorTableLength >= 2 && colorTableLength <= 256 && isPowerOfTwo(colorTableLength);
+  const firstElementDescriptor = canBeTripletArray && !canBeFlatByteArray ? Object.getOwnPropertyDescriptor(value, 0) : void 0;
+  const isTripletArray = firstElementDescriptor !== void 0 && "value" in firstElementDescriptor && Array.isArray(firstElementDescriptor.value);
+  if (isTripletArray) {
+    const flatArray = [];
+    let paletteIndex = 0;
+    while (paletteIndex < colorTableLength) {
+      const element = value[paletteIndex];
+      const triplet = normalizeSingleColorTriplet(element, `${fieldName}[${paletteIndex}]`);
+      flatArray.push(triplet[0], triplet[1], triplet[2]);
+      paletteIndex += 1;
+    }
+    return Uint8Array.from(flatArray);
+  }
+  if (!canBeFlatByteArray) {
+    validateColorTableEntryCountFromFlatLength(colorTableLength, fieldName);
+  }
+  return normalizeByteArray(value, fieldName);
+}
+function validateColorTableBytes(flatBytes, fieldName) {
+  if (flatBytes.length % 3 !== 0) {
+    throw new Error(`${fieldName} length must be divisible by 3`);
+  }
+  const entryCount = flatBytes.length / 3;
+  if (entryCount < 2 || entryCount > 256) {
+    throw new Error(`${fieldName} must contain between 2 and 256 entries, got ${entryCount}`);
+  }
+  if (!isPowerOfTwo(entryCount)) {
+    throw new Error(`${fieldName} must contain a power-of-two number of entries, got ${entryCount}`);
+  }
+}
+function validateColorTableEntryCountFromFlatLength(byteLength, fieldName) {
+  if (byteLength % 3 !== 0) {
+    throw new Error(`${fieldName} length must be divisible by 3`);
+  }
+  const entryCount = byteLength / 3;
+  if (entryCount < 2 || entryCount > 256) {
+    throw new Error(`${fieldName} must contain between 2 and 256 entries, got ${entryCount}`);
+  }
+  throw new Error(`${fieldName} must contain a power-of-two number of entries, got ${entryCount}`);
+}
+function normalizeSingleColorTriplet(value, fieldName) {
+  if (!Array.isArray(value) || value.length !== 3) {
+    throw new TypeError(`${fieldName} must be an array of exactly 3 bytes`);
+  }
+  return [
+    requireByte(value[0], `${fieldName}[0]`),
+    requireByte(value[1], `${fieldName}[1]`),
+    requireByte(value[2], `${fieldName}[2]`)
+  ];
+}
+function padColorTableToPowerOfTwo(colorTable) {
+  const entryCount = colorTable.length / 3;
+  if (entryCount === 0) {
+    throw new Error("Color table must contain at least one entry");
+  }
+  let paddedEntryCount = 2;
+  while (paddedEntryCount < entryCount) {
+    paddedEntryCount *= 2;
+  }
+  if (paddedEntryCount > 256) {
+    throw new Error("Color table cannot exceed 256 entries");
+  }
+  if (paddedEntryCount === entryCount) {
+    return colorTable;
+  }
+  const paddedColorTable = new Uint8Array(paddedEntryCount * 3);
+  paddedColorTable.set(colorTable);
+  const lastTripletOffset = Math.max(0, colorTable.length - 3);
+  for (let offset = colorTable.length; offset < paddedColorTable.length; offset += 3) {
+    paddedColorTable[offset] = colorTable[lastTripletOffset];
+    paddedColorTable[offset + 1] = colorTable[lastTripletOffset + 1];
+    paddedColorTable[offset + 2] = colorTable[lastTripletOffset + 2];
+  }
+  return paddedColorTable;
+}
+function calculateColorTableSizeField(colorTableEntryCount) {
+  if (!Number.isSafeInteger(colorTableEntryCount) || colorTableEntryCount < 2 || colorTableEntryCount > 256) {
+    throw new Error(`Color table must contain between 2 and 256 entries, got ${colorTableEntryCount}`);
+  }
+  if ((colorTableEntryCount & colorTableEntryCount - 1) !== 0) {
+    throw new Error(`Color table entry count must be a power of two, got ${colorTableEntryCount}`);
+  }
+  return Math.round(Math.log2(colorTableEntryCount)) - 1;
+}
+function deriveColorResolution(globalColorTable) {
+  if (globalColorTable === void 0) {
+    return 8;
+  }
+  const entryCount = globalColorTable.length / 3;
+  return Math.max(1, Math.ceil(Math.log2(entryCount)));
+}
+function deriveMinimumCodeSize(colorTableEntryCount) {
+  const clampedEntryCount = Math.max(2, colorTableEntryCount);
+  return Math.max(2, Math.ceil(Math.log2(clampedEntryCount)));
+}
+function normalizeIndexedPixels(value, expectedLength, fieldName) {
+  if (value === void 0) {
+    return void 0;
+  }
+  let indexedPixels;
+  if (isUint8Array(value)) {
+    indexedPixels = toUint8ArrayView(value);
+  } else if (Array.isArray(value)) {
+    if (value.length !== expectedLength) {
+      throw new Error(`${fieldName} length must be ${expectedLength}, got ${value.length}`);
+    }
+    indexedPixels = normalizeByteArray(value, fieldName);
+  } else {
+    throw new TypeError(`${fieldName} must be a Uint8Array or array of bytes`);
+  }
+  if (indexedPixels.length !== expectedLength) {
+    throw new Error(`${fieldName} length must be ${expectedLength}, got ${indexedPixels.length}`);
+  }
+  return indexedPixels;
+}
+function normalizeRedGreenBlueAlphaPixels(value, expectedLength, fieldName) {
+  let pixels;
+  if (isUint8Array(value) || isUint8ClampedArray(value)) {
+    pixels = toUint8ArrayView(value);
+  } else if (Array.isArray(value)) {
+    if (value.length !== expectedLength) {
+      throw new Error(`${fieldName} length must be ${expectedLength}, got ${value.length}`);
+    }
+    pixels = Uint8ClampedArray.from(normalizeByteArray(value, fieldName));
+  } else {
+    throw new TypeError(`${fieldName} must be a Uint8Array, Uint8ClampedArray, or array of bytes`);
+  }
+  if (pixels.length !== expectedLength) {
+    throw new Error(`${fieldName} length must be ${expectedLength}, got ${pixels.length}`);
+  }
+  return pixels;
+}
+function normalizeExtensionPayload(value, fieldName) {
+  if (typeof value === "string") {
+    return normalizeAsciiPayloadString(value, fieldName);
+  }
+  if (isUint8Array(value)) {
+    const bytes = toUint8ArrayView(value);
+    requireByteLengthWithinLimit(bytes.length, defaultMaximumDataPayloadByteLength, fieldName);
+    return bytes;
+  }
+  if (Array.isArray(value)) {
+    requireByteLengthWithinLimit(value.length, defaultMaximumDataPayloadByteLength, fieldName);
+    return normalizeByteArray(value, fieldName);
+  }
+  throw new TypeError(`${fieldName} must be a string, Uint8Array, or array of bytes`);
+}
+function normalizeAsciiPayloadString(value, fieldName) {
+  requireByteLengthWithinLimit(value.length, defaultMaximumDataPayloadByteLength, fieldName);
+  const bytes = new Uint8Array(value.length);
+  for (let index = 0; index < value.length; index += 1) {
+    const codeUnit = value.codePointAt(index);
+    if (codeUnit > 127) {
+      throw new Error(`${fieldName} must contain only ASCII characters`);
+    }
+    bytes[index] = codeUnit;
+  }
+  return bytes;
+}
+function normalizeFixedAsciiField(value, expectedLength, fieldName) {
+  if (typeof value !== "string") {
+    throw new TypeError(`${fieldName} must be a string`);
+  }
+  if (value.length !== expectedLength) {
+    throw new Error(`${fieldName} must be exactly ${expectedLength} ASCII bytes long`);
+  }
+  const encodedValue = asciiTextEncoder.encode(value);
+  if (encodedValue.length !== expectedLength) {
+    throw new Error(`${fieldName} must be exactly ${expectedLength} ASCII bytes long`);
+  }
+  for (const byte of encodedValue) {
+    if (byte < 32 || byte > 126) {
+      throw new Error(`${fieldName} must contain only printable ASCII characters`);
+    }
+  }
+  return value;
+}
+function normalizeFixedByteField(value, expectedLength, fieldName) {
+  if (typeof value === "string") {
+    if (value.length !== expectedLength) {
+      throw new Error(`${fieldName} must be exactly ${expectedLength} bytes long`);
+    }
+    const encodedValue = asciiTextEncoder.encode(value);
+    if (encodedValue.length !== expectedLength) {
+      throw new Error(`${fieldName} must be exactly ${expectedLength} bytes long`);
+    }
+    return encodedValue;
+  }
+  if (isUint8Array(value)) {
+    const bytes = toUint8ArrayView(value);
+    if (bytes.length !== expectedLength) {
+      throw new Error(`${fieldName} must be exactly ${expectedLength} bytes long`);
+    }
+    return bytes;
+  }
+  if (Array.isArray(value)) {
+    if (value.length !== expectedLength) {
+      throw new Error(`${fieldName} must be exactly ${expectedLength} bytes long`);
+    }
+    return normalizeByteArray(value, fieldName);
+  }
+  throw new TypeError(`${fieldName} must be a string, Uint8Array, or array of bytes`);
+}
+function normalizeImageGeometry(block, { logicalScreenWidth, logicalScreenHeight }) {
+  const left = requireUnsigned16(block.left ?? 0, "image.left");
+  const top = requireUnsigned16(block.top ?? 0, "image.top");
+  const width = requireNonZeroUnsigned16(block.width, "image.width");
+  const height = requireNonZeroUnsigned16(block.height, "image.height");
+  if (left + width > logicalScreenWidth || top + height > logicalScreenHeight) {
+    throw new Error("Image block extends beyond the logical screen bounds");
+  }
+  requirePixelCountWithinLimit(width, height, defaultMaximumPixelCount, "image block");
+  return {
+    left,
+    top,
+    width,
+    height
+  };
+}
+function secondsToHundredthsOfASecond(seconds, fieldName) {
+  const value = requireFiniteNumberInRange(seconds, 0, 655.35, fieldName);
+  return requireUnsigned16(Math.round(value * 100), `${fieldName} in hundredths of a second`);
+}
+function normalizeGraphicControlExtension(graphicControlExtension) {
+  if (graphicControlExtension === void 0) {
+    return void 0;
+  }
+  if (typeof graphicControlExtension !== "object" || graphicControlExtension === null) {
+    throw new TypeError("graphicControlExtension must be an object or undefined");
+  }
+  return {
+    disposalMethod: normalizeDisposalMethod(graphicControlExtension.disposalMethod ?? "unspecified"),
+    delayInHundredthsOfASecond: secondsToHundredthsOfASecond(graphicControlExtension.delay ?? 0, "graphicControlExtension.delay"),
+    transparentColorIndex: graphicControlExtension.transparentColorIndex === void 0 ? void 0 : requireByte(graphicControlExtension.transparentColorIndex, "graphicControlExtension.transparentColorIndex")
+  };
+}
+function normalizeDisposalMethod(disposalMethod) {
+  if (!disposalMethodNames.includes(disposalMethod)) {
+    throw new Error(`graphicControlExtension.disposalMethod must be one of ${disposalMethodNames.map((value) => JSON.stringify(value)).join(", ")}, got ${JSON.stringify(disposalMethod)}`);
+  }
+  return disposalMethod;
+}
+function disposalMethodByte(disposalMethod) {
+  return disposalMethodNames.indexOf(disposalMethod);
+}
+
+// packages/@cjser/sindresorhus__gifkit.tmp-26-1783615518957/source/byte-stream.js
+var GIFByteReader = class {
+  #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));
+  }
+};
+var GIFByteWriter = class {
+  #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 & 255);
+    this.writeByte(normalizedValue >> 8 & 255);
+  }
+  writeAsciiString(value) {
+    const encodedValue = asciiTextEncoder.encode(value);
+    for (const byte of encodedValue) {
+      this.writeByte(byte);
+    }
+  }
+  toUint8Array() {
+    return this.#bytes.slice(0, this.#byteLength);
+  }
+};
+
+// packages/@cjser/sindresorhus__gifkit.tmp-26-1783615518957/source/lzw.js
+function decodeCompressedIndexStream(compressedData, minimumCodeSize, expectedPixelCount, { strict, colorTableEntryCount }) {
+  const clearCode = 1 << minimumCodeSize;
+  const endOfInformationCode = clearCode + 1;
+  const context = {
+    compressedData,
+    clearCode,
+    endOfInformationCode,
+    minimumCodeSize,
+    prefixCodes: new Int16Array(4096),
+    suffixBytes: new Uint8Array(4096),
+    outputStack: new Uint8Array(4097),
+    decodedPixels: new Uint8Array(expectedPixelCount),
+    codeSize: minimumCodeSize + 1,
+    nextAvailableCode: clearCode + 2,
+    bitBuffer: 0,
+    bitCount: 0,
+    dataOffset: 0,
+    previousCode: -1,
+    outputOffset: 0,
+    firstByteOfCurrentString: 0,
+    currentStackLength: 0,
+    currentFirstByte: 0,
+    colorTableEntryCount,
+    hasReadAnyCode: false
+  };
+  resetLzwDictionary(context);
+  while (true) {
+    const currentCode = readNextLzwCode(context);
+    validateFirstLzwCode(context, currentCode, { strict });
+    if (currentCode === context.clearCode) {
+      resetLzwDictionary(context);
+      continue;
+    }
+    if (currentCode === context.endOfInformationCode) {
+      validateNoUnusedCompressedData(context, { strict });
+      break;
+    }
+    expandLzwCode(context, currentCode);
+    copyLzwStackToPixels(context, expectedPixelCount);
+    addLzwDictionaryEntry(context);
+    context.previousCode = currentCode;
+  }
+  if (context.outputOffset !== expectedPixelCount) {
+    throw new Error(`Expected ${expectedPixelCount} pixel indices, decoded ${context.outputOffset}`);
+  }
+  return context.decodedPixels;
+}
+function resetLzwDictionary(context) {
+  for (let index = 0; index < context.clearCode; index += 1) {
+    context.prefixCodes[index] = -1;
+    context.suffixBytes[index] = index;
+  }
+  context.codeSize = context.minimumCodeSize + 1;
+  context.nextAvailableCode = context.clearCode + 2;
+  context.previousCode = -1;
+}
+function readNextLzwCode(context) {
+  while (context.bitCount < context.codeSize) {
+    if (context.dataOffset >= context.compressedData.length) {
+      throw new Error("Unexpected end of compressed image data before End of Information code");
+    }
+    context.bitBuffer |= context.compressedData[context.dataOffset] << context.bitCount;
+    context.bitCount += 8;
+    context.dataOffset += 1;
+  }
+  const currentCode = context.bitBuffer & (1 << context.codeSize) - 1;
+  context.bitBuffer >>= context.codeSize;
+  context.bitCount -= context.codeSize;
+  return currentCode;
+}
+function validateFirstLzwCode(context, currentCode, { strict }) {
+  if (context.hasReadAnyCode) {
+    return;
+  }
+  context.hasReadAnyCode = true;
+  if (strict && currentCode !== context.clearCode) {
+    throw new Error("LZW image data must start with a Clear code");
+  }
+}
+function validateNoUnusedCompressedData(context, { strict }) {
+  if (strict && context.dataOffset < context.compressedData.length) {
+    throw new Error("Found unused compressed image data after the End of Information code");
+  }
+}
+function expandLzwCode(context, currentCode) {
+  if (currentCode > context.nextAvailableCode) {
+    throw new Error(`Encountered invalid compressed code ${currentCode}`);
+  }
+  let stackLength = 0;
+  let codeToExpand = currentCode;
+  if (currentCode === context.nextAvailableCode) {
+    if (context.previousCode === -1) {
+      throw new Error("Encountered a dictionary-reference code before any previous code existed");
+    }
+    context.outputStack[stackLength] = context.firstByteOfCurrentString;
+    stackLength += 1;
+    codeToExpand = context.previousCode;
+  }
+  while (codeToExpand > context.clearCode + 1) {
+    context.outputStack[stackLength] = context.suffixBytes[codeToExpand];
+    stackLength += 1;
+    codeToExpand = context.prefixCodes[codeToExpand];
+    if (stackLength >= context.outputStack.length) {
+      throw new Error("Compressed code expansion overflowed the output stack");
+    }
+  }
+  const firstByte = context.suffixBytes[codeToExpand];
+  context.outputStack[stackLength] = firstByte;
+  stackLength += 1;
+  context.firstByteOfCurrentString = firstByte;
+  context.currentStackLength = stackLength;
+  context.currentFirstByte = firstByte;
+}
+function copyLzwStackToPixels(context, expectedPixelCount) {
+  for (let stackIndex = context.currentStackLength - 1; stackIndex >= 0; stackIndex -= 1) {
+    if (context.outputOffset >= expectedPixelCount) {
+      throw new Error("Decompressed more pixels than the image dimensions allow");
+    }
+    const pixelIndex = context.outputStack[stackIndex];
+    if (context.colorTableEntryCount !== void 0 && pixelIndex >= context.colorTableEntryCount) {
+      throw new Error(`Pixel ${context.outputOffset} uses palette index ${pixelIndex}, but the active color table only has ${context.colorTableEntryCount} entries`);
+    }
+    context.decodedPixels[context.outputOffset] = pixelIndex;
+    context.outputOffset += 1;
+  }
+}
+function addLzwDictionaryEntry(context) {
+  if (context.previousCode === -1 || context.nextAvailableCode >= 4096) {
+    return;
+  }
+  context.prefixCodes[context.nextAvailableCode] = context.previousCode;
+  context.suffixBytes[context.nextAvailableCode] = context.currentFirstByte;
+  context.nextAvailableCode += 1;
+  if (context.nextAvailableCode === 1 << context.codeSize && context.codeSize < 12) {
+    context.codeSize += 1;
+  }
+}
+function encodeCompressedIndexStream(indexedPixels, minimumCodeSize) {
+  const clearCode = 1 << minimumCodeSize;
+  const endOfInformationCode = clearCode + 1;
+  const codeSequence = [clearCode];
+  if (indexedPixels.length === 0) {
+    codeSequence.push(endOfInformationCode);
+    return packCompressedCodeSequence(codeSequence, minimumCodeSize);
+  }
+  if (indexedPixels.length < 4096) {
+    return encodeCompressedIndexStreamWithMap(indexedPixels, minimumCodeSize);
+  }
+  return encodeCompressedIndexStreamWithDenseLookup(indexedPixels, minimumCodeSize);
+}
+function encodeCompressedIndexStreamWithMap(indexedPixels, minimumCodeSize) {
+  const clearCode = 1 << minimumCodeSize;
+  const endOfInformationCode = clearCode + 1;
+  let nextAvailableCode = clearCode + 2;
+  const codeLookup = /* @__PURE__ */ new Map();
+  const codeSequence = [clearCode];
+  function resetDictionary() {
+    codeLookup.clear();
+    nextAvailableCode = clearCode + 2;
+  }
+  let currentCode = indexedPixels[0];
+  for (let index = 1; index < indexedPixels.length; index += 1) {
+    const nextPixelIndex = indexedPixels[index];
+    const dictionaryKey = currentCode << 8 | nextPixelIndex;
+    const combinedCode = codeLookup.get(dictionaryKey);
+    if (combinedCode !== void 0) {
+      currentCode = combinedCode;
+      continue;
+    }
+    codeSequence.push(currentCode);
+    if (nextAvailableCode < 4096) {
+      codeLookup.set(dictionaryKey, nextAvailableCode);
+      nextAvailableCode += 1;
+    } else {
+      codeSequence.push(clearCode);
+      resetDictionary();
+    }
+    currentCode = nextPixelIndex;
+  }
+  codeSequence.push(currentCode, endOfInformationCode);
+  return packCompressedCodeSequence(codeSequence, minimumCodeSize);
+}
+function encodeCompressedIndexStreamWithDenseLookup(indexedPixels, minimumCodeSize) {
+  const clearCode = 1 << minimumCodeSize;
+  const endOfInformationCode = clearCode + 1;
+  let nextAvailableCode = clearCode + 2;
+  const codeLookup = new Uint16Array(4096 * 256);
+  const touchedDictionaryKeys = new Uint32Array(4096);
+  let touchedDictionaryKeyCount = 0;
+  const codeSequence = [clearCode];
+  function resetDictionary() {
+    for (let index = 0; index < touchedDictionaryKeyCount; index += 1) {
+      codeLookup[touchedDictionaryKeys[index]] = 0;
+    }
+    touchedDictionaryKeyCount = 0;
+    nextAvailableCode = clearCode + 2;
+  }
+  let currentCode = indexedPixels[0];
+  for (let index = 1; index < indexedPixels.length; index += 1) {
+    const nextPixelIndex = indexedPixels[index];
+    const dictionaryKey = currentCode << 8 | nextPixelIndex;
+    const combinedCode = codeLookup[dictionaryKey];
+    if (combinedCode !== 0) {
+      currentCode = combinedCode;
+      continue;
+    }
+    codeSequence.push(currentCode);
+    if (nextAvailableCode < 4096) {
+      codeLookup[dictionaryKey] = nextAvailableCode;
+      touchedDictionaryKeys[touchedDictionaryKeyCount] = dictionaryKey;
+      touchedDictionaryKeyCount += 1;
+      nextAvailableCode += 1;
+    } else {
+      codeSequence.push(clearCode);
+      resetDictionary();
+    }
+    currentCode = nextPixelIndex;
+  }
+  codeSequence.push(currentCode, endOfInformationCode);
+  return packCompressedCodeSequence(codeSequence, minimumCodeSize);
+}
+function packCompressedCodeSequence(codeSequence, minimumCodeSize) {
+  const clearCode = 1 << minimumCodeSize;
+  const endOfInformationCode = clearCode + 1;
+  let codeSize = minimumCodeSize + 1;
+  let nextAvailableCode = clearCode + 2;
+  let previousCode;
+  let bitBuffer = 0;
+  let bitCount = 0;
+  const packedBytes = [];
+  for (const code of codeSequence) {
+    bitBuffer |= code << bitCount;
+    bitCount += codeSize;
+    while (bitCount >= 8) {
+      packedBytes.push(bitBuffer & 255);
+      bitBuffer >>= 8;
+      bitCount -= 8;
+    }
+    if (code === clearCode) {
+      codeSize = minimumCodeSize + 1;
+      nextAvailableCode = clearCode + 2;
+      previousCode = void 0;
+      continue;
+    }
+    if (code === endOfInformationCode) {
+      break;
+    }
+    if (previousCode !== void 0 && nextAvailableCode < 4096) {
+      nextAvailableCode += 1;
+      if (nextAvailableCode === 1 << codeSize && codeSize < 12) {
+        codeSize += 1;
+      }
+    }
+    previousCode = code;
+  }
+  if (bitCount > 0) {
+    packedBytes.push(bitBuffer & 255);
+  }
+  return Uint8Array.from(packedBytes);
+}
+
+// packages/@cjser/sindresorhus__gifkit.tmp-26-1783615518957/source/loop-count.js
+function renderTotalPlayCount(playCount) {
+  return playCount === "forever" ? Infinity : playCount ?? 1;
+}
+function normalizePlayCount(value, name) {
+  if (value === "forever") {
+    return value;
+  }
+  return requireIntegerInRange(value, 1, 65536, name);
+}
+function encodeNetscapeLoopCount(playCount, name) {
+  if (playCount === "forever") {
+    return 0;
+  }
+  return requireIntegerInRange(playCount, 1, 65536, name) - 1;
+}
+function encodeExplicitNetscapeLoopCount(playCount, name) {
+  if (playCount === "forever") {
+    return 0;
+  }
+  return requireIntegerInRange(playCount, 2, 65536, name) - 1;
+}
+function decodeNetscapeLoopCount(loopCount) {
+  return loopCount === 0 ? "forever" : loopCount + 1;
+}
+function rejectRenamedLoopCount(object) {
+  if (object.loopCount !== void 0) {
+    throw new TypeError("loopCount has been renamed to playCount");
+  }
+}
+function containsNetscapeLoopingAppExtension(blocks) {
+  for (const block of blocks) {
+    if (isNetscapeLoopingAppExtension(block)) {
+      return true;
+    }
+  }
+  return false;
+}
+function createNetscapeLoopingAppExtension(loopCount) {
+  return {
+    type: "applicationExtension",
+    identifier: netscapeLoopingAppIdentifier,
+    authenticationCode: netscapeLoopingAppAuthenticationCode,
+    data: Uint8Array.of(1, loopCount & 255, loopCount >> 8 & 255)
+  };
+}
+function isNetscapeLoopingAppExtension(block) {
+  return block.type === "applicationExtension" && block.identifier === netscapeLoopingAppIdentifier && block.data.length >= 3 && block.data[0] === 1 && areBytesEqual(normalizeFixedByteField(block.authenticationCode, 3, "applicationExtension.authenticationCode"), netscapeLoopingAppAuthenticationCodeBytes);
+}
+
+// packages/@cjser/sindresorhus__gifkit.tmp-26-1783615518957/source/decode.js
+function decodeGIF(inputBytes, options = {}) {
+  const {
+    strict = true
+  } = options;
+  const byteReader = new GIFByteReader(inputBytes);
+  const header = readGIFHeader(byteReader, { strict });
+  const stream = readGIFBlockStream(byteReader, {
+    ...header,
+    strict
+  });
+  if (strict && byteReader.offset !== byteReader.length) {
+    throw new Error(`Found ${byteReader.length - byteReader.offset} trailing byte(s) after the GIF trailer`);
+  }
+  return {
+    type: "gif",
+    version: header.version,
+    width: header.logicalScreenWidth,
+    height: header.logicalScreenHeight,
+    backgroundColorIndex: header.backgroundColorIndex,
+    globalColorTable: header.globalColorTable,
+    ...stream.playCount !== void 0 && { playCount: stream.playCount },
+    blocks: stream.blocks,
+    imageBlocks: stream.imageBlocks
+  };
+}
+function readGIFHeader(byteReader, { strict }) {
+  const signature = byteReader.readAsciiString(3);
+  if (signature !== "GIF") {
+    throw new Error(`Expected GIF signature, got ${JSON.stringify(signature)}`);
+  }
+  const version = byteReader.readAsciiString(3);
+  if (version !== "87a" && version !== "89a") {
+    throw new Error(`Unsupported GIF version ${JSON.stringify(version)}`);
+  }
+  const logicalScreenWidth = byteReader.readUnsignedLittleEndian16();
+  const logicalScreenHeight = byteReader.readUnsignedLittleEndian16();
+  if (strict && (logicalScreenWidth === 0 || logicalScreenHeight === 0)) {
+    throw new Error("Logical Screen dimensions must be non-zero in strict mode");
+  }
+  const packedLogicalScreenField = byteReader.readByte();
+  const hasGlobalColorTable = (packedLogicalScreenField & 128) !== 0;
+  const globalColorTableSizeField = packedLogicalScreenField & 7;
+  const backgroundColorIndex = byteReader.readByte();
+  byteReader.readByte();
+  const globalColorTable = hasGlobalColorTable ? readColorTable(byteReader, globalColorTableSizeField) : void 0;
+  if (strict && globalColorTable !== void 0 && backgroundColorIndex >= globalColorTable.length / 3) {
+    throw new Error("Background color index must be inside the global color table in strict mode");
+  }
+  if (strict && globalColorTable === void 0 && backgroundColorIndex !== 0) {
+    throw new Error("Background color index must be zero when there is no global color table in strict mode");
+  }
+  return {
+    version,
+    logicalScreenWidth,
+    logicalScreenHeight,
+    backgroundColorIndex,
+    globalColorTable
+  };
+}
+function readGIFBlockStream(byteReader, { version, logicalScreenWidth, logicalScreenHeight, globalColorTable, strict }) {
+  const blocks = [];
+  const imageBlocks = [];
+  let pendingGraphicControlExtension;
+  let playCount;
+  let blockCount = 0;
+  while (true) {
+    const nextByte = byteReader.readByte();
+    if (nextByte === trailerByte) {
+      break;
+    }
+    blockCount += 1;
+    requireCountWithinLimit(blockCount, defaultMaximumBlockCount, "block count");
+    if (nextByte === imageSeparator) {
+      const imageBlock = readImageBlock({
+        byteReader,
+        logicalScreenWidth,
+        logicalScreenHeight,
+        globalColorTable,
+        graphicControlExtension: pendingGraphicControlExtension,
+        strict
+      });
+      blocks.push(imageBlock);
+      imageBlocks.push(imageBlock);
+      pendingGraphicControlExtension = void 0;
+      continue;
+    }
+    if (nextByte !== extensionIntroducer) {
+      throw new Error(`Unexpected block introducer 0x${nextByte.toString(16).padStart(2, "0")} at byte offset ${byteReader.offset - 1}`);
+    }
+    const extensionLabel = byteReader.readByte();
+    if (strict && version === "87a" && isGIF89aExtensionLabel(extensionLabel)) {
+      throw new Error(`GIF87a streams cannot contain extension label 0x${extensionLabel.toString(16).padStart(2, "0")}`);
+    }
+    switch (extensionLabel) {
+      case graphicControlExtensionLabel: {
+        if (pendingGraphicControlExtension !== void 0 && strict) {
+          throw new Error("A second Graphic Control Extension appeared before a graphic rendering block");
+        }
+        pendingGraphicControlExtension = readGraphicControlExtension(byteReader, { strict });
+        break;
+      }
+      case commentExtensionLabel: {
+        const commentBlock = {
+          type: "commentExtension",
+          data: readDataSubBlocks(byteReader)
+        };
+        blocks.push(commentBlock);
+        break;
+      }
+      case plainTextExtensionLabel: {
+        blocks.push(readUnknownExtension(byteReader, plainTextExtensionLabel));
+        pendingGraphicControlExtension = void 0;
+        break;
+      }
+      case appExtensionLabel: {
+        const appBlock = readAppExtension(byteReader, { strict });
+        blocks.push(appBlock);
+        if (isNetscapeLoopingAppExtension(appBlock)) {
+          playCount = decodeNetscapeLoopCount(appBlock.data[1] | appBlock.data[2] << 8);
+          appBlock.isNetscapeLoopingExtension = true;
+          appBlock.playCount = playCount;
+        }
+        break;
+      }
+      default: {
+        const unknownExtensionBlock = version === "87a" ? readGIF87aUnknownExtension(byteReader, extensionLabel) : readUnknownExtension(byteReader, extensionLabel);
+        blocks.push(unknownExtensionBlock);
+        if (isGraphicRenderingExtensionLabel(extensionLabel)) {
+          pendingGraphicControlExtension = void 0;
+        }
+        break;
+      }
+    }
+  }
+  if (pendingGraphicControlExtension !== void 0 && strict) {
+    throw new Error("A Graphic Control Extension was not followed by a graphic rendering block");
+  }
+  return {
+    playCount,
+    blocks,
+    imageBlocks
+  };
+}
+function readImageBlock({ byteReader, logicalScreenWidth, logicalScreenHeight, globalColorTable, graphicControlExtension, strict }) {
+  const descriptor = readImageDescriptor(byteReader, {
+    logicalScreenWidth,
+    logicalScreenHeight,
+    strict
+  });
+  const {
+    left,
+    top,
+    width,
+    height,
+    hasLocalColorTable,
+    isInterlaced,
+    colorTableSizeField
+  } = descriptor;
+  const colorTable = hasLocalColorTable ? readColorTable(byteReader, colorTableSizeField) : void 0;
+  const activeColorTable = colorTable ?? globalColorTable;
+  if (strict && activeColorTable === void 0) {
+    throw new Error("Image block requires an active color table in strict mode");
+  }
+  validateTransparentColorIndex(graphicControlExtension, activeColorTable, { strict });
+  const minimumCodeSize = byteReader.readByte();
+  if (minimumCodeSize < 2 || minimumCodeSize > 8) {
+    throw new Error(`Invalid minimum code size ${minimumCodeSize}; GIF requires a value between 2 and 8`);
+  }
+  const compressedData = readDataSubBlocks(byteReader);
+  const expectedPixelCount = width * height;
+  const colorTableEntryCount = strict && activeColorTable !== void 0 ? activeColorTable.length / 3 : void 0;
+  let indexedPixels = decodeCompressedIndexStream(compressedData, minimumCodeSize, expectedPixelCount, {
+    strict,
+    colorTableEntryCount
+  });
+  if (isInterlaced) {
+    indexedPixels = deinterlaceIndexedPixels(indexedPixels, width, height);
+  }
+  return {
+    type: "image",
+    graphicControlExtension: graphicControlExtension === void 0 ? void 0 : { ...graphicControlExtension },
+    left,
+    top,
+    width,
+    height,
+    isInterlaced,
+    colorTable,
+    minimumCodeSize,
+    pixels: indexedPixels
+  };
+}
+function readImageDescriptor(byteReader, { logicalScreenWidth, logicalScreenHeight, strict }) {
+  const left = byteReader.readUnsignedLittleEndian16();
+  const top = byteReader.readUnsignedLittleEndian16();
+  const width = byteReader.readUnsignedLittleEndian16();
+  const height = byteReader.readUnsignedLittleEndian16();
+  if (strict && (width === 0 || height === 0)) {
+    throw new Error("Image block dimensions must be non-zero in strict mode");
+  }
+  const packedImageField = byteReader.readByte();
+  const hasLocalColorTable = (packedImageField & 128) !== 0;
+  const isInterlaced = (packedImageField & 64) !== 0;
+  const reservedBits = packedImageField >> 3 & 3;
+  if (strict && reservedBits !== 0) {
+    throw new Error("Image Descriptor reserved bits must be zero");
+  }
+  if (left + width > logicalScreenWidth || top + height > logicalScreenHeight) {
+    throw new Error("Image block extends beyond the logical screen bounds");
+  }
+  const colorTableSizeField = packedImageField & 7;
+  requirePixelCountWithinLimit(width, height, defaultMaximumPixelCount, "image block");
+  return {
+    left,
+    top,
+    width,
+    height,
+    hasLocalColorTable,
+    isInterlaced,
+    colorTableSizeField
+  };
+}
+function validateTransparentColorIndex(graphicControlExtension, activeColorTable, { strict }) {
+  if (strict && (graphicControlExtension == null ? void 0 : graphicControlExtension.transparentColorIndex) !== void 0 && activeColorTable !== void 0 && graphicControlExtension.transparentColorIndex >= activeColorTable.length / 3) {
+    throw new Error("Transparent color index must be inside the active color table in strict mode");
+  }
+}
+function readGraphicControlExtension(byteReader, { strict }) {
+  const blockSize = byteReader.readByte();
+  if (blockSize !== 4) {
+    throw new Error(`Invalid Graphic Control Extension block size ${blockSize}; expected 4`);
+  }
+  const packedField = byteReader.readByte();
+  const reservedBits = packedField >> 5;
+  if (reservedBits !== 0 && strict) {
+    throw new Error("Graphic Control Extension reserved bits must be zero");
+  }
+  const disposalMethodField = packedField >> 2 & 7;
+  if (strict && disposalMethodField >= disposalMethodNames.length) {
+    throw new Error("Disposal methods 4-7 are reserved in the GIF89a specification");
+  }
+  const isTransparencyFlag = (packedField & 1) !== 0;
+  const delayInHundredthsOfASecond = byteReader.readUnsignedLittleEndian16();
+  const transparentColorIndex = byteReader.readByte();
+  const blockTerminator = byteReader.readByte();
+  if (blockTerminator !== 0) {
+    throw new Error("Graphic Control Extension is missing its block terminator");
+  }
+  return {
+    disposalMethod: disposalMethodNames[disposalMethodField] ?? "unspecified",
+    delay: delayInHundredthsOfASecond / 100,
+    transparentColorIndex: isTransparencyFlag ? transparentColorIndex : void 0
+  };
+}
+function readAppExtension(byteReader, { strict }) {
+  const blockSize = byteReader.readByte();
+  if (blockSize !== 11) {
+    throw new Error(`Invalid Application Extension block size ${blockSize}; expected 11`);
+  }
+  const identifier = byteReader.readAsciiString(8);
+  if (strict && new RegExp("[^\\u{20}-\\u{7E}]", "v").test(identifier)) {
+    throw new Error("Application Identifier must use printable ASCII characters");
+  }
+  const authenticationCode = byteReader.readBytes(3);
+  const data = readDataSubBlocks(byteReader);
+  return {
+    type: "applicationExtension",
+    identifier,
+    authenticationCode,
+    data
+  };
+}
+function isGIF89aExtensionLabel(extensionLabel) {
+  return [
+    graphicControlExtensionLabel,
+    commentExtensionLabel,
+    plainTextExtensionLabel,
+    appExtensionLabel
+  ].includes(extensionLabel);
+}
+function readUnknownExtension(byteReader, extensionLabel) {
+  const fixedBlockSize = byteReader.readByte();
+  const fixedData = byteReader.readBytes(fixedBlockSize);
+  if (fixedBlockSize === 0) {
+    return {
+      type: "unknownExtension",
+      extensionLabel,
+      fixedData,
+      data: new Uint8Array()
+    };
+  }
+  const data = readDataSubBlocks(byteReader);
+  return {
+    type: "unknownExtension",
+    extensionLabel,
+    fixedData,
+    data
+  };
+}
+function readGIF87aUnknownExtension(byteReader, extensionLabel) {
+  return {
+    type: "unknownExtension",
+    extensionLabel,
+    fixedData: new Uint8Array(),
+    data: readDataSubBlocks(byteReader)
+  };
+}
+function isGraphicRenderingExtensionLabel(extensionLabel) {
+  return extensionLabel <= 127 && extensionLabel !== trailerByte;
+}
+function readDataSubBlocks(byteReader) {
+  let concatenatedData = new Uint8Array(1024);
+  let totalLength = 0;
+  let subBlockCount = 0;
+  while (true) {
+    const blockSize = byteReader.readByte();
+    if (blockSize === 0) {
+      break;
+    }
+    subBlockCount += 1;
+    requireCountWithinLimit(subBlockCount, defaultMaximumDataSubBlockCount, "data sub-block count");
+    const nextTotalLength = totalLength + blockSize;
+    requireByteLengthWithinLimit(nextTotalLength, defaultMaximumDataPayloadByteLength, "data payload");
+    if (nextTotalLength > concatenatedData.length) {
+      const nextCapacity = Math.min(defaultMaximumDataPayloadByteLength, Math.max(nextTotalLength, concatenatedData.length * 2));
+      const nextConcatenatedData = new Uint8Array(nextCapacity);
+      nextConcatenatedData.set(uint8ArraySubarray.call(concatenatedData, 0, totalLength));
+      concatenatedData = nextConcatenatedData;
+    }
+    byteReader.readBytesInto(concatenatedData, totalLength, blockSize);
+    totalLength = nextTotalLength;
+  }
+  return concatenatedData.slice(0, totalLength);
+}
+function readColorTable(byteReader, sizeField) {
+  const entryCount = 1 << sizeField + 1;
+  const byteLength = entryCount * 3;
+  return byteReader.readBytes(byteLength);
+}
+function deinterlaceIndexedPixels(indexedPixels, width, height) {
+  const deinterlacedPixels = new Uint8Array(indexedPixels.length);
+  let sourceOffset = 0;
+  for (const [startRow, rowStep] of [[0, 8], [4, 8], [2, 4], [1, 2]]) {
+    for (let row = startRow; row < height; row += rowStep) {
+      const destinationOffset = row * width;
+      deinterlacedPixels.set(uint8ArraySubarray.call(indexedPixels, sourceOffset, sourceOffset + width), destinationOffset);
+      sourceOffset += width;
+    }
+  }
+  return deinterlacedPixels;
+}
+
+// packages/@cjser/sindresorhus__gifkit.tmp-26-1783615518957/source/quantize.js
+function indexedImage(pixels, options = {}) {
+  const {
+    transparentColor = [0, 0, 0]
+  } = options;
+  if (!isUint8Array(pixels) && !isUint8ClampedArray(pixels)) {
+    throw new TypeError("Expected pixels to be a Uint8Array or Uint8ClampedArray");
+  }
+  const redGreenBlueAlphaBytes = toUint8ArrayView(pixels);
+  if (redGreenBlueAlphaBytes.length % 4 !== 0) {
+    throw new Error("pixels length must be divisible by 4");
+  }
+  requirePixelCountValueWithinLimit(redGreenBlueAlphaBytes.length / 4, defaultMaximumIndexedImagePixelCount, "pixels");
+  const [transparentRed, transparentGreen, transparentBlue] = normalizeSingleColorTriplet(transparentColor, "transparentColor");
+  const paletteLookup = /* @__PURE__ */ new Map();
+  const palette = [];
+  const indexedPixels = new Uint8Array(redGreenBlueAlphaBytes.length / 4);
+  let transparentColorIndex;
+  for (let pixelOffset = 0, pixelIndex = 0; pixelOffset < redGreenBlueAlphaBytes.length; pixelOffset += 4, pixelIndex += 1) {
+    const red = redGreenBlueAlphaBytes[pixelOffset];
+    const green = redGreenBlueAlphaBytes[pixelOffset + 1];
+    const blue = redGreenBlueAlphaBytes[pixelOffset + 2];
+    const alpha = redGreenBlueAlphaBytes[pixelOffset + 3];
+    if (alpha !== 0 && alpha !== 255) {
+      throw new Error(`Pixel ${pixelIndex} has alpha ${alpha}; GIF only supports fully transparent or fully opaque pixels`);
+    }
+    if (alpha === 0) {
+      if (transparentColorIndex === void 0) {
+        transparentColorIndex = palette.length / 3;
+        palette.push(transparentRed, transparentGreen, transparentBlue);
+      }
+      indexedPixels[pixelIndex] = transparentColorIndex;
+      continue;
+    }
+    const lookupKey = `${red},${green},${blue}`;
+    let paletteIndex = paletteLookup.get(lookupKey);
+    if (paletteIndex === void 0) {
+      paletteIndex = palette.length / 3;
+      if (paletteIndex >= 256) {
+        throw new Error("The image uses more than 256 palette entries");
+      }
+      palette.push(red, green, blue);
+      paletteLookup.set(lookupKey, paletteIndex);
+    }
+    indexedPixels[pixelIndex] = paletteIndex;
+  }
+  const colorTable = padColorTableToPowerOfTwo(Uint8Array.from(palette));
+  return {
+    pixels: indexedPixels,
+    colorTable,
+    transparentColorIndex
+  };
+}
+function normalizeRGBAImageData(pixels, block, graphicControlExtension) {
+  const indexedImageData = indexedImage(pixels, {
+    transparentColor: block.transparentColor ?? [0, 0, 0]
+  });
+  const normalizedGraphicControlExtension = indexedImageData.transparentColorIndex !== void 0 || graphicControlExtension !== void 0 ? {
+    disposalMethod: (graphicControlExtension == null ? void 0 : graphicControlExtension.disposalMethod) ?? "unspecified",
+    delayInHundredthsOfASecond: (graphicControlExtension == null ? void 0 : graphicControlExtension.delayInHundredthsOfASecond) ?? 0,
+    transparentColorIndex: indexedImageData.transparentColorIndex
+  } : void 0;
+  return {
+    indexedPixels: indexedImageData.pixels,
+    colorTable: indexedImageData.colorTable,
+    graphicControlExtension: normalizedGraphicControlExtension
+  };
+}
+function buildQuantizedIndexedImage(pixels, { quality }) {
+  const redGreenBlueAlphaBytes = toUint8ArrayView(pixels);
+  requirePixelCountValueWithinLimit(redGreenBlueAlphaBytes.length / 4, defaultMaximumIndexedImagePixelCount, "pixels");
+  const hasTransparency = hasTransparentPixels(redGreenBlueAlphaBytes);
+  const colorBits = quantizationBitsForQuality(quality, hasTransparency ? 255 : 256);
+  const paletteLookup = /* @__PURE__ */ new Map();
+  const palette = [];
+  const indexedPixels = new Uint8Array(redGreenBlueAlphaBytes.length / 4);
+  let transparentColorIndex;
+  for (let pixelOffset = 0, pixelIndex = 0; pixelOffset < redGreenBlueAlphaBytes.length; pixelOffset += 4, pixelIndex += 1) {
+    const red = redGreenBlueAlphaBytes[pixelOffset];
+    const green = redGreenBlueAlphaBytes[pixelOffset + 1];
+    const blue = redGreenBlueAlphaBytes[pixelOffset + 2];
+    const alpha = redGreenBlueAlphaBytes[pixelOffset + 3];
+    if (alpha === 0) {
+      if (transparentColorIndex === void 0) {
+        transparentColorIndex = palette.length / 3;
+        palette.push(0, 0, 0);
+      }
+      indexedPixels[pixelIndex] = transparentColorIndex;
+      continue;
+    }
+    const quantizedRed = quantizeColorChannel(red, colorBits.red);
+    const quantizedGreen = quantizeColorChannel(green, colorBits.green);
+    const quantizedBlue = quantizeColorChannel(blue, colorBits.blue);
+    const lookupKey = `${quantizedRed},${quantizedGreen},${quantizedBlue}`;
+    let paletteIndex = paletteLookup.get(lookupKey);
+    if (paletteIndex === void 0) {
+      paletteIndex = palette.length / 3;
+      palette.push(quantizedRed, quantizedGreen, quantizedBlue);
+      paletteLookup.set(lookupKey, paletteIndex);
+    }
+    indexedPixels[pixelIndex] = paletteIndex;
+  }
+  return {
+    pixels: indexedPixels,
+    colorTable: padColorTableToPowerOfTwo(Uint8Array.from(palette)),
+    transparentColorIndex
+  };
+}
+function hasTransparentPixels(redGreenBlueAlphaBytes) {
+  for (let offset = 3; offset < redGreenBlueAlphaBytes.length; offset += 4) {
+    if (redGreenBlueAlphaBytes[offset] === 0) {
+      return true;
+    }
+  }
+  return false;
+}
+function quantizationBitsForQuality(quality, maximumColorCount) {
+  const targetColorCount = Math.max(2, Math.min(maximumColorCount, Math.round(2 + quality * (maximumColorCount - 2))));
+  let bitCount = Math.floor(Math.log2(targetColorCount));
+  const bits = [0, 0, 0];
+  let channelIndex = 0;
+  while (bitCount > 0) {
+    bits[channelIndex] += 1;
+    channelIndex = (channelIndex + 1) % bits.length;
+    bitCount -= 1;
+  }
+  return {
+    red: bits[0],
+    green: bits[1],
+    blue: bits[2]
+  };
+}
+function quantizeColorChannel(value, bitCount) {
+  if (bitCount >= 8) {
+    return value;
+  }
+  if (bitCount === 0) {
+    return 0;
+  }
+  const maximumValue = (1 << bitCount) - 1;
+  return Math.round(Math.round(value * maximumValue / 255) * 255 / maximumValue);
+}
+
+// packages/@cjser/sindresorhus__gifkit.tmp-26-1783615518957/source/encode.js
+function encodeGIF(gif) {
+  const normalizedGif = normalizeGIFForEncoding(gif);
+  const byteWriter = new GIFByteWriter();
+  byteWriter.writeAsciiString("GIF");
+  byteWriter.writeAsciiString(normalizedGif.version);
+  writeGIFHeader(byteWriter, normalizedGif);
+  writeGIFBlocks(byteWriter, normalizedGif);
+  byteWriter.writeByte(trailerByte);
+  return byteWriter.toUint8Array();
+}
+function normalizeGIFForEncoding(gif) {
+  if (!gif || typeof gif !== "object") {
+    throw new TypeError("Expected a GIF description object");
+  }
+  const logicalScreenWidth = requireNonZeroUnsigned16(gif.width, "width");
+  const logicalScreenHeight = requireNonZeroUnsigned16(gif.height, "height");
+  const globalColorTable = normalizeColorTable(gif.globalColorTable, "globalColorTable");
+  const backgroundColorIndex = requireByte(gif.backgroundColorIndex ?? 0, "backgroundColorIndex");
+  rejectRenamedLoopCount(gif);
+  if (globalColorTable === void 0 && backgroundColorIndex !== 0) {
+    throw new Error("Background color index must be zero when there is no global color table");
+  }
+  if (globalColorTable !== void 0 && backgroundColorIndex >= globalColorTable.length / 3) {
+    throw new Error("Background color index must be inside the global color table");
+  }
+  const loopCount = gif.playCount === void 0 || gif.playCount === 1 ? void 0 : encodeNetscapeLoopCount(gif.playCount, "playCount");
+  const blocks = normalizeBlocksForEncoding(gif, globalColorTable, {
+    loopCount
+  });
+  return {
+    version: "89a",
+    logicalScreenWidth,
+    logicalScreenHeight,
+    backgroundColorIndex,
+    globalColorTable,
+    blocks
+  };
+}
+function normalizeBlocksForEncoding(gif, globalColorTable, { loopCount }) {
+  if (gif.imageBlocks !== void 0) {
+    throw new Error("imageBlocks is not supported when encoding; use blocks");
+  }
+  let sourceBlocks;
+  if (gif.blocks === void 0) {
+    sourceBlocks = [];
+  } else if (Array.isArray(gif.blocks)) {
+    sourceBlocks = gif.blocks;
+  } else {
+    throw new TypeError("blocks must be an array");
+  }
+  const sourceBlockCount = sourceBlocks.length;
+  requireCountWithinLimit(sourceBlockCount, defaultMaximumBlockCount, "block count");
+  validateEncodeWorkCost(sourceBlocks, sourceBlockCount);
+  const blocks = [];
+  let index = 0;
+  while (index < sourceBlockCount) {
+    blocks.push(normalizeBlock(sourceBlocks[index], globalColorTable));
+    index += 1;
+  }
+  if (loopCount === void 0 || containsNetscapeLoopingAppExtension(blocks)) {
+    requireCountWithinLimit(countEncodedStreamBlocks(blocks), defaultMaximumBlockCount, "block count");
+    return blocks;
+  }
+  const blocksWithLoopExtension = [
+    createNetscapeLoopingAppExtension(loopCount),
+    ...blocks
+  ];
+  requireCountWithinLimit(countEncodedStreamBlocks(blocksWithLoopExtension), defaultMaximumBlockCount, "block count");
+  return blocksWithLoopExtension;
+}
+function countEncodedStreamBlocks(blocks) {
+  let blockCount = 0;
+  for (const block of blocks) {
+    blockCount += 1;
+    if (block.type === "image" && (block.graphicControlExtension !== void 0 || block.indexedPixels === void 0 && block.pixels !== void 0)) {
+      blockCount += 1;
+    }
+  }
+  return blockCount;
+}
+function validateEncodeWorkCost(blocks, blockCount = blocks.length) {
+  let workCost = 0;
+  let index = 0;
+  while (index < blockCount) {
+    const block = blocks[index];
+    if (!block || typeof block !== "object") {
+      index += 1;
+      continue;
+    }
+    switch (block.type) {
+      case "commentExtension": {
+        workCost += getPayloadInputLength(block.data ?? "");
+        break;
+      }
+      case "applicationExtension": {
+        workCost += getPayloadInputLength(block.data ?? new Uint8Array());
+        break;
+      }
+      case "image":
+      case "rgbaImage": {
+        const { width, height } = block;
+        if (Number.isSafeInteger(width) && Number.isSafeInteger(height) && width > 0 && height > 0) {
+          workCost += width * height;
+        }
+        break;
+      }
+      default: {
+        break;
+      }
+    }
+    requireCountWithinLimit(workCost, defaultMaximumEncodeWorkCost, "encode work cost");
+    index += 1;
+  }
+  return workCost;
+}
+function getPayloadInputLength(value) {
+  if (isUint8Array(value)) {
+    return toUint8ArrayView(value).length;
+  }
+  if (typeof value === "string" || Array.isArray(value)) {
+    return value.length;
+  }
+  return 0;
+}
+function writeGIFHeader(byteWriter, gif) {
+  const {
+    logicalScreenWidth,
+    logicalScreenHeight,
+    backgroundColorIndex,
+    globalColorTable
+  } = gif;
+  byteWriter.writeUnsignedLittleEndian16(logicalScreenWidth);
+  byteWriter.writeUnsignedLittleEndian16(logicalScreenHeight);
+  const globalColorTableSizeField = globalColorTable === void 0 ? 0 : calculateColorTableSizeField(globalColorTable.length / 3);
+  const packedLogicalScreenField = (globalColorTable === void 0 ? 0 : 128) | deriveColorResolution(globalColorTable) - 1 << 4 | globalColorTableSizeField;
+  byteWriter.writeByte(packedLogicalScreenField);
+  byteWriter.writeByte(backgroundColorIndex);
+  byteWriter.writeByte(0);
+  if (globalColorTable !== void 0) {
+    writeColorTable(byteWriter, globalColorTable);
+  }
+}
+function writeGIFBlocks(byteWriter, gif) {
+  const {
+    logicalScreenWidth,
+    logicalScreenHeight,
+    globalColorTable
+  } = gif;
+  for (const block of gif.blocks) {
+    switch (block.type) {
+      case "commentExtension": {
+        writeCommentExtension(byteWriter, block);
+        break;
+      }
+      case "applicationExtension": {
+        writeAppExtension(byteWriter, block);
+        break;
+      }
+      case "image": {
+        writeImageBlock(byteWriter, block, {
+          logicalScreenWidth,
+          logicalScreenHeight,
+          globalColorTable
+        });
+        break;
+      }
+      default: {
+        throw new Error(`Unsupported block type ${JSON.stringify(block.type)}`);
+      }
+    }
+  }
+}
+function writeImageBlock(byteWriter, block, { logicalScreenWidth, logicalScreenHeight, globalColorTable }) {
+  const geometry = normalizeImageGeometry(block, {
+    logicalScreenWidth,
+    logicalScreenHeight
+  });
+  const imageData = normalizeImageDataForEncoding(block, geometry, globalColorTable);
+  if (imageData.graphicControlExtension !== void 0) {
+    writeGraphicControlExtension(byteWriter, imageData.graphicControlExtension);
+  }
+  writeEncodedImageBlock(byteWriter, block, {
+    ...geometry,
+    ...imageData
+  });
+}
+function normalizeImageDataForEncoding(block, { width, height }, globalColorTable) {
+  let colorTable = normalizeColorTable(block.colorTable, "image.colorTable");
+  let indexedPixels = normalizeIndexedPixels(block.indexedPixels, width * height, "image.pixels");
+  let graphicControlExtension = normalizeGraphicControlExtension(block.graphicControlExtension);
+  if (indexedPixels === void 0 && block.pixels !== void 0) {
+    requirePixelCountValueWithinLimit(width * height, defaultMaximumIndexedImagePixelCount, "RGBA image data");
+    const pixels = normalizeRedGreenBlueAlphaPixels(block.pixels, width * height * 4, "image.pixels");
+    const indexedImageData = normalizeRGBAImageData(pixels, block, graphicControlExtension);
+    indexedPixels = indexedImageData.indexedPixels;
+    colorTable = indexedImageData.colorTable;
+    graphicControlExtension = indexedImageData.graphicControlExtension;
+  }
+  if (indexedPixels === void 0) {
+    throw new Error("An image block requires pixels");
+  }
+  const activeColorTable = colorTable ?? globalColorTable;
+  if (activeColorTable === void 0) {
+    throw new Error("An image block requires a colorTable or a globalColorTable");
+  }
+  validateIndexedPixelsAgainstColorTable(indexedPixels, activeColorTable, graphicControlExtension == null ? void 0 : graphicControlExtension.transparentColorIndex);
+  let minimumCodeSize = deriveMinimumCodeSize(activeColorTable.length / 3);
+  if (minimumCodeSize < 2) {
+    minimumCodeSize = 2;
+  }
+  return {
+    colorTable,
+    indexedPixels,
+    minimumCodeSize,
+    graphicControlExtension
+  };
+}
+function writeEncodedImageBlock(byteWriter, block, { left, top, width, height, colorTable, indexedPixels, minimumCodeSize }) {
+  const pixelsToEncode = block.isInterlaced ? interlaceIndexedPixels(indexedPixels, width, height) : indexedPixels;
+  const compressedData = encodeCompressedIndexStream(pixelsToEncode, minimumCodeSize);
+  byteWriter.writeByte(imageSeparator);
+  byteWriter.writeUnsignedLittleEndian16(left);
+  byteWriter.writeUnsignedLittleEndian16(top);
+  byteWriter.writeUnsignedLittleEndian16(width);
+  byteWriter.writeUnsignedLittleEndian16(height);
+  const packedImageField = (colorTable === void 0 ? 0 : 128) | (block.isInterlaced ? 64 : 0) | (colorTable === void 0 ? 0 : calculateColorTableSizeField(colorTable.length / 3));
+  byteWriter.writeByte(packedImageField);
+  if (colorTable !== void 0) {
+    writeColorTable(byteWriter, colorTable);
+  }
+  byteWriter.writeByte(minimumCodeSize);
+  writeDataSubBlocks(byteWriter, compressedData);
+}
+function writeGraphicControlExtension(byteWriter, graphicControlExtension) {
+  if (graphicControlExtension === void 0) {
+    return;
+  }
+  const packedField = disposalMethodByte(graphicControlExtension.disposalMethod) << 2 | (graphicControlExtension.transparentColorIndex === void 0 ? 0 : 1);
+  byteWriter.writeByte(extensionIntroducer);
+  byteWriter.writeByte(graphicControlExtensionLabel);
+  byteWriter.writeByte(4);
+  byteWriter.writeByte(packedField);
+  byteWriter.writeUnsignedLittleEndian16(graphicControlExtension.delayInHundredthsOfASecond);
+  byteWriter.writeByte(graphicControlExtension.transparentColorIndex ?? 0);
+  byteWriter.writeByte(0);
+}
+function writeCommentExtension(byteWriter, block) {
+  const data = normalizeExtensionPayload(block.data, "commentExtension.data");
+  byteWriter.writeByte(extensionIntroducer);
+  byteWriter.writeByte(commentExtensionLabel);
+  writeDataSubBlocks(byteWriter, data);
+}
+function writeAppExtension(byteWriter, block) {
+  const identifier = normalizeFixedAsciiField(block.identifier, 8, "applicationExtension.identifier");
+  const authenticationCode = normalizeFixedByteField(block.authenticationCode, 3, "applicationExtension.authenticationCode");
+  const data = normalizeExtensionPayload(block.data, "applicationExtension.data");
+  byteWriter.writeByte(extensionIntroducer);
+  byteWriter.writeByte(appExtensionLabel);
+  byteWriter.writeByte(11);
+  byteWriter.writeAsciiString(identifier);
+  byteWriter.writeBytes(authenticationCode);
+  writeDataSubBlocks(byteWriter, data);
+}
+function writeDataSubBlocks(byteWriter, data) {
+  requireByteLengthWithinLimit(data.length, defaultMaximumDataPayloadByteLength, "data payload");
+  for (let offset = 0; offset < data.length; offset += 255) {
+    const chunkLength = Math.min(255, data.length - offset);
+    byteWriter.writeByte(chunkLength);
+    byteWriter.writeBytes(uint8ArraySubarray.call(data, offset, offset + chunkLength));
+  }
+  byteWriter.writeByte(0);
+}
+function writeColorTable(byteWriter, colorTable) {
+  const normalizedColorTable = normalizeColorTable(colorTable, "colorTable");
+  if (normalizedColorTable === void 0) {
+    throw new Error("Expected a color table");
+  }
+  byteWriter.writeBytes(normalizedColorTable);
+}
+function interlaceIndexedPixels(indexedPixels, width, height) {
+  const interlacedPixels = new Uint8Array(indexedPixels.length);
+  let destinationOffset = 0;
+  for (const [startRow, rowStep] of [[0, 8], [4, 8], [2, 4], [1, 2]]) {
+    for (let row = startRow; row < height; row += rowStep) {
+      const sourceOffset = row * width;
+      interlacedPixels.set(uint8ArraySubarray.call(indexedPixels, sourceOffset, sourceOffset + width), destinationOffset);
+      destinationOffset += width;
+    }
+  }
+  return interlacedPixels;
+}
+function validateIndexedPixelsAgainstColorTable(indexedPixels, colorTable, transparentColorIndex) {
+  const colorTableEntryCount = colorTable.length / 3;
+  let pixelOffset = 0;
+  while (pixelOffset < indexedPixels.length) {
+    const pixelIndex = indexedPixels[pixelOffset];
+    if (pixelIndex >= colorTableEntryCount) {
+      throw new Error(`Pixel ${pixelOffset} uses palette index ${pixelIndex}, but the active color table only has ${colorTableEntryCount} entries`);
+    }
+    pixelOffset += 1;
+  }
+  if (transparentColorIndex !== void 0 && transparentColorIndex >= colorTableEntryCount) {
+    throw new Error(`Transparent color index ${transparentColorIndex} exceeds the active color table`);
+  }
+}
+function normalizeBlock(block, globalColorTable) {
+  requireBlockObject(block);
+  switch (block.type) {
+    case "commentExtension": {
+      return normalizeCommentExtensionBlock(block);
+    }
+    case "applicationExtension": {
+      return normalizeAppExtensionBlock(block);
+    }
+    case "image":
+    case "rgbaImage": {
+      return normalizeImageBlock(block, globalColorTable);
+    }
+    default: {
+      throw new Error(`Unsupported block type ${JSON.stringify(block.type)}`);
+    }
+  }
+}
+function normalizeCommentExtensionBlock(block) {
+  return {
+    type: "commentExtension",
+    data: normalizeExtensionPayload(block.data ?? "", "commentExtension.data")
+  };
+}
+function normalizeAppExtensionBlock(block) {
+  const authenticationCode = normalizeFixedByteField(block.authenticationCode, 3, "applicationExtension.authenticationCode");
+  const identifier = normalizeFixedAsciiField(block.identifier, 8, "applicationExtension.identifier");
+  rejectRenamedLoopCount(block);
+  const loopCount = block.playCount === void 0 ? void 0 : encodeExplicitNetscapeLoopCount(block.playCount, "applicationExtension.playCount");
+  const data = block.data ?? (identifier === netscapeLoopingAppIdentifier && areBytesEqual(authenticationCode, netscapeLoopingAppAuthenticationCodeBytes) && loopCount !== void 0 ? Uint8Array.of(1, loopCount & 255, loopCount >> 8) : new Uint8Array());
+  return {
+    type: "applicationExtension",
+    identifier,
+    authenticationCode,
+    data: normalizeExtensionPayload(data, "applicationExtension.data")
+  };
+}
+function normalizeImageBlock(block, globalColorTable) {
+  const isRGBAImage = block.type === "rgbaImage";
+  const width = requireNonZeroUnsigned16(block.width, "image.width");
+  const height = requireNonZeroUnsigned16(block.height, "image.height");
+  requirePixelCountWithinLimit(width, height, defaultMaximumPixelCount, "image block");
+  const colorTable = isRGBAImage ? void 0 : normalizeColorTable(block.colorTable, "image.colorTable");
+  const normalizedImageBlock = {
+    type: "image",
+    graphicControlExtension: block.graphicControlExtension,
+    left: requireUnsigned16(block.left ?? 0, "image.left"),
+    top: requireUnsigned16(block.top ?? 0, "image.top"),
+    width,
+    height,
+    isInterlaced: Boolean(block.isInterlaced),
+    colorTable,
+    indexedPixels: isRGBAImage ? void 0 : block.pixels
+  };
+  if (!isRGBAImage && normalizedImageBlock.colorTable === void 0 && globalColorTable === void 0) {
+    throw new Error("An image block requires a color table or a global color table");
+  }
+  if (isRGBAImage) {
+    normalizedImageBlock.pixels = block.pixels;
+    if (block.transparentColor !== void 0) {
+      normalizedImageBlock.transparentColor = block.transparentColor;
+    }
+  }
+  return normalizedImageBlock;
+}
+
+// packages/@cjser/sindresorhus__gifkit.tmp-26-1783615518957/source/render.js
+function renderGIFFrameSequence(gif, options = {}) {
+  const {
+    repeat,
+    signal,
+    ...renderOptions
+  } = normalizeFrameSequenceOptions(options);
+  if (signal == null ? void 0 : signal.aborted) {
+    return emptyGIFFrameSequence();
+  }
+  const renderState = createGIFRenderState(gif, renderOptions);
+  return renderGIFFrameSequenceFromState(renderState, { repeat, signal });
+}
+function renderGIFFrames(gif, options = {}) {
+  const renderState = createGIFRenderState(gif, normalizeRenderOptions(options));
+  const renderedFrames = [];
+  let renderedPixelCount = 0;
+  const beforeRenderFrame = () => {
+    renderedPixelCount += renderState.logicalScreenPixelCount;
+    requirePixelCountValueWithinLimit(renderedPixelCount, defaultMaximumRenderPixelCount, "rendered frame pixels");
+  };
+  for (const frame of renderGIFFrameSequenceFromState(renderState, { beforeRenderFrame })) {
+    renderedFrames.push(toRenderedFrame(frame));
+  }
+  return {
+    width: renderState.logicalScreenWidth,
+    height: renderState.logicalScreenHeight,
+    ...renderState.playCount !== void 0 && { playCount: renderState.playCount },
+    frames: renderedFrames
+  };
+}
+function createGIFRenderState(gif, renderOptions) {
+  const { background, strict } = renderOptions;
+  if (!gif || typeof gif !== "object") {
+    throw new TypeError("Expected a decoded GIF object");
+  }
+  const logicalScreenWidth = requireNonZeroUnsigned16(gif.width, "width");
+  const logicalScreenHeight = requireNonZeroUnsigned16(gif.height, "height");
+  const logicalScreenPixelCount = requirePixelCountWithinLimit(logicalScreenWidth, logicalScreenHeight, defaultMaximumRenderPixelCount, "logical screen");
+  const globalColorTable = normalizeColorTable(gif.globalColorTable, "globalColorTable");
+  const backgroundColorIndex = requireByte(gif.backgroundColorIndex ?? 0, "backgroundColorIndex");
+  rejectRenamedLoopCount(gif);
+  const playCount = gif.playCount === void 0 ? void 0 : normalizePlayCount(gif.playCount, "playCount");
+  let blocks;
+  if (gif.blocks === void 0) {
+    blocks = [];
+  } else if (Array.isArray(gif.blocks)) {
+    blocks = gif.blocks;
+  } else {
+    throw new TypeError("blocks must be an array");
+  }
+  requireCountWithinLimit(blocks.length, defaultMaximumBlockCount, "render block count");
+  const canvasPixels = new Uint8ClampedArray(logicalScreenWidth * logicalScreenHeight * 4);
+  const renderContext = {
+    logicalScreenWidth,
+    logicalScreenHeight,
+    globalColorTable,
+    backgroundColorIndex,
+    background,
+    strict
+  };
+  fillCanvasBackground(canvasPixels, renderContext);
+  return {
+    logicalScreenWidth,
+    logicalScreenHeight,
+    logicalScreenPixelCount,
+    playCount,
+    blocks,
+    canvasPixels,
+    renderContext
+  };
+}
+function* renderGIFFrameSequenceFromState(renderState, { repeat = false, signal, beforeRenderFrame } = {}) {
+  if (signal == null ? void 0 : signal.aborted) {
+    return;
+  }
+  const totalLoops = repeat ? renderTotalPlayCount(renderState.playCount) : 1;
+  const initialCanvasPixels = totalLoops > 1 ? new Uint8ClampedArray(renderState.canvasPixels) : void 0;
+  let loopIndex = 0;
+  while (loopIndex < totalLoops) {
+    if (loopIndex > 0) {
+      renderState.canvasPixels.set(initialCanvasPixels);
+    }
+    let frameIndex = 0;
+    let blockIndex = 0;
+    const blockCount = renderState.blocks.length;
+    let isRenderedFrameInLoop = false;
+    while (blockIndex < blockCount) {
+      if (signal == null ? void 0 : signal.aborted) {
+        return;
+      }
+      const block = renderState.blocks[blockIndex];
+      blockIndex += 1;
+      requireBlockObject(block);
+      switch (block.type) {
+        case "image": {
+          isRenderedFrameInLoop = true;
+          beforeRenderFrame == null ? void 0 : beforeRenderFrame();
+          yield {
+            ...renderImageBlockToFrame(renderState.canvasPixels, block, renderState.renderContext),
+            index: frameIndex,
+            loopIndex
+          };
+          frameIndex += 1;
+          break;
+        }
+        case "commentExtension":
+        case "applicationExtension":
+        case "unknownExtension": {
+          break;
+        }
+        default: {
+          throw new Error(`Unsupported block type ${JSON.stringify(block.type)}`);
+        }
+      }
+    }
+    if (!isRenderedFrameInLoop) {
+      return;
+    }
+    loopIndex += 1;
+  }
+}
+function* emptyGIFFrameSequence() {
+}
+function toRenderedFrame(frame) {
+  return {
+    left: frame.left,
+    top: frame.top,
+    width: frame.width,
+    height: frame.height,
+    delay: frame.delay,
+    disposalMethod: frame.disposalMethod,
+    pixels: frame.pixels
+  };
+}
+function normalizeRenderOptions(options) {
+  const {
+    background = "gif",
+    strict = true
+  } = options;
+  if (background !== "transparent" && background !== "gif") {
+    throw new TypeError(`background must be 'transparent' or 'gif', got ${JSON.stringify(background)}`);
+  }
+  if (typeof strict !== "boolean") {
+    throw new TypeError(`strict must be a boolean, got ${JSON.stringify(strict)}`);
+  }
+  return {
+    background,
+    strict
+  };
+}
+function normalizeFrameSequenceOptions(options) {
+  const renderOptions = normalizeRenderOptions(options);
+  const {
+    repeat = true,
+    signal
+  } = options;
+  if (typeof repeat !== "boolean") {
+    throw new TypeError(`repeat must be a boolean, got ${JSON.stringify(repeat)}`);
+  }
+  if (signal !== void 0 && typeof (signal == null ? void 0 : signal.aborted) !== "boolean") {
+    throw new TypeError("signal must be an AbortSignal");
+  }
+  return {
+    ...renderOptions,
+    repeat,
+    signal
+  };
+}
+function fillCanvasBackground(canvasPixels, { globalColorTable, backgroundColorIndex, background }) {
+  const backgroundTriplet = getColorTriplet(globalColorTable, backgroundColorIndex);
+  const isUseTransparentBackground = background === "transparent" || backgroundTriplet === void 0;
+  const red = isUseTransparentBackground ? 0 : backgroundTriplet[0];
+  const green = isUseTransparentBackground ? 0 : backgroundTriplet[1];
+  const blue = isUseTransparentBackground ? 0 : backgroundTriplet[2];
+  const alpha = isUseTransparentBackground ? 0 : 255;
+  for (let offset = 0; offset < canvasPixels.length; offset += 4) {
+    canvasPixels[offset] = red;
+    canvasPixels[offset + 1] = green;
+    canvasPixels[offset + 2] = blue;
+    canvasPixels[offset + 3] = alpha;
+  }
+}
+function renderImageBlockToFrame(canvasPixels, imageBlock, renderContext) {
+  const geometry = normalizeImageGeometry(imageBlock, {
+    logicalScreenWidth: renderContext.logicalScreenWidth,
+    logicalScreenHeight: renderContext.logicalScreenHeight
+  });
+  const indexedPixels = normalizeIndexedPixels(imageBlock.pixels, geometry.width * geometry.height, "image.pixels");
+  if (indexedPixels === void 0) {
+    throw new Error("An image block requires pixels to render");
+  }
+  const colorTable = normalizeColorTable(imageBlock.colorTable, "colorTable");
+  const activeColorTable = colorTable ?? renderContext.globalColorTable;
+  if (activeColorTable === void 0) {
+    throw new Error("Cannot render an image block without an active color table");
+  }
+  const graphicControlExtension = normalizeGraphicControlExtension(imageBlock.graphicControlExtension);
+  requirePixelCountWithinLimit(geometry.width, geometry.height, defaultMaximumPixelCount, "image block");
+  const transparentColorIndex = graphicControlExtension == null ? void 0 : graphicControlExtension.transparentColorIndex;
+  const disposalMethod = (graphicControlExtension == null ? void 0 : graphicControlExtension.disposalMethod) ?? "unspecified";
+  const normalizedImageBlock = {
+    ...imageBlock,
+    ...geometry,
+    indexedPixels
+  };
+  const activeColorTableUint32 = isLittleEndian ? createColorTableUint32(activeColorTable) : void 0;
+  if (renderContext.strict && transparentColorIndex !== void 0 && transparentColorIndex >= activeColorTable.length / 3) {
+    throw new Error(`Transparent color index ${transparentColorIndex} exceeds the active color table`);
+  }
+  const snapshotBeforeRendering = disposalMethod === "restorePrevious" ? new Uint8ClampedArray(canvasPixels) : void 0;
+  drawIndexedImageOntoCanvas(canvasPixels, normalizedImageBlock, {
+    ...renderContext,
+    activeColorTable,
+    activeColorTableUint32,
+    transparentColorIndex
+  });
+  const renderedFrame = {
+    left: geometry.left,
+    top: geometry.top,
+    width: geometry.width,
+    height: geometry.height,
+    delay: ((graphicControlExtension == null ? void 0 : graphicControlExtension.delayInHundredthsOfASecond) ?? 0) / 100,
+    disposalMethod,
+    pixels: new Uint8ClampedArray(canvasPixels)
+  };
+  if (disposalMethod === "restoreBackground") {
+    restoreAreaToBackground(canvasPixels, normalizedImageBlock, renderContext);
+  } else if (snapshotBeforeRendering !== void 0) {
+    canvasPixels.set(snapshotBeforeRendering);
+  }
+  return renderedFrame;
+}
+function drawIndexedImageOntoCanvas(canvasPixels, imageBlock, { activeColorTable, activeColorTableUint32, transparentColorIndex, logicalScreenWidth, strict }) {
+  if (activeColorTableUint32 !== void 0) {
+    drawIndexedImageOntoCanvasUint32(canvasPixels, imageBlock, {
+      activeColorTableUint32,
+      transparentColorIndex,
+      logicalScreenWidth,
+      strict
+    });
+    return;
+  }
+  const {
+    left = 0,
+    top = 0,
+    width,
+    height,
+    indexedPixels
+  } = imageBlock;
+  for (let row = 0; row < height; row += 1) {
+    let sourceOffset = row * width;
+    let destinationOffset = ((top + row) * logicalScreenWidth + left) * 4;
+    for (let column = 0; column < width; column += 1) {
+      const pixelIndex = indexedPixels[sourceOffset];
+      sourceOffset += 1;
+      if (transparentColorIndex !== void 0 && pixelIndex === transparentColorIndex) {
+        destinationOffset += 4;
+        continue;
+      }
+      const colorOffset = pixelIndex * 3;
+      if (colorOffset + 2 >= activeColorTable.length) {
+        if (strict) {
+          throw new Error(`Pixel index ${pixelIndex} is outside the active color table`);
+        }
+        destinationOffset += 4;
+        continue;
+      }
+      canvasPixels[destinationOffset] = activeColorTable[colorOffset];
+      canvasPixels[destinationOffset + 1] = activeColorTable[colorOffset + 1];
+      canvasPixels[destinationOffset + 2] = activeColorTable[colorOffset + 2];
+      canvasPixels[destinationOffset + 3] = 255;
+      destinationOffset += 4;
+    }
+  }
+}
+function drawIndexedImageOntoCanvasUint32(canvasPixels, imageBlock, { activeColorTableUint32, transparentColorIndex, logicalScreenWidth, strict }) {
+  const {
+    left = 0,
+    top = 0,
+    width,
+    height,
+    indexedPixels
+  } = imageBlock;
+  const canvasPixelsUint32 = new Uint32Array(canvasPixels.buffer, canvasPixels.byteOffset, canvasPixels.byteLength / Uint32Array.BYTES_PER_ELEMENT);
+  for (let row = 0; row < height; row += 1) {
+    let sourceOffset = row * width;
+    let destinationOffset = (top + row) * logicalScreenWidth + left;
+    for (let column = 0; column < width; column += 1) {
+      const pixelIndex = indexedPixels[sourceOffset];
+      sourceOffset += 1;
+      if (transparentColorIndex !== void 0 && pixelIndex === transparentColorIndex) {
+        destinationOffset += 1;
+        continue;
+      }
+      const color = activeColorTableUint32[pixelIndex];
+      if (color === void 0) {
+        if (strict) {
+          throw new Error(`Pixel index ${pixelIndex} is outside the active color table`);
+        }
+        destinationOffset += 1;
+        continue;
+      }
+      canvasPixelsUint32[destinationOffset] = color;
+      destinationOffset += 1;
+    }
+  }
+}
+function createColorTableUint32(colorTable) {
+  const colorTableUint32 = new Uint32Array(colorTable.length / 3);
+  for (let colorIndex = 0; colorIndex < colorTableUint32.length; colorIndex += 1) {
+    const colorOffset = colorIndex * 3;
+    colorTableUint32[colorIndex] = 4278190080 | colorTable[colorOffset + 2] << 16 | colorTable[colorOffset + 1] << 8 | colorTable[colorOffset];
+  }
+  return colorTableUint32;
+}
+function restoreAreaToBackground(canvasPixels, imageBlock, { logicalScreenWidth, logicalScreenHeight, globalColorTable, backgroundColorIndex, background }) {
+  const {
+    left = 0,
+    top = 0,
+    width,
+    height
+  } = imageBlock;
+  const backgroundTriplet = getColorTriplet(globalColorTable, backgroundColorIndex);
+  const isUseTransparentBackground = background === "transparent" || backgroundTriplet === void 0;
+  const red = isUseTransparentBackground ? 0 : backgroundTriplet[0];
+  const green = isUseTransparentBackground ? 0 : backgroundTriplet[1];
+  const blue = isUseTransparentBackground ? 0 : backgroundTriplet[2];
+  const alpha = isUseTransparentBackground ? 0 : 255;
+  for (let row = 0; row < height; row += 1) {
+    const destinationRow = top + row;
+    if (destinationRow < 0 || destinationRow >= logicalScreenHeight) {
+      continue;
+    }
+    for (let column = 0; column < width; column += 1) {
+      const destinationColumn = left + column;
+      if (destinationColumn < 0 || destinationColumn >= logicalScreenWidth) {
+        continue;
+      }
+      const destinationOffset = (destinationRow * logicalScreenWidth + destinationColumn) * 4;
+      canvasPixels[destinationOffset] = red;
+      canvasPixels[destinationOffset + 1] = green;
+      canvasPixels[destinationOffset + 2] = blue;
+      canvasPixels[destinationOffset + 3] = alpha;
+    }
+  }
+}
+function getColorTriplet(colorTable, paletteIndex) {
+  if (colorTable === void 0) {
+    return void 0;
+  }
+  const colorOffset = paletteIndex * 3;
+  if (colorOffset + 2 >= colorTable.length) {
+    return void 0;
+  }
+  return [
+    colorTable[colorOffset],
+    colorTable[colorOffset + 1],
+    colorTable[colorOffset + 2]
+  ];
+}
+
+// packages/@cjser/sindresorhus__gifkit.tmp-26-1783615518957/index.js
+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 !== void 0 && { playCount: rendered.playCount },
+    frames: rendered.frames.map((frame) => ({
+      pixels: frame.pixels,
+      delay: frame.delay
+    }))
+  };
+}
+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 !== void 0);
+  if (options.fps !== void 0 && hasFrameDelays) {
+    throw new Error("fps cannot be combined with per-frame delay");
+  }
+  if (options.fps === void 0 && frames.some((frame) => !isAnimationFrameObject(frame) || frame.delay === void 0)) {
+    throw new Error("fps is required unless every frame has a delay");
+  }
+  const frameDelay = options.fps === void 0 ? void 0 : 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 !== void 0) {
+    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);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  decodeAnimatedGIF,
+  decodeGIF,
+  encodeAnimatedGIF,
+  encodeGIF,
+  indexedImage,
+  renderGIFFrameSequence,
+  renderGIFFrames
+});