@poe-platform/safe-bash 0.1.802 → 0.1.804

package/dist/safe-bash/command-chunks/{chunk-YG4EPFWC.js → chunk-M3NINRDU.js}

@@ -1282,35 +1282,183 @@ function buildHuffmanTree(counts, symbols) {
     }
     level = nextLevel.slice(count);
   }
+  const fastLut = new Int32Array(256).fill(-1);
+  for (let byte = 0; byte < 256; byte++) {
+    let node = root;
+    for (let bitIdx = 7; bitIdx >= 0; bitIdx--) {
+      node = node?.children?.[byte >>> bitIdx & 1];
+      if (!node) break;
+      if (node.symbol !== void 0) {
+        const len = 8 - bitIdx;
+        fastLut[byte] = len << 8 | node.symbol;
+        break;
+      }
+    }
+  }
+  root.fastLut = fastLut;
   return root;
 }
-function idct8x8(coeffs, quant, out) {
-  const dequant = new Float64Array(64);
-  for (let i = 0; i < 64; i++) {
-    dequant[ZIGZAG[i]] = coeffs[i] * quant[i];
+var IDCT_DEQUANT = new Float64Array(64);
+var IDCT_TEMP = new Float64Array(64);
+var SCRATCH_COEFFS = new Int32Array(64);
+var BOX4_TABLE = (() => {
+  const table = new Float64Array(32);
+  for (let q = 0; q < 4; q++) {
+    for (let u = 0; u < 8; u++) {
+      table[q * 8 + u] = 0.25 * (COS_TABLE[u * 8 + 2 * q] + COS_TABLE[u * 8 + 2 * q + 1]);
+    }
+  }
+  return table;
+})();
+var BOX2_TABLE = (() => {
+  const table = new Float64Array(16);
+  for (let q = 0; q < 2; q++) {
+    for (let u = 0; u < 8; u++) {
+      table[q * 8 + u] = 0.125 * (COS_TABLE[u * 8 + 4 * q] + COS_TABLE[u * 8 + 4 * q + 1] + COS_TABLE[u * 8 + 4 * q + 2] + COS_TABLE[u * 8 + 4 * q + 3]);
+    }
+  }
+  return table;
+})();
+function idct8x8(coeffs, quant, out, maxK = 63) {
+  if (maxK === 0) {
+    const dcVal = Math.round(coeffs[0] * quant[0] * 0.125 + 128);
+    const clamped = dcVal < 0 ? 0 : dcVal > 255 ? 255 : dcVal;
+    out.fill(clamped, 0, 64);
+    return;
+  }
+  IDCT_DEQUANT.fill(0);
+  for (let i = 0; i <= maxK; i++) {
+    const c = coeffs[i];
+    if (c !== 0) {
+      IDCT_DEQUANT[ZIGZAG[i]] = c * quant[i];
+    }
   }
-  const temp = new Float64Array(64);
   for (let y = 0; y < 8; y++) {
+    const rowOff = y * 8;
+    const d0 = IDCT_DEQUANT[rowOff];
+    const d1 = IDCT_DEQUANT[rowOff + 1];
+    const d2 = IDCT_DEQUANT[rowOff + 2];
+    const d3 = IDCT_DEQUANT[rowOff + 3];
+    const d4 = IDCT_DEQUANT[rowOff + 4];
+    const d5 = IDCT_DEQUANT[rowOff + 5];
+    const d6 = IDCT_DEQUANT[rowOff + 6];
+    const d7 = IDCT_DEQUANT[rowOff + 7];
+    if (d1 === 0 && d2 === 0 && d3 === 0 && d4 === 0 && d5 === 0 && d6 === 0 && d7 === 0) {
+      const v = d0 * COS_TABLE[0] * 0.5;
+      IDCT_TEMP[rowOff] = v;
+      IDCT_TEMP[rowOff + 1] = v;
+      IDCT_TEMP[rowOff + 2] = v;
+      IDCT_TEMP[rowOff + 3] = v;
+      IDCT_TEMP[rowOff + 4] = v;
+      IDCT_TEMP[rowOff + 5] = v;
+      IDCT_TEMP[rowOff + 6] = v;
+      IDCT_TEMP[rowOff + 7] = v;
+      continue;
+    }
     for (let x = 0; x < 8; x++) {
-      let sum = 0;
-      for (let u = 0; u < 8; u++) {
-        sum += dequant[y * 8 + u] * COS_TABLE[u * 8 + x];
-      }
-      temp[y * 8 + x] = sum * 0.5;
+      const sum = d0 * COS_TABLE[x] + d1 * COS_TABLE[8 + x] + d2 * COS_TABLE[16 + x] + d3 * COS_TABLE[24 + x] + d4 * COS_TABLE[32 + x] + d5 * COS_TABLE[40 + x] + d6 * COS_TABLE[48 + x] + d7 * COS_TABLE[56 + x];
+      IDCT_TEMP[rowOff + x] = sum * 0.5;
     }
   }
   for (let x = 0; x < 8; x++) {
+    const t0 = IDCT_TEMP[x];
+    const t1 = IDCT_TEMP[8 + x];
+    const t2 = IDCT_TEMP[16 + x];
+    const t3 = IDCT_TEMP[24 + x];
+    const t4 = IDCT_TEMP[32 + x];
+    const t5 = IDCT_TEMP[40 + x];
+    const t6 = IDCT_TEMP[48 + x];
+    const t7 = IDCT_TEMP[56 + x];
     for (let y = 0; y < 8; y++) {
-      let sum = 0;
-      for (let v = 0; v < 8; v++) {
-        sum += temp[v * 8 + x] * COS_TABLE[v * 8 + y];
-      }
+      const sum = t0 * COS_TABLE[y] + t1 * COS_TABLE[8 + y] + t2 * COS_TABLE[16 + y] + t3 * COS_TABLE[24 + y] + t4 * COS_TABLE[32 + y] + t5 * COS_TABLE[40 + y] + t6 * COS_TABLE[48 + y] + t7 * COS_TABLE[56 + y];
       const val = Math.round(sum * 0.5 + 128);
       out[y * 8 + x] = val < 0 ? 0 : val > 255 ? 255 : val;
     }
   }
 }
-function decodeJpegImage(bytes) {
+function idctScaledBlock(coeffs, quant, out, maxK, step) {
+  if (step === 8) {
+    idct8x8(coeffs, quant, out, maxK);
+    return;
+  }
+  if (maxK === 0) {
+    const dcVal = Math.round(coeffs[0] * quant[0] * 0.125 + 128);
+    const clamped = dcVal < 0 ? 0 : dcVal > 255 ? 255 : dcVal;
+    out.fill(clamped, 0, step * step);
+    return;
+  }
+  IDCT_DEQUANT.fill(0);
+  for (let i = 0; i <= maxK; i++) {
+    const c = coeffs[i];
+    if (c !== 0) {
+      IDCT_DEQUANT[ZIGZAG[i]] = c * quant[i];
+    }
+  }
+  if (step === 4) {
+    for (let y = 0; y < 8; y++) {
+      const rowOff = y * 8;
+      const d0 = IDCT_DEQUANT[rowOff];
+      const d1 = IDCT_DEQUANT[rowOff + 1];
+      const d2 = IDCT_DEQUANT[rowOff + 2];
+      const d3 = IDCT_DEQUANT[rowOff + 3];
+      const d4 = IDCT_DEQUANT[rowOff + 4];
+      const d5 = IDCT_DEQUANT[rowOff + 5];
+      const d6 = IDCT_DEQUANT[rowOff + 6];
+      const d7 = IDCT_DEQUANT[rowOff + 7];
+      const dstOff = y * 4;
+      if (d1 === 0 && d2 === 0 && d3 === 0 && d4 === 0 && d5 === 0 && d6 === 0 && d7 === 0) {
+        const v = d0 * BOX4_TABLE[0];
+        IDCT_TEMP[dstOff] = v;
+        IDCT_TEMP[dstOff + 1] = v;
+        IDCT_TEMP[dstOff + 2] = v;
+        IDCT_TEMP[dstOff + 3] = v;
+        continue;
+      }
+      for (let qx = 0; qx < 4; qx++) {
+        const bOff = qx * 8;
+        IDCT_TEMP[dstOff + qx] = d0 * BOX4_TABLE[bOff] + d1 * BOX4_TABLE[bOff + 1] + d2 * BOX4_TABLE[bOff + 2] + d3 * BOX4_TABLE[bOff + 3] + d4 * BOX4_TABLE[bOff + 4] + d5 * BOX4_TABLE[bOff + 5] + d6 * BOX4_TABLE[bOff + 6] + d7 * BOX4_TABLE[bOff + 7];
+      }
+    }
+    for (let qx = 0; qx < 4; qx++) {
+      const t0 = IDCT_TEMP[qx];
+      const t1 = IDCT_TEMP[4 + qx];
+      const t2 = IDCT_TEMP[8 + qx];
+      const t3 = IDCT_TEMP[12 + qx];
+      const t4 = IDCT_TEMP[16 + qx];
+      const t5 = IDCT_TEMP[20 + qx];
+      const t6 = IDCT_TEMP[24 + qx];
+      const t7 = IDCT_TEMP[28 + qx];
+      for (let qy = 0; qy < 4; qy++) {
+        const bOff = qy * 8;
+        const sum = t0 * BOX4_TABLE[bOff] + t1 * BOX4_TABLE[bOff + 1] + t2 * BOX4_TABLE[bOff + 2] + t3 * BOX4_TABLE[bOff + 3] + t4 * BOX4_TABLE[bOff + 4] + t5 * BOX4_TABLE[bOff + 5] + t6 * BOX4_TABLE[bOff + 6] + t7 * BOX4_TABLE[bOff + 7];
+        const val = Math.round(sum + 128);
+        out[qy * 4 + qx] = val < 0 ? 0 : val > 255 ? 255 : val;
+      }
+    }
+  } else {
+    for (let y = 0; y < 8; y++) {
+      const rowOff = y * 8;
+      const d0 = IDCT_DEQUANT[rowOff];
+      const d1 = IDCT_DEQUANT[rowOff + 1];
+      const d3 = IDCT_DEQUANT[rowOff + 3];
+      const d5 = IDCT_DEQUANT[rowOff + 5];
+      const d7 = IDCT_DEQUANT[rowOff + 7];
+      const evenTerm = d0 * BOX2_TABLE[0];
+      const oddTerm = d1 * BOX2_TABLE[1] + d3 * BOX2_TABLE[3] + d5 * BOX2_TABLE[5] + d7 * BOX2_TABLE[7];
+      IDCT_TEMP[y * 2] = evenTerm + oddTerm;
+      IDCT_TEMP[y * 2 + 1] = evenTerm - oddTerm;
+    }
+    for (let qx = 0; qx < 2; qx++) {
+      const evenCol = (IDCT_TEMP[qx] + IDCT_TEMP[2 + qx] + IDCT_TEMP[4 + qx] + IDCT_TEMP[6 + qx] + IDCT_TEMP[8 + qx] + IDCT_TEMP[10 + qx] + IDCT_TEMP[12 + qx] + IDCT_TEMP[14 + qx]) * BOX2_TABLE[0];
+      const oddCol = (IDCT_TEMP[qx] - IDCT_TEMP[14 + qx]) * BOX2_TABLE[1] + (IDCT_TEMP[2 + qx] - IDCT_TEMP[12 + qx]) * BOX2_TABLE[3] + (IDCT_TEMP[4 + qx] - IDCT_TEMP[10 + qx]) * BOX2_TABLE[5] + (IDCT_TEMP[6 + qx] - IDCT_TEMP[8 + qx]) * BOX2_TABLE[7];
+      const v0 = Math.round(evenCol + oddCol + 128);
+      const v1 = Math.round(evenCol - oddCol + 128);
+      out[qx] = v0 < 0 ? 0 : v0 > 255 ? 255 : v0;
+      out[2 + qx] = v1 < 0 ? 0 : v1 > 255 ? 255 : v1;
+    }
+  }
+}
+function decodeJpegImage(bytes, options) {
   const meta = readJpegMetadata(bytes);
   const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
   const quantTables = [];
@@ -1318,6 +1466,12 @@ function decodeJpegImage(bytes) {
   const acTrees = [];
   let width = 0;
   let height = 0;
+  let scaleDenom = 1;
+  let blockStep = 8;
+  let outWidth = 0;
+  let outHeight = 0;
+  let useStripDecode = false;
+  let outRgba;
   let maxH = 1;
   let maxV = 1;
   let mcusX = 0;
@@ -1373,6 +1527,19 @@ function decodeJpegImage(bytes) {
     } else if (marker === 192 || marker === 193 || marker === 194) {
       height = payload[1] << 8 | payload[2];
       width = payload[3] << 8 | payload[4];
+      if (!meta.isProgressive && options?.maxDecodeDimension && options.maxDecodeDimension > 0) {
+        const maxSide = Math.max(width, height);
+        const minSide = Math.min(width, height);
+        if (maxSide >= options.maxDecodeDimension * 4 && minSide >= options.maxDecodeDimension * 2) {
+          scaleDenom = 4;
+          blockStep = 2;
+        } else if (maxSide >= options.maxDecodeDimension * 2) {
+          scaleDenom = 2;
+          blockStep = 4;
+        }
+      }
+      outWidth = Math.max(1, Math.ceil(width / scaleDenom));
+      outHeight = Math.max(1, Math.ceil(height / scaleDenom));
       const numComps = payload[5];
       components.length = 0;
       maxH = 1;
@@ -1394,16 +1561,22 @@ function decodeJpegImage(bytes) {
           acId: 0,
           dcPred: 0,
           blocksX: 0,
-          blocksY: 0,
-          blocks: []
+          blocksY: 0
         });
       }
       mcusX = Math.ceil(width / (maxH * 8));
       mcusY = Math.ceil(height / (maxV * 8));
+      useStripDecode = !meta.isProgressive && (scaleDenom > 1 || width * height > 512 * 512);
       for (const comp of components) {
         comp.blocksX = mcusX * comp.h;
         comp.blocksY = mcusY * comp.v;
-        comp.blocks = Array.from({ length: comp.blocksX * comp.blocksY }, () => new Int32Array(64));
+        if (meta.isProgressive) {
+          comp.blocksFlat = new Int16Array(comp.blocksX * comp.blocksY * 64);
+        } else if (useStripDecode) {
+          comp.stripPixels = new Uint8Array(comp.blocksX * blockStep * comp.v * blockStep);
+        } else {
+          comp.pixels = new Uint8Array(comp.blocksX * blockStep * comp.blocksY * blockStep);
+        }
       }
     } else if (marker === 218) {
       const scanCompsCount = payload[0];
@@ -1417,6 +1590,17 @@ function decodeJpegImage(bytes) {
         comp.acId = tdta & 15;
         scanComps.push(comp);
       }
+      if (!meta.isProgressive && scanCompsCount < components.length) {
+        useStripDecode = false;
+        for (const comp of components) {
+          if (!comp.pixels) {
+            comp.pixels = new Uint8Array(comp.blocksX * blockStep * comp.blocksY * blockStep);
+          }
+        }
+      }
+      if (useStripDecode && !outRgba) {
+        outRgba = new Uint8Array(outWidth * outHeight * 4);
+      }
       const ssPos = 1 + scanCompsCount * 2;
       const spectralStart = payload[ssPos] ?? 0;
       const spectralEnd = payload[ssPos + 1] ?? 63;
@@ -1427,6 +1611,23 @@ function decodeJpegImage(bytes) {
       let bitBuf = 0;
       let bitCount = 0;
       let eobRun = 0;
+      const refillBits = () => {
+        while (bitCount <= 16 && scanPos < bytes.length) {
+          const b = bytes[scanPos];
+          if (b === 255) {
+            if (scanPos + 1 >= bytes.length || bytes[scanPos + 1] !== 0) {
+              break;
+            }
+            scanPos += 2;
+            bitBuf = (bitBuf << 8 | 255) >>> 0;
+            bitCount += 8;
+          } else {
+            scanPos++;
+            bitBuf = (bitBuf << 8 | b) >>> 0;
+            bitCount += 8;
+          }
+        }
+      };
       const readBit = () => {
         if (bitCount === 0) {
           if (scanPos >= bytes.length) throw new Error("Truncated JPEG entropy data");
@@ -1443,6 +1644,13 @@ function decodeJpegImage(bytes) {
         return bit;
       };
       const readBits = (n) => {
+        if (n === 0) return 0;
+        if (bitCount < n) refillBits();
+        if (bitCount >= n) {
+          const val2 = bitBuf >>> bitCount - n & (1 << n) - 1;
+          bitCount -= n;
+          return val2;
+        }
         let val = 0;
         for (let i = 0; i < n; i++) {
           val = val << 1 | readBit();
@@ -1455,6 +1663,16 @@ function decodeJpegImage(bytes) {
         return v < 1 << n - 1 ? v + (-1 << n) + 1 : v;
       };
       const decodeSymbol = (tree) => {
+        if (!tree) throw new Error("Invalid JPEG Huffman code");
+        if (bitCount < 8) refillBits();
+        if (bitCount >= 8 && tree.fastLut) {
+          const peek = bitBuf >>> bitCount - 8 & 255;
+          const fast = tree.fastLut[peek];
+          if (fast >= 0) {
+            bitCount -= fast >>> 8;
+            return fast & 255;
+          }
+        }
         let node = tree;
         while (node && node.symbol === void 0) {
           const bit = readBit();
@@ -1464,12 +1682,14 @@ function decodeJpegImage(bytes) {
         return node.symbol;
       };
       const decodeBlockBaseline = (comp, block) => {
+        block.fill(0);
         const dcTree = dcTrees[comp.dcId];
         const acTree = acTrees[comp.acId];
         const t = decodeSymbol(dcTree);
         const diff = receiveExtend(t);
         comp.dcPred += diff;
         block[0] = comp.dcPred;
+        let maxK = 0;
         let k = 1;
         while (k < 64) {
           const rs = decodeSymbol(acTree);
@@ -1485,9 +1705,11 @@ function decodeJpegImage(bytes) {
           k += r;
           if (k < 64) {
             block[k] = receiveExtend(s);
+            maxK = k;
           }
           k++;
         }
+        return maxK;
       };
       const decodeBlockProgressive = (comp, block) => {
         if (spectralStart === 0) {
@@ -1562,6 +1784,24 @@ function decodeJpegImage(bytes) {
           }
         }
       };
+      const blockOut = new Uint8Array(64);
+      const decodeAndStoreBaselineBlock = (comp, bx, by, stripVy) => {
+        const maxK = decodeBlockBaseline(comp, SCRATCH_COEFFS);
+        const quant = quantTables[comp.qId];
+        if (!quant) throw new Error("Missing JPEG quantization table");
+        idctScaledBlock(SCRATCH_COEFFS, quant, blockOut, maxK, blockStep);
+        const stride = comp.blocksX * blockStep;
+        const dst = useStripDecode ? comp.stripPixels : comp.pixels;
+        const baseRow = (useStripDecode ? stripVy : by) * blockStep;
+        const baseCol = bx * blockStep;
+        for (let y = 0; y < blockStep; y++) {
+          const dstOff = (baseRow + y) * stride + baseCol;
+          const srcOff = y * blockStep;
+          for (let x = 0; x < blockStep; x++) {
+            dst[dstOff + x] = blockOut[srcOff + x];
+          }
+        }
+      };
       let mcuCounter = 0;
       let restartCounter = 0;
       const consumeRestart = () => {
@@ -1582,13 +1822,17 @@ function decodeJpegImage(bytes) {
             if (restartInterval > 0 && mcuCounter > 0 && mcuCounter % restartInterval === 0) {
               consumeRestart();
             }
-            const block = comp.blocks[by * comp.blocksX + bx];
-            if (meta.isProgressive) decodeBlockProgressive(comp, block);
-            else decodeBlockBaseline(comp, block);
+            if (meta.isProgressive) {
+              const off = (by * comp.blocksX + bx) * 64;
+              decodeBlockProgressive(comp, comp.blocksFlat.subarray(off, off + 64));
+            } else {
+              decodeAndStoreBaselineBlock(comp, bx, by, by % comp.v);
+            }
             mcuCounter++;
           }
         }
       } else {
+        const mcuRowH = maxV * blockStep;
         for (let my = 0; my < mcusY; my++) {
           for (let mx = 0; mx < mcusX; mx++) {
             if (restartInterval > 0 && mcuCounter > 0 && mcuCounter % restartInterval === 0) {
@@ -1599,14 +1843,87 @@ function decodeJpegImage(bytes) {
                 for (let hx = 0; hx < comp.h; hx++) {
                   const bx = mx * comp.h + hx;
                   const by = my * comp.v + vy;
-                  const block = comp.blocks[by * comp.blocksX + bx];
-                  if (meta.isProgressive) decodeBlockProgressive(comp, block);
-                  else decodeBlockBaseline(comp, block);
+                  if (meta.isProgressive) {
+                    const off = (by * comp.blocksX + bx) * 64;
+                    decodeBlockProgressive(comp, comp.blocksFlat.subarray(off, off + 64));
+                  } else {
+                    decodeAndStoreBaselineBlock(comp, bx, by, vy);
+                  }
                 }
               }
             }
             mcuCounter++;
           }
+          if (useStripDecode && outRgba) {
+            const yStart = my * mcuRowH;
+            const yEnd = Math.min(outHeight, yStart + mcuRowH);
+            const c0 = components[0];
+            const s0 = c0.blocksX * blockStep;
+            if (components.length === 1) {
+              const p0 = c0.stripPixels;
+              for (let y = yStart; y < yEnd; y++) {
+                const ly = y - yStart;
+                const rowIn = ly * s0;
+                let outIdx = y * outWidth * 4;
+                for (let x = 0; x < outWidth; x++) {
+                  const g = p0[rowIn + x];
+                  outRgba[outIdx] = g;
+                  outRgba[outIdx + 1] = g;
+                  outRgba[outIdx + 2] = g;
+                  outRgba[outIdx + 3] = 255;
+                  outIdx += 4;
+                }
+              }
+            } else if (components.length >= 3) {
+              const c1 = components[1];
+              const c2 = components[2];
+              const pY = c0.stripPixels;
+              const pCb = c1.stripPixels;
+              const pCr = c2.stripPixels;
+              const sY = s0;
+              const sCb = c1.blocksX * blockStep;
+              const sCr = c2.blocksX * blockStep;
+              const hY = c0.h, vY = c0.v;
+              const hCb = c1.h, vCb = c1.v;
+              const hCr = c2.h, vCr = c2.v;
+              const hasK = components.length === 4;
+              const c3 = hasK ? components[3] : void 0;
+              const pK = c3?.stripPixels;
+              const sK = c3 ? c3.blocksX * blockStep : 0;
+              for (let y = yStart; y < yEnd; y++) {
+                const ly = y - yStart;
+                const yRow = (vY === maxV ? ly : Math.floor(ly * vY / maxV)) * sY;
+                const cbRow = (vCb === maxV ? ly : Math.floor(ly * vCb / maxV)) * sCb;
+                const crRow = (vCr === maxV ? ly : Math.floor(ly * vCr / maxV)) * sCr;
+                const kRow = c3 ? (c3.v === maxV ? ly : Math.floor(ly * c3.v / maxV)) * sK : 0;
+                let outIdx = y * outWidth * 4;
+                for (let x = 0; x < outWidth; x++) {
+                  const yVal = pY[yRow + (hY === maxH ? x : Math.floor(x * hY / maxH))];
+                  const cbVal = pCb[cbRow + (hCb === maxH ? x : Math.floor(x * hCb / maxH))] - 128;
+                  const crVal = pCr[crRow + (hCr === maxH ? x : Math.floor(x * hCr / maxH))] - 128;
+                  let r = yVal + (91881 * crVal + 32768 >> 16);
+                  let g = yVal - (22554 * cbVal + 46802 * crVal + 32768 >> 16);
+                  let b = yVal + (116130 * cbVal + 32768 >> 16);
+                  r = r < 0 ? 0 : r > 255 ? 255 : r;
+                  g = g < 0 ? 0 : g > 255 ? 255 : g;
+                  b = b < 0 ? 0 : b > 255 ? 255 : b;
+                  if (hasK && pK && c3) {
+                    const kVal = pK[kRow + (c3.h === maxH ? x : Math.floor(x * c3.h / maxH))];
+                    outRgba[outIdx] = Math.round(r * kVal / 255);
+                    outRgba[outIdx + 1] = Math.round(g * kVal / 255);
+                    outRgba[outIdx + 2] = Math.round(b * kVal / 255);
+                    outRgba[outIdx + 3] = 255;
+                  } else {
+                    outRgba[outIdx] = r;
+                    outRgba[outIdx + 1] = g;
+                    outRgba[outIdx + 2] = b;
+                    outRgba[outIdx + 3] = 255;
+                  }
+                  outIdx += 4;
+                }
+              }
+            }
+          }
         }
       }
       pos = scanPos;
@@ -1614,14 +1931,34 @@ function decodeJpegImage(bytes) {
     }
     pos += segLen;
   }
+  if (useStripDecode && outRgba) {
+    return {
+      width: outWidth,
+      height: outHeight,
+      data: outRgba,
+      format: "jpeg",
+      space: meta.space,
+      channels: meta.channels,
+      depth: "uchar",
+      density: meta.density,
+      hasAlpha: false,
+      ...meta.orientation !== void 0 ? { orientation: meta.orientation } : {},
+      ...meta.isProgressive !== void 0 ? { isProgressive: meta.isProgressive } : {}
+    };
+  }
   const compPixels = components.map((comp) => {
+    if (!meta.isProgressive && comp.pixels) {
+      return { comp, pixels: comp.pixels, stride: comp.blocksX * blockStep };
+    }
     const pixels = new Uint8Array(comp.blocksX * 8 * comp.blocksY * 8);
     const blockOut = new Uint8Array(64);
     const quant = quantTables[comp.qId];
     if (!quant) throw new Error("Missing JPEG quantization table");
+    const blocksFlat = comp.blocksFlat;
     for (let by = 0; by < comp.blocksY; by++) {
       for (let bx = 0; bx < comp.blocksX; bx++) {
-        idct8x8(comp.blocks[by * comp.blocksX + bx], quant, blockOut);
+        const off = (by * comp.blocksX + bx) * 64;
+        idct8x8(blocksFlat.subarray(off, off + 64), quant, blockOut, 63);
         for (let y = 0; y < 8; y++) {
           const dstOffset = (by * 8 + y) * (comp.blocksX * 8) + bx * 8;
           for (let x = 0; x < 8; x++) {
@@ -1733,28 +2070,36 @@ var ENC_DC_LUMA = buildEncodeTable(STD_DC_LUMA_NRCODES, STD_DC_LUMA_VALUES);
 var ENC_DC_CHROMA = buildEncodeTable(STD_DC_CHROMA_NRCODES, STD_DC_CHROMA_VALUES);
 var ENC_AC_LUMA = buildEncodeTable(STD_AC_LUMA_NRCODES, STD_AC_LUMA_VALUES);
 var ENC_AC_CHROMA = buildEncodeTable(STD_AC_CHROMA_NRCODES, STD_AC_CHROMA_VALUES);
+var INV_ZIGZAG = (() => {
+  const inv = new Uint8Array(64);
+  for (let i = 0; i < 64; i++) {
+    inv[ZIGZAG[i]] = i;
+  }
+  return inv;
+})();
+var FDCT_TEMP = new Float64Array(64);
 function fdct8x8(block, quant, outZigZag) {
-  const temp = new Float64Array(64);
   for (let y = 0; y < 8; y++) {
+    const rowOff = y * 8;
     for (let u = 0; u < 8; u++) {
+      const cosOff = u * 8;
       let sum = 0;
       for (let x = 0; x < 8; x++) {
-        sum += block[y * 8 + x] * COS_TABLE[u * 8 + x];
+        sum += block[rowOff + x] * COS_TABLE[cosOff + x];
       }
-      temp[y * 8 + u] = sum * 0.5;
+      FDCT_TEMP[rowOff + u] = sum * 0.5;
     }
   }
   for (let v = 0; v < 8; v++) {
+    const cosOff = v * 8;
+    const vRow = v * 8;
     for (let u = 0; u < 8; u++) {
       let sum = 0;
       for (let y = 0; y < 8; y++) {
-        sum += temp[y * 8 + u] * COS_TABLE[v * 8 + y];
-      }
-      const coeff = sum * 0.5;
-      const zigIdx = ZIGZAG.indexOf(v * 8 + u);
-      if (zigIdx >= 0) {
-        outZigZag[zigIdx] = Math.round(coeff / (quant[zigIdx] ?? 1));
+        sum += FDCT_TEMP[y * 8 + u] * COS_TABLE[cosOff + y];
       }
+      const zigIdx = INV_ZIGZAG[vRow + u];
+      outZigZag[zigIdx] = Math.round(sum * 0.5 / (quant[zigIdx] ?? 1));
     }
   }
 }
@@ -1858,29 +2203,26 @@ function encodeJpegImage(img, options) {
   let bitBuf = 0;
   let bitCnt = 0;
   const writeBits = (code, len) => {
-    for (let i = len - 1; i >= 0; i--) {
-      bitBuf = bitBuf << 1 | code >>> i & 1;
-      bitCnt++;
-      if (bitCnt === 8) {
-        bytes.push(bitBuf);
-        if (bitBuf === 255) bytes.push(0);
-        bitBuf = 0;
-        bitCnt = 0;
-      }
+    bitBuf = bitBuf << len | code & (1 << len) - 1;
+    bitCnt += len;
+    while (bitCnt >= 8) {
+      bitCnt -= 8;
+      const b = bitBuf >>> bitCnt & 255;
+      bytes.push(b);
+      if (b === 255) bytes.push(0);
     }
   };
-  const encodeNumber = (val) => {
-    if (val === 0) return { category: 0, bits: 0 };
-    const abs = Math.abs(val);
-    const category = 32 - Math.clz32(abs);
-    const bits = val > 0 ? val : (1 << category) - 1 + val;
-    return { category, bits };
-  };
   const encodeBlock = (zz, prevDc, dcTab, acTab) => {
     const diff = zz[0] - prevDc;
-    const dcEnc = encodeNumber(diff);
-    writeBits(dcTab.code[dcEnc.category], dcTab.len[dcEnc.category]);
-    if (dcEnc.category > 0) writeBits(dcEnc.bits, dcEnc.category);
+    if (diff === 0) {
+      writeBits(dcTab.code[0], dcTab.len[0]);
+    } else {
+      const abs = diff < 0 ? -diff : diff;
+      const cat = 32 - Math.clz32(abs);
+      const bits = diff > 0 ? diff : (1 << cat) - 1 + diff;
+      writeBits(dcTab.code[cat], dcTab.len[cat]);
+      writeBits(bits, cat);
+    }
     let zeroRun = 0;
     for (let k = 1; k < 64; k++) {
       const v = zz[k];
@@ -1891,10 +2233,12 @@ function encodeJpegImage(img, options) {
           writeBits(acTab.code[240], acTab.len[240]);
           zeroRun -= 16;
         }
-        const acEnc = encodeNumber(v);
-        const sym = zeroRun << 4 | acEnc.category;
+        const abs = v < 0 ? -v : v;
+        const cat = 32 - Math.clz32(abs);
+        const bits = v > 0 ? v : (1 << cat) - 1 + v;
+        const sym = zeroRun << 4 | cat;
         writeBits(acTab.code[sym], acTab.len[sym]);
-        writeBits(acEnc.bits, acEnc.category);
+        writeBits(bits, cat);
         zeroRun = 0;
       }
     }
@@ -5130,14 +5474,12 @@ function decodeSvgImage(bytes, options) {
 }
 
 // packages/image-ast/src/codecs/index.ts
-var DEFAULT_PIXEL_LIMIT = Infinity;
 function checkLimitInputPixels(width, height, options) {
-  const limit = options?.limitInputPixels === false || options?.limitInputPixels === 0 || options?.unlimited === true && options?.limitInputPixels === void 0 ? Infinity : typeof options?.limitInputPixels === "number" ? options.limitInputPixels : DEFAULT_PIXEL_LIMIT;
+  const limit = options?.limitInputPixels === false || options?.limitInputPixels === 0 || options?.unlimited === true && options?.limitInputPixels === void 0 ? Infinity : typeof options?.limitInputPixels === "number" ? options.limitInputPixels : Infinity;
   if (width * height > limit) {
     throw new Error(`Input image exceeds pixel limit (${width}x${height} > ${limit})`);
   }
 }
-var DECODE_CACHE = /* @__PURE__ */ new WeakMap();
 function detectImageFormat(bytes) {
   if (isPngBytes(bytes)) return "png";
   if (isJpegBytes(bytes)) return "jpeg";
@@ -5577,14 +5919,6 @@ function decodeImage(bytes, options) {
   if (!bytes || bytes.length === 0) {
     throw new Error(!bytes ? "Input file is missing:" : "Input buffer contains unsupported image format");
   }
-  const canCache = options?.density === void 0 && options?.page === void 0 && options?.pages === void 0 && options?.animated === void 0 && options?.raw === void 0 && options?.create === void 0;
-  if (canCache) {
-    const cached = DECODE_CACHE.get(bytes);
-    if (cached) {
-      checkLimitInputPixels(cached.width, cached.height, options);
-      return cached;
-    }
-  }
   const meta = readImageMetadata(bytes, options);
   let decoded;
   switch (meta.format) {
@@ -5592,7 +5926,7 @@ function decodeImage(bytes, options) {
       decoded = decodePngImage(bytes);
       break;
     case "jpeg":
-      decoded = decodeJpegImage(bytes);
+      decoded = decodeJpegImage(bytes, options);
       break;
     case "webp":
       decoded = decodeWebpImage(bytes);
@@ -5625,9 +5959,6 @@ function decodeImage(bytes, options) {
     default:
       throw new Error(`Unsupported format: ${meta.format}`);
   }
-  if (canCache) {
-    DECODE_CACHE.set(bytes, decoded);
-  }
   return decoded;
 }
 function encodeImage(img, options) {
@@ -6244,19 +6575,22 @@ function* shrinkVBoxSteps(src, w, h, vshrink) {
   const out = new Uint8Array(w * outH * 4);
   const roundAdd = vshrink >> 1;
   for (let y = 0; y < outH; y++) {
-    if (++work % 16384 === 0) yield;
     for (let x = 0; x < w; x++) {
       if (++work % 16384 === 0) yield;
-      for (let c = 0; c < 4; c++) {
-        if (++work % 16384 === 0) yield;
-        let sum = 0;
-        for (let k = 0; k < vshrink; k++) {
-          if (++work % 16384 === 0) yield;
-          const sy = Math.min(h - 1, y * vshrink + k);
-          sum += src[(sy * w + x) * 4 + c];
-        }
-        out[(y * w + x) * 4 + c] = Math.floor((sum + roundAdd) / vshrink);
+      let sum0 = 0, sum1 = 0, sum2 = 0, sum3 = 0;
+      for (let k = 0; k < vshrink; k++) {
+        const sy = Math.min(h - 1, y * vshrink + k);
+        const sIdx = (sy * w + x) * 4;
+        sum0 += src[sIdx];
+        sum1 += src[sIdx + 1];
+        sum2 += src[sIdx + 2];
+        sum3 += src[sIdx + 3];
       }
+      const dIdx = (y * w + x) * 4;
+      out[dIdx] = Math.floor((sum0 + roundAdd) / vshrink);
+      out[dIdx + 1] = Math.floor((sum1 + roundAdd) / vshrink);
+      out[dIdx + 2] = Math.floor((sum2 + roundAdd) / vshrink);
+      out[dIdx + 3] = Math.floor((sum3 + roundAdd) / vshrink);
     }
   }
   return { data: out, h: outH };
@@ -6267,19 +6601,24 @@ function* shrinkHBoxSteps(src, w, h, hshrink) {
   const out = new Uint8Array(outW * h * 4);
   const roundAdd = hshrink >> 1;
   for (let y = 0; y < h; y++) {
-    if (++work % 16384 === 0) yield;
+    const rowOff = y * w * 4;
+    const dstRowOff = y * outW * 4;
     for (let x = 0; x < outW; x++) {
       if (++work % 16384 === 0) yield;
-      for (let c = 0; c < 4; c++) {
-        if (++work % 16384 === 0) yield;
-        let sum = 0;
-        for (let k = 0; k < hshrink; k++) {
-          if (++work % 16384 === 0) yield;
-          const sx = Math.min(w - 1, x * hshrink + k);
-          sum += src[(y * w + sx) * 4 + c];
-        }
-        out[(y * outW + x) * 4 + c] = Math.floor((sum + roundAdd) / hshrink);
-      }
+      let sum0 = 0, sum1 = 0, sum2 = 0, sum3 = 0;
+      for (let k = 0; k < hshrink; k++) {
+        const sx = Math.min(w - 1, x * hshrink + k);
+        const sIdx = rowOff + sx * 4;
+        sum0 += src[sIdx];
+        sum1 += src[sIdx + 1];
+        sum2 += src[sIdx + 2];
+        sum3 += src[sIdx + 3];
+      }
+      const dIdx = dstRowOff + x * 4;
+      out[dIdx] = Math.floor((sum0 + roundAdd) / hshrink);
+      out[dIdx + 1] = Math.floor((sum1 + roundAdd) / hshrink);
+      out[dIdx + 2] = Math.floor((sum2 + roundAdd) / hshrink);
+      out[dIdx + 3] = Math.floor((sum3 + roundAdd) / hshrink);
     }
   }
   return { data: out, w: outW };
@@ -6356,23 +6695,32 @@ function* resampleRawBitmapSteps(src, srcW, srcH, dstW, dstH, kernel = "lanczos3
         const voffset = (extraPixels + 1) * 0.5 - 1;
         const out = new Uint8Array(w * targetH * 4);
         let Y = fmaDouble(0.5, vshrink, -0.5) - voffset;
+        const rowOffsets = new Int32Array(nPoint);
         for (let y = 0; y < targetH; y++) {
-          if (++work % 16384 === 0) yield;
           const iy = Math.trunc(Y);
           const ty = (Math.trunc(Y * 128) & 127) + 1 >> 1;
           const wRow = ty * nPoint;
+          for (let j = 0; j < nPoint; j++) {
+            rowOffsets[j] = Math.max(0, Math.min(h - 1, iy + j - topPad)) * w * 4;
+          }
+          const dstRowOff = y * w * 4;
           for (let x = 0; x < w; x++) {
             if (++work % 16384 === 0) yield;
-            for (let c = 0; c < 4; c++) {
-              if (++work % 16384 === 0) yield;
-              let sum = 0;
-              for (let j = 0; j < nPoint; j++) {
-                if (++work % 16384 === 0) yield;
-                const sy = Math.max(0, Math.min(h - 1, iy + j - topPad));
-                sum += cur[(sy * w + x) * 4 + c] * table[wRow + j];
-              }
-              out[(y * w + x) * 4 + c] = Math.max(0, Math.min(255, sum + 2048 >> 12));
+            const xOff = x * 4;
+            let sum0 = 0, sum1 = 0, sum2 = 0, sum3 = 0;
+            for (let j = 0; j < nPoint; j++) {
+              const wt = table[wRow + j];
+              const sIdx = rowOffsets[j] + xOff;
+              sum0 += cur[sIdx] * wt;
+              sum1 += cur[sIdx + 1] * wt;
+              sum2 += cur[sIdx + 2] * wt;
+              sum3 += cur[sIdx + 3] * wt;
             }
+            const dIdx = dstRowOff + xOff;
+            out[dIdx] = Math.max(0, Math.min(255, sum0 + 2048 >> 12));
+            out[dIdx + 1] = Math.max(0, Math.min(255, sum1 + 2048 >> 12));
+            out[dIdx + 2] = Math.max(0, Math.min(255, sum2 + 2048 >> 12));
+            out[dIdx + 3] = Math.max(0, Math.min(255, sum3 + 2048 >> 12));
           }
           Y += vshrink;
         }
@@ -6398,24 +6746,33 @@ function* resampleRawBitmapSteps(src, srcW, srcH, dstW, dstH, kernel = "lanczos3
         const leftPad = Math.ceil(nPoint * 0.5) - 1;
         const hoffset = (extraPixels + 1) * 0.5 - 1;
         const out = new Uint8Array(targetW * h * 4);
+        const colOffsets = new Int32Array(nPoint);
         let X = fmaDouble(0.5, hshrink, -0.5) - hoffset;
         for (let x = 0; x < targetW; x++) {
-          if (++work % 16384 === 0) yield;
           const ix = Math.trunc(X);
           const tx = (Math.trunc(X * 128) & 127) + 1 >> 1;
           const wRow = tx * nPoint;
+          for (let j = 0; j < nPoint; j++) {
+            colOffsets[j] = Math.max(0, Math.min(w - 1, ix + j - leftPad)) * 4;
+          }
+          const dstColOff = x * 4;
           for (let y = 0; y < h; y++) {
             if (++work % 16384 === 0) yield;
-            for (let c = 0; c < 4; c++) {
-              if (++work % 16384 === 0) yield;
-              let sum = 0;
-              for (let j = 0; j < nPoint; j++) {
-                if (++work % 16384 === 0) yield;
-                const sx = Math.max(0, Math.min(w - 1, ix + j - leftPad));
-                sum += cur[(y * w + sx) * 4 + c] * table[wRow + j];
-              }
-              out[(y * targetW + x) * 4 + c] = Math.max(0, Math.min(255, sum + 2048 >> 12));
+            const srcRowOff = y * w * 4;
+            let sum0 = 0, sum1 = 0, sum2 = 0, sum3 = 0;
+            for (let j = 0; j < nPoint; j++) {
+              const wt = table[wRow + j];
+              const sIdx = srcRowOff + colOffsets[j];
+              sum0 += cur[sIdx] * wt;
+              sum1 += cur[sIdx + 1] * wt;
+              sum2 += cur[sIdx + 2] * wt;
+              sum3 += cur[sIdx + 3] * wt;
             }
+            const dIdx = y * targetW * 4 + dstColOff;
+            out[dIdx] = Math.max(0, Math.min(255, sum0 + 2048 >> 12));
+            out[dIdx + 1] = Math.max(0, Math.min(255, sum1 + 2048 >> 12));
+            out[dIdx + 2] = Math.max(0, Math.min(255, sum2 + 2048 >> 12));
+            out[dIdx + 3] = Math.max(0, Math.min(255, sum3 + 2048 >> 12));
           }
           X += hshrink;
         }
@@ -8373,35 +8730,35 @@ function buildVipsGaussmat(sigma, minAmpl = 0.1) {
   }
   return { radius: maxX, weights, scale };
 }
-function vipsSrgbToLabForSharpen(r, g, b) {
+var SHARPEN_LAB_OUT = new Float64Array(3);
+var SHARPEN_RGB_OUT = new Uint8Array(3);
+function vipsSrgbToLabForSharpenInto(r, g, b, out) {
   const rl = SRGB_TO_LINEAR_LUT[r];
   const gl = SRGB_TO_LINEAR_LUT[g];
   const bl = SRGB_TO_LINEAR_LUT[b];
   const X = (41.24 * rl + 35.76 * gl + 18.05 * bl) / 95.047;
   const Y = (21.26 * rl + 71.52 * gl + 7.22 * bl) / 100;
   const Z = (1.93 * rl + 11.92 * gl + 95.05 * bl) / 108.883;
-  const f = (t) => t > 8856e-6 ? Math.cbrt(t) : 7.787 * t + 16 / 116;
-  const fx = f(X);
-  const fy = f(Y);
-  const fz = f(Z);
-  return [
-    Math.fround(116 * fy - 16),
-    Math.fround(500 * (fx - fy)),
-    Math.fround(200 * (fy - fz))
-  ];
-}
-function vipsLabToSrgbForSharpen(L, a, b) {
+  const fx = X > 8856e-6 ? Math.cbrt(X) : 7.787 * X + 16 / 116;
+  const fy = Y > 8856e-6 ? Math.cbrt(Y) : 7.787 * Y + 16 / 116;
+  const fz = Z > 8856e-6 ? Math.cbrt(Z) : 7.787 * Z + 16 / 116;
+  out[0] = Math.fround(116 * fy - 16);
+  out[1] = Math.fround(500 * (fx - fy));
+  out[2] = Math.fround(200 * (fy - fz));
+}
+function vipsLabToSrgbForSharpenInto(L, a, b, out) {
   const fy = (L + 16) / 116;
   const fx = fy + a / 500;
   const fz = fy - b / 200;
-  const inv = (t) => t > 0.20689655172413793 ? t * t * t : (t - 16 / 116) / 7.787;
-  const X = inv(fx) * 0.95047;
-  const Y = inv(fy) * 1;
-  const Z = inv(fz) * 1.08883;
+  const X = (fx > 0.20689655172413793 ? fx * fx * fx : (fx - 16 / 116) / 7.787) * 0.95047;
+  const Y = (fy > 0.20689655172413793 ? fy * fy * fy : (fy - 16 / 116) / 7.787) * 1;
+  const Z = (fz > 0.20689655172413793 ? fz * fz * fz : (fz - 16 / 116) / 7.787) * 1.08883;
   const rl = 3.2406 * X - 1.5372 * Y - 0.4986 * Z;
   const gl = -0.9689 * X + 1.8758 * Y + 0.0415 * Z;
   const bl = 0.0557 * X - 0.204 * Y + 1.057 * Z;
-  return [linearToSrgbByte(rl), linearToSrgbByte(gl), linearToSrgbByte(bl)];
+  out[0] = linearToSrgbByte(rl);
+  out[1] = linearToSrgbByte(gl);
+  out[2] = linearToSrgbByte(bl);
 }
 function* sharpenImageSteps(img, sigma = 1, m1 = 1, m2 = 2, x1 = 2, y2 = 10, y3 = 20) {
   let work = 0;
@@ -8446,37 +8803,35 @@ function* sharpenImageSteps(img, sigma = 1, m1 = 1, m2 = 2, x1 = 2, y2 = 10, y3
   for (let i = 0; i < width * height; i++) {
     if (++work % 16384 === 0) yield;
     const idx = i * 4;
-    const [lVal, aVal, bVal] = vipsSrgbToLabForSharpen(cur[idx], cur[idx + 1], cur[idx + 2]);
-    Ls[i] = Math.trunc(lVal * 327.67);
-    As[i] = Math.trunc(aVal * 256);
-    Bs[i] = Math.trunc(bVal * 256);
+    vipsSrgbToLabForSharpenInto(cur[idx], cur[idx + 1], cur[idx + 2], SHARPEN_LAB_OUT);
+    Ls[i] = Math.trunc(SHARPEN_LAB_OUT[0] * 327.67);
+    As[i] = Math.trunc(SHARPEN_LAB_OUT[1] * 256);
+    Bs[i] = Math.trunc(SHARPEN_LAB_OUT[2] * 256);
   }
   const { radius, weights, scale } = buildVipsGaussmat(sigma, 0.1);
   const roundAdd = Math.trunc(scale) >> 1;
   const tmpL = new Int16Array(width * height);
   const blurL = new Int16Array(width * height);
   for (let y = 0; y < height; y++) {
-    if (++work % 16384 === 0) yield;
+    const rowOff = y * width;
     for (let x = 0; x < width; x++) {
       if (++work % 16384 === 0) yield;
       let sum = 0;
       for (let k = -radius; k <= radius; k++) {
-        if (++work % 16384 === 0) yield;
-        sum += Ls[y * width + Math.max(0, Math.min(width - 1, x + k))] * weights[k + radius];
+        sum += Ls[rowOff + Math.max(0, Math.min(width - 1, x + k))] * weights[k + radius];
       }
-      tmpL[y * width + x] = Math.floor((sum + roundAdd) / scale);
+      tmpL[rowOff + x] = Math.floor((sum + roundAdd) / scale);
     }
   }
   for (let y = 0; y < height; y++) {
-    if (++work % 16384 === 0) yield;
+    const rowOff = y * width;
     for (let x = 0; x < width; x++) {
       if (++work % 16384 === 0) yield;
       let sum = 0;
       for (let k = -radius; k <= radius; k++) {
-        if (++work % 16384 === 0) yield;
         sum += tmpL[Math.max(0, Math.min(height - 1, y + k)) * width + x] * weights[k + radius];
       }
-      blurL[y * width + x] = Math.floor((sum + roundAdd) / scale);
+      blurL[rowOff + x] = Math.floor((sum + roundAdd) / scale);
     }
   }
   const out = new Uint8Array(img.data.length);
@@ -8493,7 +8848,10 @@ function* sharpenImageSteps(img, sigma = 1, m1 = 1, m2 = 2, x1 = 2, y2 = 10, y3
     if (v > y2) v = y2;
     const boostS = rintEven2(v * 327.67);
     const newLS = Math.max(0, Math.min(32767, Ls[i] + boostS));
-    const [nr, ng, nb] = vipsLabToSrgbForSharpen(newLS / 327.67, As[i] / 256, Bs[i] / 256);
+    vipsLabToSrgbForSharpenInto(newLS / 327.67, As[i] / 256, Bs[i] / 256, SHARPEN_RGB_OUT);
+    const nr = SHARPEN_RGB_OUT[0];
+    const ng = SHARPEN_RGB_OUT[1];
+    const nb = SHARPEN_RGB_OUT[2];
     if (hasSemiTransparentAlpha && !alreadyPremultiplied) {
       const a = cur[idx + 3];
       const factor = a === 0 ? 0 : Math.fround(255 / a);
@@ -9479,6 +9837,2386 @@ function erodeImage(img, width = 1) {
   return next.value;
 }
 
+// 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/contracts";
+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(rgb) {
+    this.upsertNode({ kind: "tint", color: parseColor(rgb, 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 encoded = encodeImage(img, this.outputOptions);
+    const outBuf = outputBytes(encoded.data);
+    return {
+      data: outBuf,
+      info: {
+        format: encoded.format,
+        width: img.width,
+        height: img.height,
+        channels: encoded.channels,
+        ...encoded.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: encoded.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"
+  }
+});
+
 export {
   parseColor,
   decodeJpegImage,
@@ -9513,39 +12251,9 @@ export {
   computeImageStatsSteps,
   flipImage,
   flopImage,
-  applyExifOrientation,
   rotateImage,
   extractImage,
-  trimImage,
   extendImage,
-  compositeImage,
-  booleanImage,
   grayscaleImage,
-  flattenImage,
-  unflattenImage,
-  negateImage,
-  modulateImage,
-  tintImage,
-  gammaImage,
-  linearImage,
-  normalizeImage,
-  thresholdImage,
-  premultiplyRgbaImage,
-  unpremultiplyRgbaImage,
-  blurImage,
-  sharpenImage,
-  medianImage,
-  convolveImage,
-  ensureAlphaImage,
-  removeAlphaImage,
-  extractChannelImage,
-  recombImage,
-  toColorspaceImage,
-  bandboolImage,
-  joinChannelImage,
-  claheImage,
-  affineImage,
-  computeImageStats,
-  dilateImage,
-  erodeImage
+  negateImage
 };