@poe-platform/safe-bash 0.1.802 → 0.1.804

package/dist/safe-bash/command-chunks/{chunk-QRRYN2KO.js → chunk-BC7BK6R6.js}

@@ -1,47 +1,3 @@
-import {
-  affineImage,
-  applyExifOrientation,
-  bandboolImage,
-  blurImage,
-  booleanImage,
-  claheImage,
-  compositeImage,
-  computeImageStats,
-  convolveImage,
-  decodeImage,
-  dilateImage,
-  encodeImage,
-  ensureAlphaImage,
-  erodeImage,
-  extendImage,
-  extractChannelImage,
-  extractImage,
-  flattenImage,
-  flipImage,
-  flopImage,
-  gammaImage,
-  grayscaleImage,
-  joinChannelImage,
-  linearImage,
-  medianImage,
-  modulateImage,
-  negateImage,
-  normalizeImage,
-  parseColor,
-  premultiplyRgbaImage,
-  readImageMetadata,
-  recombImage,
-  removeAlphaImage,
-  resizeImage,
-  rotateImage,
-  sharpenImage,
-  thresholdImage,
-  tintImage,
-  toColorspaceImage,
-  trimImage,
-  unflattenImage,
-  unpremultiplyRgbaImage
-} from "./chunk-YG4EPFWC.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";
@@ -49,2386 +5,6 @@ import {
 // packages/image-ast/src/index.ts
 init_buffer();
 
-// packages/image-ast/src/sharp.ts
-init_buffer();
-
-// packages/image-ast/src/streams/web.ts
-init_buffer();
-var outputBytes = Uint8Array.from.bind(Uint8Array);
-var isBuffer = (_input) => false;
-var EventEmitter = class {
-  listeners = /* @__PURE__ */ new Map();
-  on(event, listener) {
-    let listeners = this.listeners.get(event);
-    if (!listeners) this.listeners.set(event, listeners = /* @__PURE__ */ new Set());
-    listeners.add(listener);
-    return this;
-  }
-  once(event, listener) {
-    const once = (...args) => {
-      this.removeListener(event, once);
-      listener(...args);
-    };
-    return this.on(event, once);
-  }
-  removeListener(event, listener) {
-    this.listeners.get(event)?.delete(listener);
-    return this;
-  }
-  emit(event, ...args) {
-    const listeners = [...this.listeners.get(event) ?? []];
-    for (const listener of listeners) listener(...args);
-    return listeners.length > 0;
-  }
-};
-var Duplex = class extends EventEmitter {
-  readable;
-  writable;
-  writableFinished = false;
-  controller;
-  closed = false;
-  constructor() {
-    super();
-    this.readable = new ReadableStream({
-      start: (controller) => {
-        this.controller = controller;
-      },
-      pull: () => {
-        this._read();
-      },
-      cancel: (reason) => {
-        this.destroy(reason instanceof Error ? reason : void 0);
-      }
-    }, { highWaterMark: 0 });
-    this.writable = new WritableStream({
-      write: (chunk) => new Promise((resolve, reject) => {
-        this._write(chunk, "utf8", (error) => {
-          if (error) {
-            this.destroy(error);
-            reject(error);
-          } else resolve();
-        });
-      }),
-      close: () => {
-        this.writableFinished = true;
-        this.emit("finish");
-      },
-      abort: (reason) => {
-        this.destroy(reason instanceof Error ? reason : void 0);
-      }
-    });
-  }
-  _write(_chunk, _encoding, callback) {
-    callback(new Error("Writable operation is not implemented"));
-  }
-  _read() {
-    throw new Error("Readable operation is not implemented");
-  }
-  push(chunk) {
-    if (this.closed) return false;
-    if (chunk === null) {
-      this.closed = true;
-      this.controller.close();
-    } else this.controller.enqueue(new Uint8Array(chunk));
-    return (this.controller.desiredSize ?? 0) > 0;
-  }
-  destroy(error) {
-    if (!this.closed) {
-      this.closed = true;
-      this.controller.error(error ?? new Error("Stream cancelled"));
-      this.emit("error", error ?? new Error("Stream cancelled"));
-    }
-    return this;
-  }
-  async *[Symbol.asyncIterator]() {
-    const reader = this.readable.getReader();
-    try {
-      while (true) {
-        const result = await reader.read();
-        if (result.done) return;
-        yield result.value;
-      }
-    } finally {
-      await reader.cancel();
-      reader.releaseLock();
-    }
-  }
-};
-
-// packages/image-ast/src/sharp.ts
-import { extname, normalizePath } from "@poe-platform/safe-fs/core";
-function inferTypedArrayDepth(input) {
-  if (!input || !ArrayBuffer.isView(input)) return void 0;
-  if (input instanceof Int8Array) return "char";
-  if (input instanceof Uint16Array) return "ushort";
-  if (input instanceof Int16Array) return "short";
-  if (input instanceof Uint32Array) return "uint";
-  if (input instanceof Int32Array) return "int";
-  if (input instanceof Float32Array) return "float";
-  if (input instanceof Float64Array) return "double";
-  return "uchar";
-}
-function validateInputOptions(opts) {
-  if (!opts || typeof opts !== "object") return;
-  const anyOpts = opts;
-  if (anyOpts.failOnError !== void 0 && typeof anyOpts.failOnError !== "boolean") {
-    throw new Error(`Expected boolean for failOnError but received ${anyOpts.failOnError} of type ${typeof anyOpts.failOnError}`);
-  }
-  if (opts.failOn !== void 0 && !["none", "truncated", "error", "warning"].includes(opts.failOn)) {
-    throw new Error(`Expected one of: none, truncated, error, warning for failOn but received ${opts.failOn} of type ${typeof opts.failOn}`);
-  }
-  for (const boolKey of ["animated", "autoOrient", "sequentialRead", "unlimited", "ignoreIcc"]) {
-    if (anyOpts[boolKey] !== void 0 && typeof anyOpts[boolKey] !== "boolean") {
-      throw new Error(`Expected boolean for ${boolKey} but received ${anyOpts[boolKey]} of type ${typeof anyOpts[boolKey]}`);
-    }
-  }
-  if (opts.density !== void 0 && (typeof opts.density !== "number" || Number.isNaN(opts.density) || opts.density < 1 || opts.density > 1e5)) {
-    throw new Error(`Expected number between 1 and 100000 for density but received ${opts.density} of type ${typeof opts.density}`);
-  }
-  if (opts.limitInputPixels !== void 0 && typeof opts.limitInputPixels !== "boolean" && (!Number.isInteger(opts.limitInputPixels) || opts.limitInputPixels < 0 || opts.limitInputPixels > Number.MAX_SAFE_INTEGER)) {
-    throw new Error(
-      `Expected positive integer for limitInputPixels but received ${opts.limitInputPixels} of type ${typeof opts.limitInputPixels}`
-    );
-  }
-  if (opts.page !== void 0 && (!Number.isInteger(opts.page) || opts.page < 0 || opts.page > 1e5)) {
-    throw new Error(`Expected integer between 0 and 100000 for page but received ${opts.page} of type ${typeof opts.page}`);
-  }
-  if (opts.pages !== void 0 && (!Number.isInteger(opts.pages) || opts.pages < -1 || opts.pages > 1e5)) {
-    throw new Error(`Expected integer between -1 and 100000 for pages but received ${opts.pages} of type ${typeof opts.pages}`);
-  }
-  if (opts.raw !== void 0) {
-    const raw = opts.raw;
-    if (!raw || typeof raw !== "object" || !Number.isInteger(raw.width) || raw.width <= 0 || !Number.isInteger(raw.height) || raw.height <= 0 || !Number.isInteger(raw.channels) || raw.channels < 1 || raw.channels > 4) {
-      throw new Error("Expected width, height and channels for raw pixel input");
-    }
-    if (raw.premultiplied !== void 0 && typeof raw.premultiplied !== "boolean") {
-      throw new Error(`Expected boolean for raw.premultiplied but received ${raw.premultiplied}`);
-    }
-    if (raw.pageHeight !== void 0) {
-      if (!Number.isInteger(raw.pageHeight) || raw.pageHeight <= 0 || raw.pageHeight > raw.height) {
-        throw new Error(`Expected positive integer for raw.pageHeight but received ${raw.pageHeight}`);
-      }
-      if (raw.height % raw.pageHeight !== 0) {
-        throw new Error(`Expected raw.height ${raw.height} to be a multiple of raw.pageHeight ${raw.pageHeight}`);
-      }
-    }
-  }
-  const validAlignments = ["left", "top", "low", "center", "centre", "right", "bottom", "high"];
-  if (opts.join !== void 0) {
-    const join = opts.join;
-    if (join && typeof join === "object") {
-      if (join.across !== void 0 && (!Number.isInteger(join.across) || join.across < 1 || join.across > 1e5)) {
-        throw new Error(`Expected integer between 1 and 100000 for join.across but received ${join.across} of type ${typeof join.across}`);
-      }
-      if (join.shim !== void 0 && (!Number.isInteger(join.shim) || join.shim < 0 || join.shim > 1e5)) {
-        throw new Error(`Expected integer between 0 and 100000 for join.shim but received ${join.shim} of type ${typeof join.shim}`);
-      }
-      if (join.halign !== void 0 && !validAlignments.includes(join.halign)) {
-        throw new Error(`Expected valid alignment for join.halign but received ${join.halign} of type ${typeof join.halign}`);
-      }
-      if (join.valign !== void 0 && !validAlignments.includes(join.valign)) {
-        throw new Error(`Expected valid alignment for join.valign but received ${join.valign} of type ${typeof join.valign}`);
-      }
-      if (join.animated !== void 0 && typeof join.animated !== "boolean") {
-        throw new Error(`Expected boolean for join.animated but received ${join.animated} of type ${typeof join.animated}`);
-      }
-      if (join.background !== void 0) {
-        parseColor(join.background, 255);
-      }
-    }
-  }
-  if (opts.text !== void 0) {
-    const text = opts.text;
-    if (!text || typeof text !== "object" || typeof text.text !== "string" || text.text.trim().length === 0) {
-      throw new Error("Expected a valid string to create an image with text.");
-    }
-    if (text.width !== void 0 && (!Number.isInteger(text.width) || text.width <= 0)) {
-      throw new Error(`Expected positive integer for text.width but received ${text.width} of type ${typeof text.width}`);
-    }
-    if (text.height !== void 0 && (!Number.isInteger(text.height) || text.height <= 0)) {
-      throw new Error(`Expected positive integer for text.height but received ${text.height} of type ${typeof text.height}`);
-    }
-    if (text.dpi !== void 0 && (!Number.isInteger(text.dpi) || text.dpi < 1 || text.dpi > 1e6)) {
-      throw new Error(`Expected integer between 1 and 1000000 for text.dpi but received ${text.dpi} of type ${typeof text.dpi}`);
-    }
-    if (text.align !== void 0 && !validAlignments.includes(text.align)) {
-      throw new Error(`Expected valid alignment for text.align but received ${text.align} of type ${typeof text.align}`);
-    }
-    if (text.justify !== void 0 && typeof text.justify !== "boolean") {
-      throw new Error(`Expected boolean for text.justify but received ${text.justify} of type ${typeof text.justify}`);
-    }
-    if (text.rgba !== void 0 && typeof text.rgba !== "boolean") {
-      throw new Error(`Expected bool for text.rgba but received ${text.rgba} of type ${typeof text.rgba}`);
-    }
-    if (text.wrap !== void 0 && !["word", "char", "word-char", "none"].includes(text.wrap)) {
-      throw new Error(`Expected one of: word, char, word-char, none for text.wrap but received ${text.wrap} of type ${typeof text.wrap}`);
-    }
-  }
-  if (opts.create !== void 0) {
-    const create = opts.create;
-    if (!create || typeof create !== "object" || !Number.isInteger(create.width) || create.width <= 0 || !Number.isInteger(create.height) || create.height <= 0 || !Number.isInteger(create.channels)) {
-      throw new Error("Expected valid width, height and channels to create a new input image");
-    }
-    if (create.pageHeight !== void 0) {
-      if (!Number.isInteger(create.pageHeight) || create.pageHeight <= 0 || create.pageHeight > create.height) {
-        throw new Error(`Expected positive integer for create.pageHeight but received ${create.pageHeight}`);
-      }
-      if (create.height % create.pageHeight !== 0) {
-        throw new Error(`Expected create.height ${create.height} to be a multiple of create.pageHeight ${create.pageHeight}`);
-      }
-    }
-    if (create.noise !== void 0) {
-      if (!create.noise || typeof create.noise !== "object") {
-        throw new Error("Expected noise to be an object");
-      }
-      if (create.noise.type !== "gaussian") {
-        throw new Error("Only gaussian noise is supported at the moment");
-      }
-      if (create.channels < 1 || create.channels > 4) {
-        throw new Error(
-          `Expected number between 1 and 4 for create.channels but received ${create.channels} of type ${typeof create.channels}`
-        );
-      }
-    } else if (create.background !== void 0) {
-      if (create.channels < 3 || create.channels > 4) {
-        throw new Error(
-          `Expected number between 3 and 4 for create.channels but received ${create.channels} of type ${typeof create.channels}`
-        );
-      }
-    } else {
-      throw new Error("Expected valid noise or background to create a new input image");
-    }
-  }
-}
-function toBytes(input, readFile) {
-  if (!input) return void 0;
-  if (isBuffer(input)) {
-    const bytes = input;
-    if (bytes.length === 0) {
-      throw new Error("Input Buffer is empty");
-    }
-    return bytes;
-  }
-  if (ArrayBuffer.isView(input)) {
-    if (input.byteLength === 0) {
-      throw new Error("Input Bit Array is empty");
-    }
-    return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
-  }
-  if (input instanceof ArrayBuffer) {
-    if (input.byteLength === 0) {
-      throw new Error("Input bit Array is empty");
-    }
-    return new Uint8Array(input);
-  }
-  if (typeof input === "string") {
-    if (input.trimStart().startsWith("<")) {
-      return new TextEncoder().encode(input);
-    }
-    if (!readFile) throw new Error("File inputs require an explicit filesystem and an asynchronous output method");
-    return readFile(input);
-  }
-  return void 0;
-}
-function inferFormatFromPath(fileOut) {
-  const ext = extname(fileOut).toLowerCase().slice(1);
-  switch (ext) {
-    case "png":
-      return "png";
-    case "jpg":
-    case "jpeg":
-    case "jpe":
-      return "jpeg";
-    case "webp":
-      return "webp";
-    case "gif":
-      return "gif";
-    case "tif":
-    case "tiff":
-      return "tiff";
-    case "avif":
-      return "avif";
-    case "heic":
-      return "heic";
-    case "heif":
-      return "heif";
-    case "pdf":
-      return "pdf";
-    case "ppm":
-      return "ppm";
-    case "pgm":
-      return "pgm";
-    case "pbm":
-      return "pbm";
-    case "bmp":
-      return "bmp";
-    case "raw":
-      return "raw";
-    default:
-      return void 0;
-  }
-}
-var SharpInstance = class _SharpInstance extends Duplex {
-  inputBytes;
-  inputFilePath;
-  joinInputs;
-  inputOptions;
-  nodes = [];
-  outputOptions = {};
-  streamIn = false;
-  streamInFinished = false;
-  streamFailure;
-  streamChunks = [];
-  fileInputs = /* @__PURE__ */ new Map();
-  fileLoads = /* @__PURE__ */ new Map();
-  clonedStreams = [];
-  streamOutStarted = false;
-  constructor(input, options) {
-    super();
-    if (Array.isArray(input)) {
-      if (input.length < 2) {
-        throw new Error("Expected at least two images to join");
-      }
-      if (input.some((item) => Array.isArray(item))) {
-        throw new Error("Recursive join is unsupported");
-      }
-      this.inputBytes = void 0;
-      this.joinInputs = input;
-      this.inputOptions = options;
-    } else if (input && typeof input === "object" && !ArrayBuffer.isView(input) && !(input instanceof ArrayBuffer)) {
-      this.inputBytes = void 0;
-      this.joinInputs = void 0;
-      this.inputOptions = input;
-      if (this.inputOptions.join !== void 0) {
-        throw new Error("Expected input to be an array of images to join");
-      }
-      validateInputOptions(this.inputOptions);
-      if (!this.inputOptions.create && !this.inputOptions.text && Object.keys(this.inputOptions).length > 0) {
-        this.streamIn = true;
-      }
-    } else {
-      if (options?.join !== void 0) {
-        throw new Error("Expected input to be an array of images to join");
-      }
-      this.inputFilePath = typeof input === "string" && !input.trimStart().startsWith("<") ? input : void 0;
-      const inferredDepth = inferTypedArrayDepth(input);
-      let effectiveOptions = options;
-      if (effectiveOptions?.raw && inferredDepth && !effectiveOptions.raw.depth) {
-        effectiveOptions = {
-          ...effectiveOptions,
-          raw: {
-            ...effectiveOptions.raw,
-            depth: inferredDepth
-          }
-        };
-      }
-      validateInputOptions(effectiveOptions);
-      this.inputBytes = this.inputFilePath ? void 0 : toBytes(input);
-      this.joinInputs = void 0;
-      this.inputOptions = effectiveOptions;
-      if (input === void 0 && (!effectiveOptions || !effectiveOptions.create && !effectiveOptions.text)) {
-        this.streamIn = true;
-      }
-    }
-    validateInputOptions(this.inputOptions);
-    this.on("error", (error) => {
-      this.streamFailure = error;
-      for (const child of this.clonedStreams) {
-        child.streamFailure = error;
-        child.destroy(error);
-      }
-    });
-    if (this.streamIn) {
-      this.on("finish", () => {
-        this.flattenStreamInput();
-      });
-    }
-    if (this.inputOptions?.autoOrient) {
-      this.nodes.push({ kind: "autoOrient" });
-    }
-  }
-  flattenStreamInput() {
-    if (this.streamIn && !this.streamInFinished) {
-      const merged = new Uint8Array(this.streamChunks.reduce((total, bytes) => total + bytes.length, 0));
-      let offset = 0;
-      for (const bytes of this.streamChunks) {
-        merged.set(bytes, offset);
-        offset += bytes.length;
-      }
-      this.receiveStreamInput(merged);
-    }
-  }
-  receiveStreamInput(merged) {
-    this.inputBytes = merged;
-    this.streamInFinished = true;
-    for (const child of this.clonedStreams) {
-      child.receiveStreamInput(merged);
-    }
-    this.emit("streamReady");
-  }
-  async waitForStreamInput() {
-    if (this.streamFailure) throw this.streamFailure;
-    await this.loadFileInputs();
-    if (this.streamFailure) throw this.streamFailure;
-    if (!this.streamIn || this.streamInFinished) {
-      return;
-    }
-    if (this.writableFinished) {
-      this.flattenStreamInput();
-      if (this.streamInFinished) return;
-    }
-    await new Promise((resolve, reject) => {
-      const onReady = () => {
-        this.removeListener("finish", onReady);
-        this.removeListener("streamReady", onReady);
-        this.removeListener("error", onError);
-        this.flattenStreamInput();
-        resolve();
-      };
-      const onError = (err) => {
-        this.removeListener("finish", onReady);
-        this.removeListener("streamReady", onReady);
-        reject(err);
-      };
-      this.once("finish", onReady);
-      this.once("streamReady", onReady);
-      this.once("error", onError);
-    });
-  }
-  operationInput(input) {
-    if (typeof input !== "string" || input.trimStart().startsWith("<")) return toBytes(input);
-    return input;
-  }
-  loadedFile(path) {
-    const bytes = this.fileInputs.get(path);
-    if (!bytes) throw new Error("File inputs require an explicit filesystem and an asynchronous output method");
-    return bytes;
-  }
-  async loadFileInputs() {
-    const paths = /* @__PURE__ */ new Set();
-    if (this.inputFilePath) paths.add(this.inputFilePath);
-    for (const input of this.joinInputs ?? []) {
-      if (typeof input === "string" && !input.trimStart().startsWith("<")) paths.add(input);
-    }
-    for (const node of this.nodes) {
-      if (node.kind === "boolean" && typeof node.operand === "string") paths.add(node.operand);
-      if (node.kind === "joinChannel") {
-        for (const input of node.inputs) if (typeof input.data === "string") paths.add(input.data);
-      }
-      if (node.kind !== "composite") continue;
-      for (const layer of node.layers) {
-        if (typeof layer.input === "string" && !layer.input.trimStart().startsWith("<")) paths.add(layer.input);
-      }
-    }
-    await Promise.all([...paths].map((path) => {
-      if (this.fileInputs.has(path)) return;
-      let pending = this.fileLoads.get(path);
-      if (!pending) {
-        if (!this.inputOptions?.filesystem) throw new Error("File inputs require an explicit filesystem");
-        pending = this.inputOptions.filesystem.readFile(path).then((bytes) => {
-          this.fileInputs.set(path, new Uint8Array(bytes));
-        });
-        this.fileLoads.set(path, pending);
-      }
-      return pending;
-    }));
-    if (this.inputFilePath) this.inputBytes = this.loadedFile(this.inputFilePath);
-  }
-  _write(chunk, _encoding, callback) {
-    if (this.streamIn && !this.streamInFinished) {
-      if (chunk instanceof Uint8Array) {
-        this.streamChunks.push(new Uint8Array(chunk));
-        callback();
-      } else {
-        callback(new Error("Non-Buffer data on Writable Stream"));
-      }
-    } else {
-      callback(new Error("Unexpected data on Writable Stream"));
-    }
-  }
-  _read() {
-    if (!this.streamOutStarted) {
-      this.streamOutStarted = true;
-      this.waitForStreamInput().then(() => {
-        const res = this.toBufferWithObjectSync();
-        this.emit("info", res.info);
-        this.push(res.data);
-        this.push(null);
-      }).catch((err) => {
-        this.destroy(err);
-      });
-    }
-  }
-  clone() {
-    if (this.streamIn && !this.streamInFinished) {
-      const copy2 = new _SharpInstance(void 0, this.inputOptions);
-      copy2.nodes.length = 0;
-      copy2.nodes.push(...this.nodes);
-      copy2.outputOptions = { ...this.outputOptions };
-      this.clonedStreams.push(copy2);
-      if (this.streamFailure) {
-        copy2.streamFailure = this.streamFailure;
-        copy2.destroy(this.streamFailure);
-      }
-      return copy2;
-    }
-    const copy = this.joinInputs !== void 0 ? new _SharpInstance(this.joinInputs, this.inputOptions) : this.inputFilePath !== void 0 ? new _SharpInstance(this.inputFilePath, this.inputOptions) : this.inputBytes !== void 0 ? new _SharpInstance(this.inputBytes, this.inputOptions) : new _SharpInstance(this.inputOptions);
-    copy.inputFilePath = this.inputFilePath;
-    for (const [path, bytes] of this.fileInputs) copy.fileInputs.set(path, bytes);
-    copy.nodes.length = 0;
-    copy.nodes.push(...this.nodes);
-    copy.outputOptions = { ...this.outputOptions };
-    return copy;
-  }
-  decodeInitialImage() {
-    if (!this.joinInputs) {
-      return decodeImage(this.inputFilePath ? this.loadedFile(this.inputFilePath) : this.inputBytes, this.inputOptions);
-    }
-    const imgs = this.joinInputs.map((item) => {
-      if (item && typeof item === "object" && !(item instanceof Uint8Array) && !(item instanceof ArrayBuffer)) {
-        return decodeImage(void 0, item);
-      }
-      return decodeImage(toBytes(item, (path) => this.loadedFile(path)), this.inputOptions);
-    });
-    const n = imgs.length;
-    const cellW = Math.max(...imgs.map((i) => i.width));
-    const cellH = Math.max(...imgs.map((i) => i.height));
-    const joinOpts = this.inputOptions?.join;
-    const animated = Boolean(joinOpts?.animated);
-    const across = Math.max(1, joinOpts?.across ?? 1);
-    const cols = Math.min(n, across);
-    const rows = Math.ceil(n / cols);
-    const shim = Math.max(0, joinOpts?.shim ?? 0);
-    const outW = cols * cellW + (cols - 1) * shim;
-    const outH = rows * cellH + (rows - 1) * shim;
-    const anyAlpha = imgs.some((i) => i.hasAlpha);
-    const bg = parseColor(joinOpts?.background ?? { r: 0, g: 0, b: 0, alpha: 1 }, 255);
-    const hasAlpha = anyAlpha || bg.a < 255;
-    const channels = hasAlpha ? 4 : 3;
-    const out = new Uint8Array(outW * outH * 4);
-    const bgA = hasAlpha ? bg.a : 255;
-    const bgWord = (bgA << 24 | bg.b << 16 | bg.g << 8 | bg.r) >>> 0;
-    new Uint32Array(out.buffer, out.byteOffset, outW * outH).fill(bgWord);
-    const halign = joinOpts?.halign ?? "left";
-    const valign = joinOpts?.valign ?? "top";
-    for (let k = 0; k < n; k++) {
-      const im = imgs[k];
-      const col = k % cols;
-      const row = Math.floor(k / cols);
-      const cellX = col * (cellW + shim);
-      const cellY = row * (cellH + shim);
-      const dx = halign === "centre" || halign === "center" ? Math.floor((cellW - im.width) / 2) : halign === "right" || halign === "high" ? cellW - im.width : 0;
-      const dy = valign === "centre" || valign === "center" ? Math.floor((cellH - im.height) / 2) : valign === "bottom" || valign === "high" ? cellH - im.height : 0;
-      for (let y = 0; y < im.height; y++) {
-        const dstY = cellY + dy + y;
-        const sRow = y * im.width * 4;
-        const dRow = (dstY * outW + cellX + dx) * 4;
-        out.set(im.data.subarray(sRow, sRow + im.width * 4), dRow);
-      }
-    }
-    const animPageHeight = animated && n > 0 ? Math.floor(outH / n) : 0;
-    const validAnim = animated && animPageHeight > 0 && outH % animPageHeight === 0 && outH / animPageHeight === n;
-    return {
-      width: outW,
-      height: outH,
-      data: out,
-      format: "raw",
-      space: "srgb",
-      channels,
-      depth: "uchar",
-      density: this.inputOptions?.density ?? 72,
-      hasAlpha,
-      ...validAnim ? { pages: n, pageHeight: animPageHeight } : {}
-    };
-  }
-  getAst() {
-    return this.nodes;
-  }
-  upsertNode(nextNode, beforeGrayscale = false) {
-    const idx = this.nodes.findIndex((n) => n.kind === nextNode.kind);
-    if (idx !== -1) {
-      this.nodes[idx] = nextNode;
-      return;
-    }
-    if (nextNode.kind === "removeAlpha" || nextNode.kind === "flatten") {
-      const ensureIdx = this.nodes.findIndex((n) => n.kind === "ensureAlpha");
-      if (ensureIdx !== -1) {
-        this.nodes.splice(ensureIdx, 0, nextNode);
-        return;
-      }
-    }
-    if (beforeGrayscale) {
-      const grayIdx = this.nodes.findIndex((n) => n.kind === "grayscale");
-      if (grayIdx !== -1) {
-        this.nodes.splice(grayIdx, 0, nextNode);
-        return;
-      }
-    }
-    this.nodes.push(nextNode);
-  }
-  evaluateImage() {
-    let img = this.decodeInitialImage();
-    const resizeIdx = this.nodes.findIndex((n) => n.kind === "resize");
-    const postScaleIndices = /* @__PURE__ */ new Set();
-    if (resizeIdx !== -1) {
-      for (let i = resizeIdx + 1; i < this.nodes.length; i++) {
-        const n = this.nodes[i];
-        if (n.kind === "flip" || n.kind === "flop" || n.kind === "rotate" && n.angle % 90 === 0) {
-          postScaleIndices.add(i);
-        }
-      }
-    }
-    const postScaleNodes = this.nodes.filter((_, idx) => postScaleIndices.has(idx));
-    const postScaleTransform = postScaleNodes.length > 0 ? (scaled) => {
-      let cur = scaled;
-      for (const pNode of postScaleNodes) {
-        if (pNode.kind === "rotate") {
-          cur = rotateImage(cur, pNode.angle, pNode.background);
-        } else if (pNode.kind === "flip") {
-          cur = flipImage(cur);
-        } else if (pNode.kind === "flop") {
-          cur = flopImage(cur);
-        }
-      }
-      return cur;
-    } : void 0;
-    const gammaNode = this.nodes.find((n) => n.kind === "gamma");
-    const splitGamma = gammaNode !== void 0 && this.nodes.some(
-      (n) => n.kind === "resize" || n.kind === "blur" || n.kind === "convolve" || n.kind === "recomb" || n.kind === "modulate" || n.kind === "sharpen" || n.kind === "composite"
-    );
-    const postStageRank = {
-      extend: 10,
-      median: 20,
-      threshold: 30,
-      dilate: 40,
-      erode: 50,
-      blur: 60,
-      unflatten: 70,
-      convolve: 80,
-      recomb: 90,
-      modulate: 100,
-      sharpen: 110,
-      composite: 120,
-      gamma: 130,
-      linear: 140,
-      normalize: 150,
-      clahe: 160,
-      negate: 170,
-      tint: 180,
-      grayscale: 190,
-      toColorspace: 200,
-      bandbool: 210,
-      boolean: 220,
-      joinChannel: 230,
-      extractChannel: 240,
-      withMetadata: 250
-    };
-    const activeNodes = this.nodes.filter((_, idx) => !postScaleIndices.has(idx));
-    const preNodes = activeNodes.filter((n) => !(n.kind in postStageRank));
-    const postNodes = activeNodes.filter((n) => n.kind in postStageRank).sort((a, b) => (postStageRank[a.kind] ?? 999) - (postStageRank[b.kind] ?? 999));
-    const orderedNodes = [...preNodes, ...postNodes];
-    const isPremulStageKind = (kind) => kind === "resize" || kind === "blur" || kind === "convolve" || kind === "sharpen";
-    const premulStageCount = orderedNodes.filter((n) => isPremulStageKind(n.kind)).length;
-    const firstPremulIdx = orderedNodes.findIndex((n) => isPremulStageKind(n.kind));
-    let lastPremulIdx = -1;
-    for (let i = orderedNodes.length - 1; i >= 0; i--) {
-      if (isPremulStageKind(orderedNodes[i].kind)) {
-        lastPremulIdx = i;
-        break;
-      }
-    }
-    let gammaInApplied = false;
-    let gammaOutApplied = false;
-    for (let i = 0; i < orderedNodes.length; i++) {
-      const node = orderedNodes[i];
-      if (splitGamma && gammaNode && !gammaInApplied && (i === firstPremulIdx || node.kind === "recomb" || node.kind === "modulate" || node.kind === "composite")) {
-        img = gammaImage(img, gammaNode.gamma, 1);
-        gammaInApplied = true;
-      }
-      if (i === firstPremulIdx && img.hasAlpha) {
-        if (premulStageCount > 1) {
-          img = premultiplyRgbaImage(img);
-        } else {
-          img = { ...img, wasPremultiplied: true };
-        }
-      }
-      switch (node.kind) {
-        case "autoOrient":
-          img = applyExifOrientation(img);
-          break;
-        case "rotate":
-          img = rotateImage(img, node.angle, node.background);
-          break;
-        case "flip":
-          img = flipImage(img);
-          break;
-        case "flop":
-          img = flopImage(img);
-          break;
-        case "extract":
-          img = extractImage(img, node);
-          break;
-        case "trim":
-          img = trimImage(img, {
-            threshold: node.threshold,
-            ...node.background !== void 0 ? { background: node.background } : {},
-            ...node.lineArt !== void 0 ? { lineArt: node.lineArt } : {}
-          });
-          break;
-        case "resize":
-          img = resizeImage(img, node, postScaleTransform);
-          if (img.hasAlpha && !img.isPremultiplied) {
-            if (i < lastPremulIdx) {
-              img = premultiplyRgbaImage(img);
-            } else {
-              img = { ...img, wasPremultiplied: true };
-            }
-          }
-          break;
-        case "extend":
-          img = extendImage(img, node);
-          break;
-        case "composite":
-          img = compositeImage(img, node.layers, (path) => this.loadedFile(path));
-          break;
-        case "grayscale":
-          img = grayscaleImage(img);
-          break;
-        case "flatten":
-          img = flattenImage(img, node.background);
-          break;
-        case "unflatten":
-          img = unflattenImage(img);
-          break;
-        case "negate":
-          img = negateImage(img, { alpha: node.alpha });
-          break;
-        case "modulate":
-          img = modulateImage(img, node);
-          break;
-        case "tint":
-          img = tintImage(img, node.color);
-          break;
-        case "gamma":
-          if (splitGamma) {
-            img = gammaImage(img, 1, node.gammaOut);
-            gammaOutApplied = true;
-          } else {
-            img = gammaImage(img, node.gamma, node.gammaOut);
-          }
-          break;
-        case "linear":
-          img = linearImage(img, node.a, node.b);
-          break;
-        case "normalize":
-          img = normalizeImage(img, { lower: node.lower, upper: node.upper });
-          break;
-        case "threshold":
-          img = thresholdImage(img, node.value, node.grayscale);
-          break;
-        case "blur":
-          img = blurImage(img, node.sigma, node.minAmplitude, node.precision);
-          break;
-        case "sharpen":
-          img = sharpenImage(img, node.sigma, node.m1, node.m2, node.x1, node.y2, node.y3);
-          break;
-        case "median":
-          img = medianImage(img, node.size);
-          break;
-        case "dilate":
-          img = dilateImage(img, node.width);
-          break;
-        case "erode":
-          img = erodeImage(img, node.width);
-          break;
-        case "convolve":
-          img = convolveImage(img, node);
-          break;
-        case "ensureAlpha":
-          img = ensureAlphaImage(img, node.alpha);
-          break;
-        case "removeAlpha":
-          img = removeAlphaImage(img);
-          break;
-        case "extractChannel":
-          img = extractChannelImage(img, node.channel);
-          break;
-        case "recomb":
-          img = recombImage(img, node.matrix);
-          break;
-        case "toColorspace":
-          img = toColorspaceImage(img, node.space);
-          break;
-        case "bandbool":
-          img = bandboolImage(img, node.op);
-          break;
-        case "boolean": {
-          const opImg = decodeImage(typeof node.operand === "string" ? this.loadedFile(node.operand) : node.operand, node.options);
-          img = booleanImage(img, opImg, node.op);
-          break;
-        }
-        case "joinChannel": {
-          const extras = node.inputs.map((item) => decodeImage(typeof item.data === "string" ? this.loadedFile(item.data) : item.data, item.options));
-          img = joinChannelImage(img, extras);
-          break;
-        }
-        case "clahe": {
-          const explicitBw = this.nodes.some(
-            (n) => n.kind === "grayscale" || n.kind === "toColorspace" && (n.space === "b-w" || n.space === "grey16")
-          );
-          if (!explicitBw && (img.channels === 1 || img.channels === 2)) {
-            img = {
-              ...img,
-              channels: img.channels === 2 ? 4 : 3,
-              space: "srgb",
-              hasAlpha: img.channels === 2
-            };
-          }
-          img = claheImage(img, node);
-          break;
-        }
-        case "affine":
-          img = affineImage(img, node);
-          break;
-        case "withMetadata":
-          img = {
-            ...img,
-            ...node.density !== void 0 ? { density: node.density } : {},
-            ...node.orientation !== void 0 ? { orientation: node.orientation } : {}
-          };
-          break;
-      }
-      if (i === lastPremulIdx && img.isPremultiplied) {
-        img = unpremultiplyRgbaImage(img);
-      }
-    }
-    if (splitGamma && gammaNode && gammaInApplied && !gammaOutApplied) {
-      img = gammaImage(img, 1, gammaNode.gammaOut);
-    }
-    return img;
-  }
-  metadataSync() {
-    const computeAutoOrient = (w, h, orient) => orient !== void 0 && orient >= 5 && orient <= 8 ? { width: h, height: w } : { width: w, height: h };
-    const rawMeta = this.joinInputs ? (() => {
-      const joined = this.decodeInitialImage();
-      return {
-        format: joined.format,
-        width: joined.width,
-        height: joined.height,
-        space: joined.space,
-        channels: joined.channels,
-        depth: joined.depth,
-        density: joined.density,
-        hasAlpha: joined.hasAlpha,
-        ...joined.pages !== void 0 ? { pages: joined.pages } : {},
-        ...joined.pageHeight !== void 0 ? { pageHeight: joined.pageHeight } : {},
-        size: joined.data.byteLength
-      };
-    })() : readImageMetadata(this.inputFilePath ? this.loadedFile(this.inputFilePath) : this.inputBytes, this.inputOptions);
-    if (this.nodes.length === 0) {
-      return {
-        ...rawMeta,
-        autoOrient: computeAutoOrient(rawMeta.width, rawMeta.height, rawMeta.orientation)
-      };
-    }
-    const evaluated = this.evaluateImage();
-    return {
-      format: this.outputOptions.format ?? evaluated.format,
-      width: evaluated.width,
-      height: evaluated.height,
-      space: evaluated.space,
-      channels: evaluated.channels,
-      depth: evaluated.depth,
-      density: this.outputOptions.density ?? evaluated.density,
-      hasAlpha: evaluated.hasAlpha,
-      autoOrient: computeAutoOrient(evaluated.width, evaluated.height, evaluated.orientation),
-      ...evaluated.orientation !== void 0 ? { orientation: evaluated.orientation } : {},
-      ...rawMeta.pages !== void 0 ? { pages: rawMeta.pages } : {},
-      ...rawMeta.pagePrimary !== void 0 ? { pagePrimary: rawMeta.pagePrimary } : {},
-      ...rawMeta.isProgressive !== void 0 ? { isProgressive: rawMeta.isProgressive } : {},
-      ...rawMeta.size !== void 0 ? { size: rawMeta.size } : {}
-    };
-  }
-  async metadata(callback) {
-    try {
-      await this.waitForStreamInput();
-      const res = this.metadataSync();
-      if (callback) callback(null, res);
-      return res;
-    } catch (err) {
-      if (callback) callback(err);
-      throw err;
-    }
-  }
-  statsSync() {
-    const img = this.evaluateImage();
-    return computeImageStats(img);
-  }
-  async stats(callback) {
-    try {
-      await this.waitForStreamInput();
-      const res = this.statsSync();
-      if (callback) callback(null, res);
-      return res;
-    } catch (err) {
-      if (callback) callback(err);
-      throw err;
-    }
-  }
-  autoOrient() {
-    return this.rotate();
-  }
-  rotate(angle, options) {
-    if (angle === void 0) {
-      if (!this.nodes.some((n) => n.kind === "autoOrient")) {
-        const insertIdx = this.nodes.findIndex(
-          (n) => n.kind === "rotate" || n.kind === "flip" || n.kind === "flop" || n.kind === "resize"
-        );
-        if (insertIdx !== -1) {
-          this.nodes.splice(insertIdx, 0, { kind: "autoOrient" });
-        } else {
-          this.nodes.push({ kind: "autoOrient" });
-        }
-      }
-    } else {
-      if (typeof angle !== "number" || Number.isNaN(angle)) {
-        throw new Error(`Expected numeric for angle but received ${angle} of type ${typeof angle}`);
-      }
-      const isOrthogonal = Number.isInteger(angle) && angle % 90 === 0;
-      const nextNode = {
-        kind: "rotate",
-        angle,
-        background: isOrthogonal ? { r: 0, g: 0, b: 0, a: 255 } : parseColor(options?.background, 255)
-      };
-      const existingIdx = this.nodes.findIndex((n) => n.kind === "rotate");
-      if (existingIdx !== -1) {
-        this.nodes[existingIdx] = nextNode;
-      } else {
-        this.nodes.push(nextNode);
-      }
-    }
-    return this;
-  }
-  flip(flip = true) {
-    const existingIdx = this.nodes.findIndex((n) => n.kind === "flip");
-    if (flip) {
-      if (existingIdx !== -1) return this;
-      const rotIdx = this.nodes.findIndex((n) => n.kind === "rotate");
-      if (rotIdx !== -1) this.nodes.splice(rotIdx, 0, { kind: "flip" });
-      else this.nodes.push({ kind: "flip" });
-    } else if (existingIdx !== -1) {
-      this.nodes.splice(existingIdx, 1);
-    }
-    return this;
-  }
-  flop(flop = true) {
-    const existingIdx = this.nodes.findIndex((n) => n.kind === "flop");
-    if (flop) {
-      if (existingIdx !== -1) return this;
-      const rotIdx = this.nodes.findIndex((n) => n.kind === "rotate");
-      if (rotIdx !== -1) this.nodes.splice(rotIdx, 0, { kind: "flop" });
-      else this.nodes.push({ kind: "flop" });
-    } else if (existingIdx !== -1) {
-      this.nodes.splice(existingIdx, 1);
-    }
-    return this;
-  }
-  extract(region) {
-    if (!region || typeof region !== "object") {
-      throw new Error("Expected object for extract region");
-    }
-    for (const name of ["left", "top", "width", "height"]) {
-      const val = region[name];
-      if (!Number.isInteger(val) || val < 0) {
-        throw new Error(`Expected integer for ${name} but received ${val}`);
-      }
-    }
-    const nextNode = {
-      kind: "extract",
-      left: region.left,
-      top: region.top,
-      width: region.width,
-      height: region.height
-    };
-    const resizeIdx = this.nodes.findIndex((n) => n.kind === "resize");
-    const extractIndices = [];
-    for (let i = 0; i < this.nodes.length; i++) {
-      if (this.nodes[i].kind === "extract") extractIndices.push(i);
-    }
-    if (resizeIdx !== -1) {
-      const postIdx = extractIndices.find((idx) => idx > resizeIdx);
-      if (postIdx !== void 0) {
-        this.nodes[postIdx] = nextNode;
-        return this;
-      }
-    } else if (extractIndices.length >= 2) {
-      this.nodes[extractIndices[1]] = nextNode;
-      return this;
-    }
-    const extIdx = this.nodes.findIndex((n) => n.kind === "extend");
-    if (extIdx !== -1) this.nodes.splice(extIdx, 0, nextNode);
-    else this.nodes.push(nextNode);
-    return this;
-  }
-  trim(options) {
-    if (options !== void 0 && typeof options !== "number" && (typeof options !== "object" || options === null || Array.isArray(options))) {
-      throw new Error(`Expected object or number for trim but received ${options} of type ${typeof options}`);
-    }
-    if (typeof options === "object" && options !== null && options.lineArt !== void 0 && typeof options.lineArt !== "boolean") {
-      throw new Error(
-        `Expected boolean for trimLineArt but received ${options.lineArt} of type ${typeof options.lineArt}`
-      );
-    }
-    const threshold = typeof options === "number" ? options : options?.threshold ?? 10;
-    if (typeof threshold !== "number" || Number.isNaN(threshold) || threshold < 0) {
-      throw new Error(`Expected positive number for threshold but received ${threshold} of type ${typeof threshold}`);
-    }
-    const background = typeof options === "object" && options?.background ? parseColor(options.background) : void 0;
-    const lineArt = typeof options === "object" && typeof options?.lineArt === "boolean" ? options.lineArt : void 0;
-    const nextNode = {
-      kind: "trim",
-      threshold,
-      ...background ? { background } : {},
-      ...lineArt !== void 0 ? { lineArt } : {}
-    };
-    const existingIdx = this.nodes.findIndex((n) => n.kind === "trim");
-    if (existingIdx !== -1) {
-      this.nodes[existingIdx] = nextNode;
-      return this;
-    }
-    const geomIdx = this.nodes.findIndex(
-      (n) => n.kind === "resize" || n.kind === "extend" || n.kind === "extract" || n.kind === "rotate"
-    );
-    if (geomIdx !== -1) this.nodes.splice(geomIdx, 0, nextNode);
-    else this.nodes.push(nextNode);
-    return this;
-  }
-  resize(widthOrOptions, height, options) {
-    let w = null;
-    let h = null;
-    let wProvided = false;
-    let hProvided = false;
-    let opts = {};
-    if (typeof widthOrOptions === "object" && widthOrOptions !== null) {
-      opts = widthOrOptions;
-      w = opts.width ?? null;
-      h = opts.height ?? null;
-      wProvided = opts.width !== void 0;
-      hProvided = true;
-    } else {
-      opts = options ?? {};
-      w = widthOrOptions !== void 0 ? widthOrOptions : opts.width ?? null;
-      h = height !== void 0 ? height : opts.height ?? null;
-      wProvided = true;
-      hProvided = true;
-    }
-    if (w !== null && (!Number.isInteger(w) || w <= 0)) {
-      throw new Error(`Expected positive integer for width but received ${w}`);
-    }
-    if (h !== null && (!Number.isInteger(h) || h <= 0)) {
-      throw new Error(`Expected positive integer for height but received ${h}`);
-    }
-    if (opts.fit !== void 0 && !["contain", "cover", "fill", "inside", "outside"].includes(opts.fit)) {
-      throw new Error(`Expected valid fit for fit but received ${opts.fit} of type ${typeof opts.fit}`);
-    }
-    if (opts.kernel !== void 0 && !["nearest", "linear", "cubic", "mitchell", "lanczos2", "lanczos3", "mks2013", "mks2021"].includes(opts.kernel)) {
-      throw new Error(`Expected valid kernel name for kernel but received ${opts.kernel} of type ${typeof opts.kernel}`);
-    }
-    if (opts.position !== void 0) {
-      const validPosStrings = [
-        "top",
-        "right",
-        "bottom",
-        "left",
-        "right top",
-        "right bottom",
-        "left bottom",
-        "left top",
-        "north",
-        "northeast",
-        "east",
-        "southeast",
-        "south",
-        "southwest",
-        "west",
-        "northwest",
-        "center",
-        "centre",
-        "entropy",
-        "attention"
-      ];
-      const isValidPos = typeof opts.position === "string" ? validPosStrings.includes(opts.position) : typeof opts.position === "number" && Number.isInteger(opts.position) && (opts.position >= 0 && opts.position <= 8 || opts.position === 16 || opts.position === 17);
-      if (!isValidPos) {
-        throw new Error(
-          `Expected valid position/gravity/strategy for position but received ${opts.position} of type ${typeof opts.position}`
-        );
-      }
-    }
-    const anyResizeOpts = opts;
-    for (const boolKey of ["withoutEnlargement", "withoutReduction", "fastShrinkOnLoad"]) {
-      if (anyResizeOpts[boolKey] !== void 0 && typeof anyResizeOpts[boolKey] !== "boolean") {
-        throw new Error(
-          `Expected boolean for ${boolKey} but received ${anyResizeOpts[boolKey]} of type ${typeof anyResizeOpts[boolKey]}`
-        );
-      }
-    }
-    const existingIdx = this.nodes.findIndex((n) => n.kind === "resize");
-    if (existingIdx !== -1) {
-      const prev = this.nodes[existingIdx];
-      this.nodes[existingIdx] = {
-        kind: "resize",
-        width: wProvided ? w : prev.width,
-        height: hProvided ? h : prev.height,
-        fit: opts.fit ?? prev.fit,
-        position: opts.position ?? prev.position,
-        kernel: opts.kernel ?? prev.kernel,
-        background: opts.background !== void 0 ? parseColor(opts.background, 255) : prev.background,
-        withoutEnlargement: opts.withoutEnlargement ?? prev.withoutEnlargement,
-        withoutReduction: opts.withoutReduction ?? prev.withoutReduction
-      };
-      return this;
-    }
-    const nextResizeNode = {
-      kind: "resize",
-      width: w,
-      height: h,
-      fit: opts.fit ?? "cover",
-      position: opts.position ?? "centre",
-      kernel: opts.kernel ?? "lanczos3",
-      background: parseColor(opts.background, 255),
-      withoutEnlargement: opts.withoutEnlargement ?? false,
-      withoutReduction: opts.withoutReduction ?? false
-    };
-    const extIdx = this.nodes.findIndex((n) => n.kind === "extend");
-    if (extIdx !== -1) this.nodes.splice(extIdx, 0, nextResizeNode);
-    else this.nodes.push(nextResizeNode);
-    return this;
-  }
-  extend(edges) {
-    if (typeof edges === "number") {
-      if (!Number.isInteger(edges) || edges <= 0) {
-        throw new Error(`Expected positive integer for extend but received ${edges}`);
-      }
-    } else if (edges && typeof edges === "object") {
-      for (const side of ["top", "bottom", "left", "right"]) {
-        const val = edges[side];
-        if (val !== void 0 && (!Number.isInteger(val) || val < 0)) {
-          throw new Error(`Expected positive integer for ${side} but received ${val}`);
-        }
-      }
-      if (edges.extendWith !== void 0 && edges.extendWith !== "background" && edges.extendWith !== "copy" && edges.extendWith !== "repeat" && edges.extendWith !== "mirror") {
-        throw new Error(`Expected one of: background, copy, repeat, mirror for extendWith but received ${edges.extendWith}`);
-      }
-    } else {
-      throw new Error(`Expected integer or object for extend but received ${edges}`);
-    }
-    const nextNode = typeof edges === "number" ? {
-      kind: "extend",
-      top: edges,
-      bottom: edges,
-      left: edges,
-      right: edges,
-      background: { r: 0, g: 0, b: 0, a: 255 },
-      extendWith: "background"
-    } : {
-      kind: "extend",
-      top: edges.top ?? 0,
-      bottom: edges.bottom ?? 0,
-      left: edges.left ?? 0,
-      right: edges.right ?? 0,
-      background: parseColor(edges.background, 255),
-      extendWith: edges.extendWith ?? "background"
-    };
-    const existingIdx = this.nodes.findIndex((n) => n.kind === "extend");
-    if (existingIdx !== -1) {
-      this.nodes[existingIdx] = nextNode;
-    } else {
-      this.nodes.push(nextNode);
-    }
-    return this;
-  }
-  composite(images) {
-    if (!Array.isArray(images)) {
-      throw new Error("Expected array for images to composite");
-    }
-    const validBlends = [
-      "clear",
-      "source",
-      "over",
-      "in",
-      "out",
-      "atop",
-      "dest",
-      "dest-over",
-      "dest-in",
-      "dest-out",
-      "dest-atop",
-      "xor",
-      "add",
-      "saturate",
-      "multiply",
-      "screen",
-      "overlay",
-      "darken",
-      "lighten",
-      "colour-dodge",
-      "color-dodge",
-      "colour-burn",
-      "color-burn",
-      "hard-light",
-      "soft-light",
-      "difference",
-      "exclusion"
-    ];
-    const validGravities = [
-      "center",
-      "centre",
-      "north",
-      "east",
-      "south",
-      "west",
-      "northeast",
-      "southeast",
-      "southwest",
-      "northwest"
-    ];
-    for (const img of images) {
-      if (!img || typeof img !== "object") {
-        throw new Error("Expected object for image to composite");
-      }
-      if (img.input === void 0) {
-        throw new Error(`Unsupported input '${img.input}' of type ${typeof img.input}`);
-      }
-      validateInputOptions(img);
-      if (img.blend !== void 0 && !validBlends.includes(img.blend)) {
-        throw new Error(`Expected valid blend name for blend but received ${img.blend} of type ${typeof img.blend}`);
-      }
-      if (img.tile !== void 0 && typeof img.tile !== "boolean") {
-        throw new Error(`Expected boolean for tile but received ${img.tile} of type ${typeof img.tile}`);
-      }
-      if (img.premultiplied !== void 0 && typeof img.premultiplied !== "boolean") {
-        throw new Error(`Expected boolean for premultiplied but received ${img.premultiplied} of type ${typeof img.premultiplied}`);
-      }
-      if (img.gravity !== void 0) {
-        const validG = typeof img.gravity === "string" ? validGravities.includes(img.gravity) : typeof img.gravity === "number" && Number.isInteger(img.gravity) && img.gravity >= 0 && img.gravity <= 8;
-        if (!validG) {
-          throw new Error(`Expected valid gravity for gravity but received ${img.gravity} of type ${typeof img.gravity}`);
-        }
-      }
-      if (img.top !== void 0 !== (img.left !== void 0)) {
-        throw new Error("Expected both left and top to be set");
-      }
-      if (img.top !== void 0 && !Number.isInteger(img.top)) {
-        throw new Error(`Expected integer for top but received ${img.top}`);
-      }
-      if (img.left !== void 0 && !Number.isInteger(img.left)) {
-        throw new Error(`Expected integer for left but received ${img.left}`);
-      }
-    }
-    const existingIdx = this.nodes.findIndex((n) => n.kind === "composite");
-    if (existingIdx !== -1) {
-      this.nodes[existingIdx] = { kind: "composite", layers: [...images] };
-    } else {
-      this.nodes.push({ kind: "composite", layers: [...images] });
-    }
-    return this;
-  }
-  grayscale(grayscale = true) {
-    if (grayscale === false) {
-      const idx = this.nodes.findIndex((n) => n.kind === "grayscale");
-      if (idx !== -1) this.nodes.splice(idx, 1);
-      return this;
-    }
-    this.upsertNode({ kind: "grayscale" });
-    return this;
-  }
-  greyscale(greyscale = true) {
-    return this.grayscale(greyscale);
-  }
-  flatten(options) {
-    if (options === false) {
-      const idx = this.nodes.findIndex((n) => n.kind === "flatten");
-      if (idx !== -1) this.nodes.splice(idx, 1);
-      return this;
-    }
-    const bg = typeof options === "object" ? options?.background : void 0;
-    this.upsertNode({
-      kind: "flatten",
-      background: parseColor(bg ?? "#000000", 255)
-    });
-    return this;
-  }
-  unflatten() {
-    this.upsertNode({ kind: "unflatten" }, true);
-    return this;
-  }
-  negate(options) {
-    if (options === false) {
-      const idx = this.nodes.findIndex((n) => n.kind === "negate");
-      if (idx !== -1) this.nodes.splice(idx, 1);
-      return this;
-    }
-    if (typeof options === "object" && options !== null && options.alpha !== void 0 && typeof options.alpha !== "boolean") {
-      throw new Error(`Expected should be boolean value for alpha but received ${options.alpha} of type ${typeof options.alpha}`);
-    }
-    const alpha = typeof options === "object" ? options.alpha ?? true : true;
-    this.upsertNode({ kind: "negate", alpha });
-    return this;
-  }
-  modulate(options) {
-    if (!options || typeof options !== "object") {
-      throw new Error(`Expected plain object for modulate options but received ${options}`);
-    }
-    if (options.brightness !== void 0 && (typeof options.brightness !== "number" || Number.isNaN(options.brightness) || options.brightness < 0)) {
-      throw new Error(`Expected number above zero for brightness but received ${options.brightness} of type ${typeof options.brightness}`);
-    }
-    if (options.saturation !== void 0 && (typeof options.saturation !== "number" || Number.isNaN(options.saturation) || options.saturation < 0)) {
-      throw new Error(`Expected number above zero for saturation but received ${options.saturation} of type ${typeof options.saturation}`);
-    }
-    if (options.hue !== void 0 && (typeof options.hue !== "number" || Number.isNaN(options.hue))) {
-      throw new Error(`Expected number for hue but received ${options.hue} of type ${typeof options.hue}`);
-    }
-    if (options.lightness !== void 0 && (typeof options.lightness !== "number" || Number.isNaN(options.lightness))) {
-      throw new Error(`Expected number for lightness but received ${options.lightness} of type ${typeof options.lightness}`);
-    }
-    const idx = this.nodes.findIndex((n) => n.kind === "modulate");
-    if (idx !== -1) {
-      const prev = this.nodes[idx];
-      this.nodes[idx] = {
-        kind: "modulate",
-        brightness: options.brightness ?? prev.brightness,
-        saturation: options.saturation ?? prev.saturation,
-        hue: options.hue ?? prev.hue,
-        lightness: options.lightness ?? prev.lightness
-      };
-      return this;
-    }
-    this.nodes.push({
-      kind: "modulate",
-      brightness: options.brightness ?? 1,
-      saturation: options.saturation ?? 1,
-      hue: options.hue ?? 0,
-      lightness: options.lightness ?? 0
-    });
-    return this;
-  }
-  tint(rgb2) {
-    this.upsertNode({ kind: "tint", color: parseColor(rgb2, 255) }, true);
-    return this;
-  }
-  gamma(gamma = 2.2, gammaOut = gamma) {
-    if (typeof gamma !== "number" || Number.isNaN(gamma) || gamma < 1 || gamma > 3) {
-      throw new Error(`Expected number between 1.0 and 3.0 for gamma but received ${gamma}`);
-    }
-    if (typeof gammaOut !== "number" || Number.isNaN(gammaOut) || gammaOut < 1 || gammaOut > 3) {
-      throw new Error(`Expected number between 1.0 and 3.0 for gammaOut but received ${gammaOut}`);
-    }
-    this.upsertNode({ kind: "gamma", gamma, gammaOut });
-    return this;
-  }
-  linear(a, b) {
-    if (a == null && b == null) {
-      const idx = this.nodes.findIndex((n) => n.kind === "linear");
-      if (idx !== -1) this.nodes.splice(idx, 1);
-      return this;
-    }
-    let effA = a;
-    let effB = b;
-    if (effA == null && typeof effB === "number") {
-      effA = 1;
-    } else if (typeof effA === "number" && effB == null) {
-      effB = 0;
-    }
-    const aArr = effA == null ? [] : typeof effA === "number" ? [effA] : Array.isArray(effA) ? [...effA] : [];
-    const bArr = effB == null ? [] : typeof effB === "number" ? [effB] : Array.isArray(effB) ? [...effB] : [];
-    if (aArr.length !== bArr.length) {
-      throw new Error("Expected a and b to be arrays of the same length");
-    }
-    this.upsertNode({ kind: "linear", a: aArr, b: bArr });
-    return this;
-  }
-  normalize(lowerOrOptions, upperArg) {
-    if (lowerOrOptions === false) {
-      const idx = this.nodes.findIndex((n) => n.kind === "normalize");
-      if (idx !== -1) this.nodes.splice(idx, 1);
-      return this;
-    }
-    if (lowerOrOptions === true) {
-      this.upsertNode({ kind: "normalize", lower: 1, upper: 99 });
-      return this;
-    }
-    const lower = typeof lowerOrOptions === "number" ? lowerOrOptions : lowerOrOptions?.lower ?? 1;
-    const upper = typeof lowerOrOptions === "number" ? upperArg ?? 99 : lowerOrOptions?.upper ?? 99;
-    if (typeof lower !== "number" || Number.isNaN(lower) || lower < 0 || lower > 99) {
-      throw new Error(`Expected number between 0 and 99 for lower but received ${lower} of type ${typeof lower}`);
-    }
-    if (typeof upper !== "number" || Number.isNaN(upper) || upper < 1 || upper > 100) {
-      throw new Error(`Expected number between 1 and 100 for upper but received ${upper} of type ${typeof upper}`);
-    }
-    if (lower >= upper) {
-      throw new Error(`Expected lower to be less than upper for range but received ${lower} >= ${upper} of type string`);
-    }
-    this.upsertNode({ kind: "normalize", lower, upper });
-    return this;
-  }
-  normalise(lowerOrOptions, upperArg) {
-    return this.normalize(lowerOrOptions, upperArg);
-  }
-  threshold(threshold = 128, options) {
-    if (threshold === false || threshold === 0) {
-      const idx = this.nodes.findIndex((n) => n.kind === "threshold");
-      if (idx !== -1) this.nodes.splice(idx, 1);
-      return this;
-    }
-    if (typeof threshold === "number" && (!Number.isInteger(threshold) || threshold < 0 || threshold > 255)) {
-      throw new Error(`Expected integer between 0 and 255 for threshold but received ${threshold}`);
-    }
-    const val = typeof threshold === "number" ? threshold : 128;
-    const gs = options?.grayscale ?? options?.greyscale ?? true;
-    this.upsertNode({ kind: "threshold", value: val, grayscale: gs });
-    return this;
-  }
-  blur(options) {
-    if (options === false) {
-      const idx = this.nodes.findIndex((n) => n.kind === "blur");
-      if (idx !== -1) this.nodes.splice(idx, 1);
-      return this;
-    }
-    let sigma;
-    let precision;
-    let minAmplitude;
-    if (typeof options === "number") {
-      sigma = options;
-    } else if (options !== null && typeof options === "object" && !Array.isArray(options)) {
-      if (typeof options.sigma !== "number" || Number.isNaN(options.sigma)) {
-        throw new Error(
-          `Expected number between 0.3 and 1000 for options.sigma but received ${options.sigma} of type ${typeof options.sigma}`
-        );
-      }
-      sigma = options.sigma;
-      if ("precision" in options && options.precision !== void 0) {
-        if (options.precision !== "integer" && options.precision !== "float" && options.precision !== "approximate") {
-          throw new Error(
-            `Expected one of: integer, float, approximate for precision but received ${options.precision} of type ${typeof options.precision}`
-          );
-        }
-        precision = options.precision;
-      }
-      if ("minAmplitude" in options && options.minAmplitude !== void 0) {
-        if (typeof options.minAmplitude !== "number" || Number.isNaN(options.minAmplitude) || options.minAmplitude < 1e-3 || options.minAmplitude > 1) {
-          throw new Error(
-            `Expected number between 0.001 and 1 for minAmplitude but received ${options.minAmplitude} of type ${typeof options.minAmplitude}`
-          );
-        }
-        minAmplitude = options.minAmplitude;
-      }
-    }
-    if (options === void 0 || options === true) {
-      this.upsertNode({ kind: "blur", sigma: -1 });
-      return this;
-    }
-    if (typeof sigma !== "number" || Number.isNaN(sigma) || sigma < 0.3 || sigma > 1e3) {
-      throw new Error(
-        `Expected number between 0.3 and 1000 for sigma but received ${sigma} of type ${typeof sigma}`
-      );
-    }
-    this.upsertNode({
-      kind: "blur",
-      sigma,
-      ...precision ? { precision } : {},
-      ...minAmplitude !== void 0 ? { minAmplitude } : {}
-    });
-    return this;
-  }
-  sharpen(options, flat, jagged) {
-    if (options === false) {
-      const idx = this.nodes.findIndex((n) => n.kind === "sharpen");
-      if (idx !== -1) this.nodes.splice(idx, 1);
-      return this;
-    }
-    if (options === void 0 || options === true) {
-      this.upsertNode({ kind: "sharpen", sigma: -1, m1: 1, m2: 2, x1: 2, y2: 10, y3: 20 });
-      return this;
-    }
-    if (typeof options === "number") {
-      if (Number.isNaN(options) || options < 0.01 || options > 1e4) {
-        throw new Error(`Expected number between 0.01 and 10000 for sigma but received ${options}`);
-      }
-      this.upsertNode({
-        kind: "sharpen",
-        sigma: options,
-        m1: flat ?? 1,
-        m2: jagged ?? 2,
-        x1: 2,
-        y2: 10,
-        y3: 20
-      });
-      return this;
-    }
-    if (options.sigma !== void 0 && (typeof options.sigma !== "number" || Number.isNaN(options.sigma) || options.sigma < 1e-6 || options.sigma > 10)) {
-      throw new Error(`Expected number between 0.000001 and 10 for options.sigma but received ${options.sigma}`);
-    }
-    this.upsertNode({
-      kind: "sharpen",
-      sigma: options.sigma ?? -1,
-      m1: options.m1 ?? 1,
-      m2: options.m2 ?? 2,
-      x1: options.x1 ?? 2,
-      y2: options.y2 ?? 10,
-      y3: options.y3 ?? 20
-    });
-    return this;
-  }
-  median(size = 3) {
-    if (size === false) {
-      const idx = this.nodes.findIndex((n) => n.kind === "median");
-      if (idx !== -1) this.nodes.splice(idx, 1);
-      return this;
-    }
-    const effSize = size === true ? 3 : size;
-    if (!Number.isInteger(effSize) || effSize < 1 || effSize > 1e3) {
-      throw new Error(`Expected integer between 1 and 1000 for size but received ${size}`);
-    }
-    this.upsertNode({ kind: "median", size: effSize });
-    return this;
-  }
-  dilate(width = 1) {
-    if (!Number.isInteger(width) || width <= 0) {
-      throw new Error(`Expected positive integer for dilate but received ${width}`);
-    }
-    this.upsertNode({ kind: "dilate", width });
-    return this;
-  }
-  erode(width = 1) {
-    if (!Number.isInteger(width) || width <= 0) {
-      throw new Error(`Expected positive integer for erode but received ${width}`);
-    }
-    this.upsertNode({ kind: "erode", width });
-    return this;
-  }
-  convolve(kernelSpec) {
-    if (!kernelSpec || typeof kernelSpec !== "object" || !Array.isArray(kernelSpec.kernel) || !Number.isInteger(kernelSpec.width) || !Number.isInteger(kernelSpec.height) || kernelSpec.width < 3 || kernelSpec.width > 1001 || kernelSpec.height < 3 || kernelSpec.height > 1001 || kernelSpec.width * kernelSpec.height !== kernelSpec.kernel.length) {
-      throw new Error("Invalid convolution kernel");
-    }
-    const defaultScale = kernelSpec.kernel.reduce((s, v) => s + v, 0) || 1;
-    this.upsertNode({
-      kind: "convolve",
-      width: kernelSpec.width,
-      height: kernelSpec.height,
-      kernel: [...kernelSpec.kernel],
-      scale: kernelSpec.scale ?? defaultScale,
-      offset: kernelSpec.offset ?? 0
-    });
-    return this;
-  }
-  ensureAlpha(alpha = 1) {
-    if (typeof alpha !== "number" || Number.isNaN(alpha) || alpha < 0 || alpha > 1) {
-      throw new Error(`Expected number between 0 and 1 for alpha but received ${alpha}`);
-    }
-    this.upsertNode({ kind: "ensureAlpha", alpha }, true);
-    return this;
-  }
-  removeAlpha() {
-    this.upsertNode({ kind: "removeAlpha" }, true);
-    return this;
-  }
-  extractChannel(channel) {
-    const ch = channel === "red" ? 0 : channel === "green" ? 1 : channel === "blue" ? 2 : channel === "alpha" ? 3 : channel;
-    if (!Number.isInteger(ch) || ch < 0 || ch > 3) {
-      throw new Error(`Expected integer or one of: red, green, blue, alpha for channel but received ${channel}`);
-    }
-    this.upsertNode({ kind: "extractChannel", channel: ch });
-    return this;
-  }
-  recomb(matrix) {
-    if (!Array.isArray(matrix) || matrix.length !== 3 && matrix.length !== 4) {
-      throw new Error(`Expected 3x3 or 4x4 array for inputMatrix but received ${matrix?.length}`);
-    }
-    const flatLen = matrix.reduce((acc, row) => acc + (Array.isArray(row) ? row.length : 0), 0);
-    if (flatLen !== 9 && flatLen !== 16) {
-      throw new Error(`Expected 3x3 or 4x4 array with cardinality of 9 or 16 for inputMatrix`);
-    }
-    this.upsertNode({
-      kind: "recomb",
-      matrix: matrix.map((row) => [...row])
-    });
-    return this;
-  }
-  toColorspace(colorspace) {
-    if (typeof colorspace !== "string") {
-      throw new Error(`Expected string for colourspace but received ${colorspace}`);
-    }
-    const norm = colorspace.toLowerCase();
-    const space = norm === "grey16" ? "grey16" : norm === "rgb16" ? "rgb16" : norm === "b-w" || norm === "bw" || norm === "gray" ? "b-w" : norm === "cmyk" ? "cmyk" : "srgb";
-    if (space === "srgb" && this.nodes.some((n) => n.kind === "grayscale")) {
-      const idx = this.nodes.findIndex((n) => n.kind === "toColorspace");
-      if (idx !== -1) this.nodes.splice(idx, 1);
-      return this;
-    }
-    this.upsertNode({ kind: "toColorspace", space });
-    return this;
-  }
-  toColourspace(colourspace) {
-    return this.toColorspace(colourspace);
-  }
-  pipelineColorspace(colorspace) {
-    return this.toColorspace(colorspace);
-  }
-  pipelineColourspace(colourspace) {
-    return this.toColorspace(colourspace);
-  }
-  bandbool(boolOp) {
-    if (boolOp !== "and" && boolOp !== "or" && boolOp !== "eor") {
-      throw new Error(`Expected one of: and, or, eor for boolOp but received ${boolOp}`);
-    }
-    this.upsertNode({ kind: "bandbool", op: boolOp });
-    return this;
-  }
-  boolean(operand, op, options) {
-    if (op !== "and" && op !== "or" && op !== "eor") {
-      throw new Error(`Expected one of: and, or, eor for operator but received ${op}`);
-    }
-    const data = this.operationInput(operand);
-    if (data) {
-      this.nodes.push({
-        kind: "boolean",
-        operand: data,
-        op,
-        ...options?.raw !== void 0 ? { options: { raw: options.raw } } : {}
-      });
-    }
-    return this;
-  }
-  joinChannel(images, options) {
-    const list = Array.isArray(images) ? images : [images];
-    this.nodes.push({
-      kind: "joinChannel",
-      inputs: list.map((buf) => {
-        const data = this.operationInput(buf);
-        if (!data) {
-          throw new Error(`Unsupported joinChannel input: ${typeof buf}`);
-        }
-        return {
-          data,
-          ...options !== void 0 ? { options } : {}
-        };
-      })
-    });
-    return this;
-  }
-  clahe(options) {
-    if (!options || typeof options !== "object") {
-      throw new Error("Expected plain object for clahe options");
-    }
-    if (!Number.isInteger(options.width) || options.width <= 0) {
-      throw new Error(`Expected integer greater than zero for width but received ${options.width}`);
-    }
-    if (!Number.isInteger(options.height) || options.height <= 0) {
-      throw new Error(`Expected integer greater than zero for height but received ${options.height}`);
-    }
-    if (options.maxSlope !== void 0 && (!Number.isInteger(options.maxSlope) || options.maxSlope < 0 || options.maxSlope > 100)) {
-      throw new Error(`Expected integer between 0 and 100 for maxSlope but received ${options.maxSlope}`);
-    }
-    this.upsertNode({
-      kind: "clahe",
-      width: options.width,
-      height: options.height,
-      maxSlope: options.maxSlope ?? 3
-    });
-    return this;
-  }
-  affine(matrix, options) {
-    const rawFlat = Array.isArray(matrix) ? Array.isArray(matrix[0]) ? [...matrix[0], ...matrix[1] ?? []] : [...matrix] : [];
-    if (rawFlat.length !== 4 || rawFlat.some((v) => typeof v !== "number" || Number.isNaN(v))) {
-      throw new Error(`Expected 1x4 or 2x2 array for matrix but received ${matrix} of type ${typeof matrix}`);
-    }
-    if (options?.interpolator !== void 0 && !["nearest", "bilinear", "bicubic", "lbb", "nohalo", "vsqbs"].includes(options.interpolator)) {
-      throw new Error(
-        `Expected valid interpolator name for options.interpolator but received ${options.interpolator} of type ${typeof options.interpolator}`
-      );
-    }
-    for (const key of ["idx", "idy", "odx", "ody"]) {
-      const val = options?.[key];
-      if (val !== void 0 && (typeof val !== "number" || Number.isNaN(val))) {
-        throw new Error(`Expected number for options.${key} but received ${val} of type ${typeof val}`);
-      }
-    }
-    const flat = [rawFlat[0], rawFlat[1], rawFlat[2], rawFlat[3]];
-    this.upsertNode({
-      kind: "affine",
-      matrix: flat,
-      background: parseColor(options?.background ?? "#000000", 255),
-      idx: options?.idx ?? 0,
-      idy: options?.idy ?? 0,
-      odx: options?.odx ?? 0,
-      ody: options?.ody ?? 0,
-      ...options?.interpolator !== void 0 ? { interpolator: options.interpolator } : {}
-    });
-    return this;
-  }
-  withMetadata(options) {
-    if (options && typeof options === "object") {
-      if (options.orientation !== void 0 && (!Number.isInteger(options.orientation) || options.orientation < 1 || options.orientation > 8)) {
-        throw new Error(`Expected integer between 1 and 8 for orientation but received ${options.orientation}`);
-      }
-      if (options.density !== void 0 && (typeof options.density !== "number" || Number.isNaN(options.density) || options.density <= 0)) {
-        throw new Error(`Expected positive number for density but received ${options.density}`);
-      }
-    }
-    const existingIdx = this.nodes.findIndex((n) => n.kind === "withMetadata");
-    const prev = existingIdx !== -1 ? this.nodes[existingIdx] : void 0;
-    const density = options?.density ?? prev?.density;
-    const orientation = options?.orientation ?? prev?.orientation;
-    this.upsertNode({
-      kind: "withMetadata",
-      ...density !== void 0 ? { density } : {},
-      ...orientation !== void 0 ? { orientation } : {}
-    });
-    this.outputOptions = {
-      ...this.outputOptions,
-      ...density !== void 0 ? { density } : {},
-      ...orientation !== void 0 ? { orientation } : {}
-    };
-    return this;
-  }
-  keepExif() {
-    return this.withMetadata();
-  }
-  withExif(exif) {
-    if (!exif || typeof exif !== "object" || Array.isArray(exif)) {
-      throw new Error(`Expected object for exif but received ${exif}`);
-    }
-    const orientStr = exif?.IFD0?.Orientation;
-    const orientNum = orientStr !== void 0 ? Number(orientStr) : void 0;
-    return this.withMetadata(orientNum !== void 0 && Number.isFinite(orientNum) ? { orientation: orientNum } : void 0);
-  }
-  withExifMerge(exif) {
-    return this.withExif(exif);
-  }
-  keepIccProfile() {
-    return this;
-  }
-  withIccProfile(profile, _options) {
-    if (typeof profile !== "string") {
-      throw new Error(`Expected string for icc but received ${profile}`);
-    }
-    return this;
-  }
-  timeout(options) {
-    if (!options || typeof options !== "object" || Array.isArray(options)) {
-      throw new Error(`Expected object for options but received ${options}`);
-    }
-    if (!Number.isInteger(options.seconds) || options.seconds < 0 || options.seconds > 3600) {
-      throw new Error(`Expected integer between 0 and 3600 for seconds but received ${options.seconds}`);
-    }
-    return this;
-  }
-  keepXmp() {
-    return this;
-  }
-  withXmp(xmp) {
-    if (typeof xmp !== "string" || xmp.length === 0) {
-      throw new Error(`Expected non-empty string for xmp but received ${xmp}`);
-    }
-    return this;
-  }
-  keepMetadata() {
-    return this.withMetadata();
-  }
-  validateQuality(q) {
-    if (q !== void 0 && (!Number.isInteger(q) || q < 1 || q > 100)) {
-      throw new Error(`Expected integer between 1 and 100 for quality but received ${q}`);
-    }
-  }
-  validateCompressionLevel(level) {
-    if (level !== void 0 && (!Number.isInteger(level) || level < 0 || level > 9)) {
-      throw new Error(`Expected integer between 0 and 9 for compressionLevel but received ${level}`);
-    }
-  }
-  jp2(options) {
-    this.validateQuality(options?.quality);
-    return this.png(options);
-  }
-  jxl(options) {
-    this.validateQuality(options?.quality);
-    return this.png(options);
-  }
-  tile(_options) {
-    return this;
-  }
-  png(options) {
-    this.validateCompressionLevel(options?.compressionLevel);
-    this.validateQuality(options?.quality);
-    const anyOpts = options;
-    for (const [k, label] of [
-      ["progressive", "pngProgressive"],
-      ["adaptiveFiltering", "pngAdaptiveFiltering"],
-      ["palette", "pngPalette"]
-    ]) {
-      if (anyOpts?.[k] !== void 0 && typeof anyOpts[k] !== "boolean") {
-        throw new Error(`Expected boolean for ${label} but received ${anyOpts[k]} of type ${typeof anyOpts[k]}`);
-      }
-    }
-    if (anyOpts?.effort !== void 0 && (!Number.isInteger(anyOpts.effort) || anyOpts.effort < 1 || anyOpts.effort > 10)) {
-      throw new Error(`Expected integer between 1 and 10 for effort but received ${anyOpts.effort} of type ${typeof anyOpts.effort}`);
-    }
-    const colours = anyOpts?.colours ?? anyOpts?.colors;
-    if (colours !== void 0 && (!Number.isInteger(colours) || colours < 2 || colours > 256)) {
-      throw new Error(`Expected integer between 2 and 256 for colours but received ${colours} of type ${typeof colours}`);
-    }
-    if (anyOpts?.dither !== void 0 && (typeof anyOpts.dither !== "number" || Number.isNaN(anyOpts.dither) || anyOpts.dither < 0 || anyOpts.dither > 1)) {
-      throw new Error(`Expected number between 0.0 and 1.0 for dither but received ${anyOpts.dither} of type ${typeof anyOpts.dither}`);
-    }
-    if (anyOpts?.bitdepth !== void 0 && ![1, 2, 4, 8, 16].includes(anyOpts.bitdepth)) {
-      throw new Error(`Expected 1, 2, 4, 8 or 16 for bitdepth but received ${anyOpts.bitdepth} of type ${typeof anyOpts.bitdepth}`);
-    }
-    this.outputOptions = {
-      ...this.outputOptions,
-      ...options?.force === false ? {} : { format: "png" },
-      ...options?.compressionLevel !== void 0 ? { compressionLevel: options.compressionLevel } : {},
-      ...options?.palette !== void 0 ? { palette: options.palette } : {}
-    };
-    return this;
-  }
-  jpeg(options) {
-    this.validateQuality(options?.quality);
-    const anyOpts = options;
-    for (const [k, label] of [
-      ["progressive", "jpegProgressive"],
-      ["trellisQuantisation", "jpegTrellisQuantisation"],
-      ["overshootDeringing", "jpegOvershootDeringing"],
-      ["optimiseScans", "jpegOptimiseScans"],
-      ["optimiseCoding", "jpegOptimiseCoding"],
-      ["mozjpeg", "mozjpeg"]
-    ]) {
-      if (anyOpts?.[k] !== void 0 && typeof anyOpts[k] !== "boolean") {
-        throw new Error(`Expected boolean for ${label} but received ${anyOpts[k]} of type ${typeof anyOpts[k]}`);
-      }
-    }
-    if (anyOpts?.chromaSubsampling !== void 0 && typeof anyOpts.chromaSubsampling !== "string") {
-      throw new Error(`Expected one of: 4:2:0, 4:4:4 for chromaSubsampling but received ${anyOpts.chromaSubsampling} of type ${typeof anyOpts.chromaSubsampling}`);
-    }
-    const qTable = anyOpts?.quantisationTable ?? anyOpts?.quantizationTable;
-    if (qTable !== void 0 && (!Number.isInteger(qTable) || qTable < 0 || qTable > 8)) {
-      throw new Error(`Expected integer between 0 and 8 for quantisationTable but received ${qTable} of type ${typeof qTable}`);
-    }
-    this.outputOptions = {
-      ...this.outputOptions,
-      ...options?.force === false ? {} : { format: "jpeg" },
-      ...options?.quality !== void 0 ? { quality: options.quality } : {}
-    };
-    return this;
-  }
-  webp(options) {
-    this.validateQuality(options?.quality);
-    const anyOpts = options;
-    for (const [k, label] of [
-      ["lossless", "webpLossless"],
-      ["nearLossless", "webpNearLossless"],
-      ["smartSubsample", "webpSmartSubsample"],
-      ["smartDeblock", "webpSmartDeblock"],
-      ["minSize", "webpMinSize"],
-      ["mixed", "webpMixed"]
-    ]) {
-      if (anyOpts?.[k] !== void 0 && typeof anyOpts[k] !== "boolean") {
-        throw new Error(`Expected boolean for ${label} but received ${anyOpts[k]} of type ${typeof anyOpts[k]}`);
-      }
-    }
-    if (anyOpts?.alphaQuality !== void 0 && (!Number.isInteger(anyOpts.alphaQuality) || anyOpts.alphaQuality < 0 || anyOpts.alphaQuality > 100)) {
-      throw new Error(
-        `Expected integer between 0 and 100 for alphaQuality but received ${anyOpts.alphaQuality} of type ${typeof anyOpts.alphaQuality}`
-      );
-    }
-    if (anyOpts?.effort !== void 0 && (!Number.isInteger(anyOpts.effort) || anyOpts.effort < 0 || anyOpts.effort > 6)) {
-      throw new Error(`Expected integer between 0 and 6 for effort but received ${anyOpts.effort} of type ${typeof anyOpts.effort}`);
-    }
-    if (anyOpts?.preset !== void 0 && !["default", "photo", "picture", "drawing", "icon", "text"].includes(anyOpts.preset)) {
-      throw new Error(
-        `Expected one of: default, photo, picture, drawing, icon, text for preset but received ${anyOpts.preset} of type ${typeof anyOpts.preset}`
-      );
-    }
-    this.outputOptions = {
-      ...this.outputOptions,
-      ...options?.force === false ? {} : { format: "webp" },
-      ...options?.quality !== void 0 ? { quality: options.quality } : {},
-      ...options?.lossless !== void 0 ? { lossless: options.lossless } : {}
-    };
-    return this;
-  }
-  heif(options) {
-    this.validateQuality(options?.quality);
-    if (options?.compression !== void 0 && !["av1", "hevc"].includes(options.compression)) {
-      throw new Error(`Expected one of: av1, hevc for compression but received ${options.compression} of type ${typeof options.compression}`);
-    }
-    const anyOpts = options;
-    if (anyOpts?.lossless !== void 0 && typeof anyOpts.lossless !== "boolean") {
-      throw new Error(`Expected boolean for lossless but received ${anyOpts.lossless} of type ${typeof anyOpts.lossless}`);
-    }
-    if (anyOpts?.chromaSubsampling !== void 0 && typeof anyOpts.chromaSubsampling !== "string") {
-      throw new Error(`Expected one of: 4:2:0, 4:4:4 for chromaSubsampling but received ${anyOpts.chromaSubsampling} of type ${typeof anyOpts.chromaSubsampling}`);
-    }
-    if (anyOpts?.bitdepth !== void 0 && ![8, 10, 12].includes(anyOpts.bitdepth)) {
-      throw new Error(`Expected 8, 10 or 12 for bitdepth but received ${anyOpts.bitdepth} of type ${typeof anyOpts.bitdepth}`);
-    }
-    if (anyOpts?.effort !== void 0 && (!Number.isInteger(anyOpts.effort) || anyOpts.effort < 0 || anyOpts.effort > 9)) {
-      throw new Error(`Expected integer between 0 and 9 for effort but received ${anyOpts.effort} of type ${typeof anyOpts.effort}`);
-    }
-    this.outputOptions = {
-      ...this.outputOptions,
-      ...options?.force === false ? {} : { format: "heif" },
-      ...options?.quality !== void 0 ? { quality: options.quality } : {},
-      ...options?.compression !== void 0 ? { compression: options.compression } : {},
-      ...options?.lossless !== void 0 ? { lossless: options.lossless } : {}
-    };
-    return this;
-  }
-  heic(options) {
-    this.validateQuality(options?.quality);
-    this.outputOptions = {
-      ...this.outputOptions,
-      ...options?.force === false ? {} : { format: "heic" },
-      compression: options?.compression ?? "hevc",
-      ...options?.quality !== void 0 ? { quality: options.quality } : {},
-      ...options?.lossless !== void 0 ? { lossless: options.lossless } : {}
-    };
-    return this;
-  }
-  avif(options) {
-    this.validateQuality(options?.quality);
-    const anyOpts = options;
-    if (anyOpts?.lossless !== void 0 && typeof anyOpts.lossless !== "boolean") {
-      throw new Error(`Expected boolean for lossless but received ${anyOpts.lossless} of type ${typeof anyOpts.lossless}`);
-    }
-    if (anyOpts?.chromaSubsampling !== void 0 && typeof anyOpts.chromaSubsampling !== "string") {
-      throw new Error(`Expected one of: 4:2:0, 4:4:4 for chromaSubsampling but received ${anyOpts.chromaSubsampling} of type ${typeof anyOpts.chromaSubsampling}`);
-    }
-    if (anyOpts?.bitdepth !== void 0 && ![8, 10, 12].includes(anyOpts.bitdepth)) {
-      throw new Error(`Expected 8, 10 or 12 for bitdepth but received ${anyOpts.bitdepth} of type ${typeof anyOpts.bitdepth}`);
-    }
-    if (anyOpts?.effort !== void 0 && (!Number.isInteger(anyOpts.effort) || anyOpts.effort < 0 || anyOpts.effort > 9)) {
-      throw new Error(`Expected integer between 0 and 9 for effort but received ${anyOpts.effort} of type ${typeof anyOpts.effort}`);
-    }
-    this.outputOptions = {
-      ...this.outputOptions,
-      ...options?.force === false ? {} : { format: "avif" },
-      compression: "av1",
-      ...options?.quality !== void 0 ? { quality: options.quality } : {},
-      ...options?.lossless !== void 0 ? { lossless: options.lossless } : {}
-    };
-    return this;
-  }
-  gif(options) {
-    const anyOpts = options;
-    if (anyOpts?.reuse !== void 0 && typeof anyOpts.reuse !== "boolean") {
-      throw new Error(`Expected boolean for gifReuse but received ${anyOpts.reuse} of type ${typeof anyOpts.reuse}`);
-    }
-    const prog = anyOpts?.progressive;
-    if (prog !== void 0 && typeof prog !== "boolean") {
-      throw new Error(`Expected boolean for gifProgressive but received ${prog} of type ${typeof prog}`);
-    }
-    const colours = anyOpts?.colours ?? anyOpts?.colors;
-    if (colours !== void 0 && (!Number.isInteger(colours) || colours < 2 || colours > 256)) {
-      throw new Error(`Expected integer between 2 and 256 for colours but received ${colours} of type ${typeof colours}`);
-    }
-    if (anyOpts?.effort !== void 0 && (!Number.isInteger(anyOpts.effort) || anyOpts.effort < 1 || anyOpts.effort > 10)) {
-      throw new Error(`Expected integer between 1 and 10 for effort but received ${anyOpts.effort} of type ${typeof anyOpts.effort}`);
-    }
-    if (anyOpts?.dither !== void 0 && (typeof anyOpts.dither !== "number" || Number.isNaN(anyOpts.dither) || anyOpts.dither < 0 || anyOpts.dither > 1)) {
-      throw new Error(`Expected number between 0.0 and 1.0 for dither but received ${anyOpts.dither} of type ${typeof anyOpts.dither}`);
-    }
-    if (anyOpts?.interFrameMaxError !== void 0 && (typeof anyOpts.interFrameMaxError !== "number" || Number.isNaN(anyOpts.interFrameMaxError) || anyOpts.interFrameMaxError < 0 || anyOpts.interFrameMaxError > 32)) {
-      throw new Error(`Expected number between 0.0 and 32.0 for interFrameMaxError but received ${anyOpts.interFrameMaxError} of type ${typeof anyOpts.interFrameMaxError}`);
-    }
-    if (anyOpts?.interPaletteMaxError !== void 0 && (typeof anyOpts.interPaletteMaxError !== "number" || Number.isNaN(anyOpts.interPaletteMaxError) || anyOpts.interPaletteMaxError < 0 || anyOpts.interPaletteMaxError > 256)) {
-      throw new Error(`Expected number between 0.0 and 256.0 for interPaletteMaxError but received ${anyOpts.interPaletteMaxError} of type ${typeof anyOpts.interPaletteMaxError}`);
-    }
-    if (options?.loop !== void 0 && (!Number.isInteger(options.loop) || options.loop < 0 || options.loop > 65535)) {
-      throw new Error(`Expected integer between 0 and 65535 for loop but received ${options.loop} of type ${typeof options.loop}`);
-    }
-    if (options?.delay !== void 0) {
-      const isValidDelay = Number.isInteger(options.delay) && options.delay >= 0 && options.delay <= 65535 || Array.isArray(options.delay) && options.delay.every((d) => Number.isInteger(d) && d >= 0 && d <= 65535);
-      if (!isValidDelay) {
-        throw new Error(
-          `Expected integer or an array of integers between 0 and 65535 for delay but received ${options.delay} of type ${typeof options.delay}`
-        );
-      }
-    }
-    this.outputOptions = {
-      ...this.outputOptions,
-      ...options?.force === false ? {} : { format: "gif" },
-      ...options?.pageHeight !== void 0 ? { pageHeight: options.pageHeight } : {},
-      ...options?.delay !== void 0 ? { delay: options.delay } : {},
-      ...options?.loop !== void 0 ? { loop: options.loop } : {}
-    };
-    return this;
-  }
-  ppm() {
-    this.outputOptions = { ...this.outputOptions, format: "ppm" };
-    return this;
-  }
-  pgm() {
-    this.outputOptions = { ...this.outputOptions, format: "pgm" };
-    return this;
-  }
-  pbm() {
-    this.outputOptions = { ...this.outputOptions, format: "pbm" };
-    return this;
-  }
-  bmp() {
-    this.outputOptions = { ...this.outputOptions, format: "bmp" };
-    return this;
-  }
-  tiff(options) {
-    this.validateQuality(options?.quality);
-    const anyOpts = options;
-    if (anyOpts?.predictor !== void 0 && !["none", "horizontal", "float"].includes(anyOpts.predictor)) {
-      throw new Error(`Expected one of: none, horizontal, float for predictor but received ${anyOpts.predictor} of type ${typeof anyOpts.predictor}`);
-    }
-    for (const [k, label] of [
-      ["pyramid", "tiffPyramid"],
-      ["tile", "tiffTile"],
-      ["miniswhite", "tiffMiniswhite"]
-    ]) {
-      if (anyOpts?.[k] !== void 0 && typeof anyOpts[k] !== "boolean") {
-        throw new Error(`Expected boolean for ${label} but received ${anyOpts[k]} of type ${typeof anyOpts[k]}`);
-      }
-    }
-    if (anyOpts?.tileWidth !== void 0 && (!Number.isInteger(anyOpts.tileWidth) || anyOpts.tileWidth <= 0)) {
-      throw new Error(`Expected integer greater than zero for tileWidth but received ${anyOpts.tileWidth} of type ${typeof anyOpts.tileWidth}`);
-    }
-    if (anyOpts?.tileHeight !== void 0 && (!Number.isInteger(anyOpts.tileHeight) || anyOpts.tileHeight <= 0)) {
-      throw new Error(`Expected integer greater than zero for tileHeight but received ${anyOpts.tileHeight} of type ${typeof anyOpts.tileHeight}`);
-    }
-    if (anyOpts?.xres !== void 0 && (typeof anyOpts.xres !== "number" || Number.isNaN(anyOpts.xres) || anyOpts.xres <= 0)) {
-      throw new Error(`Expected number greater than zero for xres but received ${anyOpts.xres} of type ${typeof anyOpts.xres}`);
-    }
-    if (anyOpts?.yres !== void 0 && (typeof anyOpts.yres !== "number" || Number.isNaN(anyOpts.yres) || anyOpts.yres <= 0)) {
-      throw new Error(`Expected number greater than zero for yres but received ${anyOpts.yres} of type ${typeof anyOpts.yres}`);
-    }
-    if (anyOpts?.resolutionUnit !== void 0 && !["inch", "cm"].includes(anyOpts.resolutionUnit)) {
-      throw new Error(`Expected one of: inch, cm for resolutionUnit but received ${anyOpts.resolutionUnit} of type ${typeof anyOpts.resolutionUnit}`);
-    }
-    if (anyOpts?.compression !== void 0 && !["none", "jpeg", "deflate", "packbits", "ccittfax4", "lzw", "webp", "zstd", "jp2k"].includes(anyOpts.compression)) {
-      throw new Error(
-        `Expected one of: none, jpeg, deflate, packbits, ccittfax4, lzw, webp, zstd, jp2k for compression but received ${anyOpts.compression} of type ${typeof anyOpts.compression}`
-      );
-    }
-    if (anyOpts?.bitdepth !== void 0 && ![1, 2, 4, 8].includes(anyOpts.bitdepth)) {
-      throw new Error(`Expected 1, 2, 4 or 8 for bitdepth but received ${anyOpts.bitdepth} of type ${typeof anyOpts.bitdepth}`);
-    }
-    this.outputOptions = {
-      ...this.outputOptions,
-      ...options?.force === false ? {} : { format: "tiff" },
-      ...options?.quality !== void 0 ? { quality: options.quality } : {}
-    };
-    return this;
-  }
-  raw(options) {
-    if (options?.depth !== void 0 && !["char", "uchar", "short", "ushort", "int", "uint", "float", "complex", "double", "dpcomplex"].includes(options.depth)) {
-      throw new Error(
-        `Expected one of: char, uchar, short, ushort, int, uint, float, complex, double, dpcomplex for depth but received ${options.depth} of type ${typeof options.depth}`
-      );
-    }
-    this.outputOptions = {
-      ...this.outputOptions,
-      format: "raw",
-      ...options?.depth !== void 0 ? { rawDepth: options.depth } : {}
-    };
-    return this;
-  }
-  toFormat(format, options) {
-    const rawFmt = typeof format === "object" && format !== null ? format.id : String(format);
-    const lower = rawFmt.toLowerCase();
-    const norm = lower === "jpg" || lower === "jpe" ? "jpeg" : lower === "tif" ? "tiff" : lower;
-    const validFormats = [
-      "jpeg",
-      "png",
-      "webp",
-      "tiff",
-      "heif",
-      "heic",
-      "avif",
-      "gif",
-      "svg",
-      "pdf",
-      "ppm",
-      "pgm",
-      "pbm",
-      "bmp",
-      "raw",
-      "jp2",
-      "jxl"
-    ];
-    if (!validFormats.includes(norm)) {
-      throw new Error(`Expected one of: ${validFormats.join(", ")} for format but received ${rawFmt}`);
-    }
-    this.validateQuality(options?.quality);
-    this.validateCompressionLevel(options?.compressionLevel);
-    this.outputOptions = {
-      ...this.outputOptions,
-      ...options?.force === false ? {} : { format: norm },
-      ...options?.quality !== void 0 ? { quality: options.quality } : {},
-      ...options?.compression !== void 0 ? { compression: options.compression } : {},
-      ...options?.compressionLevel !== void 0 ? { compressionLevel: options.compressionLevel } : {},
-      ...options?.lossless !== void 0 ? { lossless: options.lossless } : {}
-    };
-    return this;
-  }
-  toBufferWithObjectSync() {
-    let img = this.evaluateImage();
-    if (this.outputOptions.format === "raw" && (img.channels === 2 || img.channels === 1 && this.nodes.some((n) => n.kind === "removeAlpha" || n.kind === "flatten")) && !this.nodes.some(
-      (n) => n.kind === "toColorspace" && n.space === "b-w" || n.kind === "grayscale" || n.kind === "joinChannel" || n.kind === "extractChannel"
-    )) {
-      img = { ...img, space: "srgb", channels: img.hasAlpha ? 4 : 3 };
-    }
-    const encoded2 = encodeImage(img, this.outputOptions);
-    const outBuf = outputBytes(encoded2.data);
-    return {
-      data: outBuf,
-      info: {
-        format: encoded2.format,
-        width: img.width,
-        height: img.height,
-        channels: encoded2.channels,
-        ...encoded2.format === "raw" ? { depth: this.outputOptions.rawDepth ?? img.depth } : {},
-        premultiplied: Boolean(img.wasPremultiplied),
-        ...img.pageHeight !== void 0 ? { pageHeight: img.pageHeight } : {},
-        ...img.pageHeight !== void 0 && (img.sourcePages ?? img.pages) !== void 0 ? { pages: img.sourcePages ?? img.pages } : {},
-        ...img.trimOffsetLeft !== void 0 ? { trimOffsetLeft: img.trimOffsetLeft } : {},
-        ...img.trimOffsetTop !== void 0 ? { trimOffsetTop: img.trimOffsetTop } : {},
-        ...img.textAutofitDpi !== void 0 ? { textAutofitDpi: img.textAutofitDpi } : {},
-        size: encoded2.data.byteLength
-      }
-    };
-  }
-  toBufferSync() {
-    return this.toBufferWithObjectSync().data;
-  }
-  async toFile(fileOut, callback) {
-    try {
-      if (!fileOut || typeof fileOut !== "string") {
-        throw new Error("Missing output file path");
-      }
-      if (this.inputFilePath && normalizePath(fileOut) === normalizePath(this.inputFilePath)) {
-        throw new Error("Cannot use same file for input and output");
-      }
-      const filesystem = this.inputOptions?.filesystem;
-      if (!filesystem) throw new Error("File outputs require an explicit filesystem");
-      const prevFormat = this.outputOptions.format;
-      const inferred = prevFormat ?? inferFormatFromPath(fileOut);
-      if (!prevFormat && inferred) {
-        this.outputOptions = { ...this.outputOptions, format: inferred };
-      }
-      try {
-        await this.waitForStreamInput();
-        const res = this.toBufferWithObjectSync();
-        await filesystem.writeFile(fileOut, res.data);
-        if (callback) callback(null, res.info);
-        return res.info;
-      } finally {
-        if (!prevFormat && inferred) {
-          const { format: _omit, ...rest } = this.outputOptions;
-          this.outputOptions = rest;
-        }
-      }
-    } catch (err) {
-      if (callback) callback(err);
-      throw err;
-    }
-  }
-  async toBuffer(optionsOrCallback) {
-    const cb = typeof optionsOrCallback === "function" ? optionsOrCallback : void 0;
-    const options = typeof optionsOrCallback === "object" && optionsOrCallback !== null ? optionsOrCallback : void 0;
-    try {
-      await this.waitForStreamInput();
-      const res = this.toBufferWithObjectSync();
-      if (cb) cb(null, res.data, res.info);
-      if (options?.resolveWithObject) {
-        return res;
-      }
-      return res.data;
-    } catch (err) {
-      if (cb) cb(err);
-      throw err;
-    }
-  }
-};
-function sharp(input, options) {
-  return new SharpInstance(input, options);
-}
-Object.assign(sharp, {
-  align: {
-    left: "low",
-    top: "low",
-    low: "low",
-    center: "centre",
-    centre: "centre",
-    right: "high",
-    bottom: "high",
-    high: "high"
-  },
-  position: {
-    top: 1,
-    right: 2,
-    bottom: 3,
-    left: 4,
-    "right top": 5,
-    "right bottom": 6,
-    "left bottom": 7,
-    "left top": 8
-  },
-  blend: {
-    clear: "clear",
-    source: "source",
-    over: "over",
-    in: "in",
-    out: "out",
-    atop: "atop",
-    dest: "dest",
-    "dest-over": "dest-over",
-    "dest-in": "dest-in",
-    "dest-out": "dest-out",
-    "dest-atop": "dest-atop",
-    xor: "xor",
-    add: "add",
-    saturate: "saturate",
-    multiply: "multiply",
-    screen: "screen",
-    overlay: "overlay",
-    darken: "darken",
-    lighten: "lighten",
-    "colour-dodge": "colour-dodge",
-    "color-dodge": "colour-dodge",
-    "colour-burn": "colour-burn",
-    "color-burn": "colour-burn",
-    "hard-light": "hard-light",
-    "soft-light": "soft-light",
-    difference: "difference",
-    exclusion: "exclusion"
-  },
-  queue: new EventEmitter(),
-  gravity: {
-    center: 0,
-    centre: 0,
-    north: 1,
-    east: 2,
-    south: 3,
-    west: 4,
-    northeast: 5,
-    southeast: 6,
-    southwest: 7,
-    northwest: 8
-  },
-  fit: {
-    contain: "contain",
-    cover: "cover",
-    fill: "fill",
-    inside: "inside",
-    outside: "outside"
-  },
-  kernel: {
-    nearest: "nearest",
-    linear: "linear",
-    cubic: "cubic",
-    mitchell: "mitchell",
-    lanczos2: "lanczos2",
-    lanczos3: "lanczos3",
-    mks2013: "mks2013",
-    mks2021: "mks2021"
-  },
-  bool: {
-    and: "and",
-    or: "or",
-    eor: "eor"
-  },
-  strategy: {
-    entropy: 16,
-    attention: 17
-  },
-  colourspace: {
-    multiband: "multiband",
-    "b-w": "b-w",
-    bw: "b-w",
-    cmyk: "cmyk",
-    srgb: "srgb"
-  },
-  colorspace: {
-    multiband: "multiband",
-    "b-w": "b-w",
-    bw: "b-w",
-    cmyk: "cmyk",
-    srgb: "srgb"
-  },
-  interpolators: {
-    nearest: "nearest",
-    bilinear: "bilinear",
-    bicubic: "bicubic",
-    locallyBoundedBicubic: "lbb",
-    nohalo: "nohalo",
-    vertexSplitQuadraticBasisSpline: "vsqbs"
-  },
-  format: Object.fromEntries(
-    ["jpeg", "png", "webp", "tiff", "heif", "heic", "avif", "gif", "svg", "pdf", "ppm", "pgm", "pbm", "bmp", "raw"].map(
-      (id) => [
-        id,
-        {
-          id,
-          input: { file: true, buffer: true, stream: true },
-          output: { file: true, buffer: true, stream: true }
-        }
-      ]
-    )
-  ),
-  cache: /* @__PURE__ */ (() => {
-    let memMax = 50;
-    let filesMax = 20;
-    let itemsMax = 100;
-    return (options) => {
-      if (options === false) {
-        memMax = 0;
-        filesMax = 0;
-        itemsMax = 0;
-      } else if (options === true) {
-        memMax = 50;
-        filesMax = 20;
-        itemsMax = 100;
-      } else if (options && typeof options === "object") {
-        if (typeof options.memory === "number") memMax = options.memory;
-        if (typeof options.files === "number") filesMax = options.files;
-        if (typeof options.items === "number") itemsMax = options.items;
-      }
-      return {
-        memory: { current: 0, high: 0, max: memMax },
-        files: { current: 0, max: filesMax },
-        items: { current: 0, max: itemsMax }
-      };
-    };
-  })(),
-  concurrency: /* @__PURE__ */ (() => {
-    let threads = 4;
-    return (n) => {
-      if (typeof n === "number" && n > 0) threads = Math.floor(n);
-      return threads;
-    };
-  })(),
-  counters: () => ({ queue: 0, process: 0 }),
-  simd: /* @__PURE__ */ (() => {
-    let enabled = true;
-    return (enable) => {
-      if (typeof enable === "boolean") enabled = enable;
-      return enabled;
-    };
-  })(),
-  block: (_options) => {
-  },
-  unblock: (_options) => {
-  },
-  versions: {
-    vips: "8.16.1",
-    sharp: "0.34.5"
-  }
-});
-
 // packages/pdf/src/errors.ts
 init_buffer();
 var PdfError = class extends Error {