@poe-platform/safe-bash 0.1.726 → 0.1.727

package/dist/safe-bash-command-sips/index.js

@@ -4159,6 +4159,10 @@ function decodeTiffImage(bytes) {
   let photometric = 2;
   let stripOffsets = [8];
   let stripByteCounts = [];
+  let tileWidth = 0;
+  let tileLength = 0;
+  let tileOffsets = [];
+  let tileByteCounts = [];
   let samplesPerPixel = 4;
   let rowsPerStrip = 0;
   let predictor = 1;
@@ -4183,42 +4187,77 @@ function decodeTiffImage(bytes) {
     else if (tag === 282 && first > 0) xRes = first;
     else if (tag === 296 && (first === 2 || first === 3)) resUnit = first;
     else if (tag === 317 && first > 0) predictor = first;
+    else if (tag === 322 && first > 0) tileWidth = first;
+    else if (tag === 323 && first > 0) tileLength = first;
+    else if (tag === 324 && vals.length > 0) tileOffsets = vals;
+    else if (tag === 325 && vals.length > 0) tileByteCounts = vals;
   }
   const bytesPerSample = Math.max(1, bitsPerSample >>> 3);
+  const bytesPerPixel = samplesPerPixel * bytesPerSample;
   const rowByteWidth = width * samplesPerPixel * bytesPerSample;
   const totalExpectedBytes = height * rowByteWidth;
   const combined = new Uint8Array(totalExpectedBytes);
-  const effectiveRowsPerStrip = rowsPerStrip > 0 ? rowsPerStrip : height;
-  let dstOff = 0;
-  for (let s = 0; s < stripOffsets.length && dstOff < totalExpectedBytes; s++) {
-    const off = stripOffsets[s];
-    const remainingBytes = totalExpectedBytes - dstOff;
-    const expectedStripBytes = Math.min(remainingBytes, effectiveRowsPerStrip * rowByteWidth);
-    const rawLen = stripByteCounts[s] ?? Math.max(0, bytes.length - off);
+  const decompressChunk = (off, rawLen, expectedBytes) => {
     const rawSlice = bytes.subarray(off, Math.min(bytes.length, off + rawLen));
-    let decodedStrip;
     if (compression === 8 || compression === 32946) {
       try {
-        decodedStrip = inflate3(rawSlice);
+        return inflate3(rawSlice);
       } catch {
-        decodedStrip = rawSlice;
+        return rawSlice;
       }
-    } else if (compression === 5) {
-      decodedStrip = decodeTiffLzw(rawSlice, expectedStripBytes);
-    } else if (compression === 32773) {
-      decodedStrip = decodePackBits(rawSlice, expectedStripBytes);
-    } else {
-      decodedStrip = rawSlice;
     }
-    const copyLen = Math.min(decodedStrip.length, remainingBytes);
-    combined.set(decodedStrip.subarray(0, copyLen), dstOff);
-    dstOff += copyLen;
-  }
-  if (predictor === 2 && bytesPerSample === 1) {
-    for (let y = 0; y < height; y++) {
-      const rowStart = y * rowByteWidth;
-      for (let x = samplesPerPixel; x < rowByteWidth; x++) {
-        combined[rowStart + x] = (combined[rowStart + x] ?? 0) + (combined[rowStart + x - samplesPerPixel] ?? 0) & 255;
+    if (compression === 5) return decodeTiffLzw(rawSlice, expectedBytes);
+    if (compression === 32773) return decodePackBits(rawSlice, expectedBytes);
+    return rawSlice;
+  };
+  if (tileWidth > 0 && tileLength > 0 && tileOffsets.length > 0) {
+    const tilesAcross = Math.max(1, Math.ceil(width / tileWidth));
+    const tileRowByteWidth = tileWidth * bytesPerPixel;
+    const expectedTileBytes = tileLength * tileRowByteWidth;
+    for (let t = 0; t < tileOffsets.length; t++) {
+      const off = tileOffsets[t];
+      const rawLen = tileByteCounts[t] ?? Math.max(0, bytes.length - off);
+      const decodedTile = new Uint8Array(decompressChunk(off, rawLen, expectedTileBytes));
+      if (predictor === 2 && bytesPerSample === 1) {
+        for (let ry = 0; ry < tileLength; ry++) {
+          const rStart = ry * tileRowByteWidth;
+          for (let rx = samplesPerPixel; rx < tileRowByteWidth && rStart + rx < decodedTile.length; rx++) {
+            decodedTile[rStart + rx] = (decodedTile[rStart + rx] ?? 0) + (decodedTile[rStart + rx - samplesPerPixel] ?? 0) & 255;
+          }
+        }
+      }
+      const tx = t % tilesAcross * tileWidth;
+      const ty = Math.floor(t / tilesAcross) * tileLength;
+      const validW = Math.max(0, Math.min(tileWidth, width - tx));
+      const validH = Math.max(0, Math.min(tileLength, height - ty));
+      const validRowBytes = validW * bytesPerPixel;
+      for (let ry = 0; ry < validH; ry++) {
+        const srcStart = ry * tileRowByteWidth;
+        const dstStart = (ty + ry) * rowByteWidth + tx * bytesPerPixel;
+        if (srcStart + validRowBytes <= decodedTile.length && dstStart + validRowBytes <= combined.length) {
+          combined.set(decodedTile.subarray(srcStart, srcStart + validRowBytes), dstStart);
+        }
+      }
+    }
+  } else {
+    const effectiveRowsPerStrip = rowsPerStrip > 0 ? rowsPerStrip : height;
+    let dstOff = 0;
+    for (let s = 0; s < stripOffsets.length && dstOff < totalExpectedBytes; s++) {
+      const off = stripOffsets[s];
+      const remainingBytes = totalExpectedBytes - dstOff;
+      const expectedStripBytes = Math.min(remainingBytes, effectiveRowsPerStrip * rowByteWidth);
+      const rawLen = stripByteCounts[s] ?? Math.max(0, bytes.length - off);
+      const decodedStrip = decompressChunk(off, rawLen, expectedStripBytes);
+      const copyLen = Math.min(decodedStrip.length, remainingBytes);
+      combined.set(decodedStrip.subarray(0, copyLen), dstOff);
+      dstOff += copyLen;
+    }
+    if (predictor === 2 && bytesPerSample === 1) {
+      for (let y = 0; y < height; y++) {
+        const rowStart = y * rowByteWidth;
+        for (let x = samplesPerPixel; x < rowByteWidth; x++) {
+          combined[rowStart + x] = (combined[rowStart + x] ?? 0) + (combined[rowStart + x - samplesPerPixel] ?? 0) & 255;
+        }
       }
     }
   }
@@ -4617,6 +4656,7 @@ function decodeSvgImage(bytes, options) {
 
 // packages/image-ast/src/codecs/index.ts
 var DEFAULT_PIXEL_LIMIT = 268402689;
+var DECODE_CACHE = /* @__PURE__ */ new WeakMap();
 function detectImageFormat(bytes) {
   if (isPngBytes(bytes)) return "png";
   if (isJpegBytes(bytes)) return "jpeg";
@@ -4752,14 +4792,25 @@ function decodeImage(bytes, options) {
     };
   }
   if (options?.raw && bytes) {
-    const { width, height, channels } = options.raw;
+    const { width, height, channels, premultiplied } = options.raw;
     const data = new Uint8Array(width * height * 4);
     for (let i = 0; i < width * height; i++) {
       if (channels === 4) {
-        data[i * 4] = bytes[i * 4] ?? 0;
-        data[i * 4 + 1] = bytes[i * 4 + 1] ?? 0;
-        data[i * 4 + 2] = bytes[i * 4 + 2] ?? 0;
-        data[i * 4 + 3] = bytes[i * 4 + 3] ?? 255;
+        const r = bytes[i * 4] ?? 0;
+        const g = bytes[i * 4 + 1] ?? 0;
+        const b = bytes[i * 4 + 2] ?? 0;
+        const a = bytes[i * 4 + 3] ?? 255;
+        if (premultiplied && a > 0 && a < 255) {
+          const scale = 255 / a;
+          data[i * 4] = Math.min(255, Math.round(r * scale));
+          data[i * 4 + 1] = Math.min(255, Math.round(g * scale));
+          data[i * 4 + 2] = Math.min(255, Math.round(b * scale));
+        } else {
+          data[i * 4] = r;
+          data[i * 4 + 1] = g;
+          data[i * 4 + 2] = b;
+        }
+        data[i * 4 + 3] = a;
       } else if (channels === 3) {
         data[i * 4] = bytes[i * 3] ?? 0;
         data[i * 4 + 1] = bytes[i * 3 + 1] ?? 0;
@@ -4794,35 +4845,55 @@ function decodeImage(bytes, options) {
   if (!bytes || bytes.length === 0) {
     throw new Error("Empty image input");
   }
+  const canCache = options?.density === void 0 && options?.page === void 0 && options?.pages === void 0 && options?.raw === void 0 && options?.create === void 0;
+  if (canCache) {
+    const cached = DECODE_CACHE.get(bytes);
+    if (cached) return cached;
+  }
   const meta = readImageMetadata(bytes, options);
+  let decoded;
   switch (meta.format) {
     case "png":
-      return decodePngImage(bytes);
+      decoded = decodePngImage(bytes);
+      break;
     case "jpeg":
-      return decodeJpegImage(bytes);
+      decoded = decodeJpegImage(bytes);
+      break;
     case "webp":
-      return decodeWebpImage(bytes);
+      decoded = decodeWebpImage(bytes);
+      break;
     case "heic":
     case "heif":
     case "avif":
-      return decodeHeifImage(bytes);
+      decoded = decodeHeifImage(bytes);
+      break;
     case "gif":
-      return decodeGifImage(bytes, options);
+      decoded = decodeGifImage(bytes, options);
+      break;
     case "ppm":
     case "pgm":
     case "pbm":
-      return decodeNetpbmImage(bytes);
+      decoded = decodeNetpbmImage(bytes);
+      break;
     case "bmp":
-      return decodeBmpImage(bytes);
+      decoded = decodeBmpImage(bytes);
+      break;
     case "tiff":
-      return decodeTiffImage(bytes);
+      decoded = decodeTiffImage(bytes);
+      break;
     case "pdf":
-      return decodePdfImage(bytes, options);
+      decoded = decodePdfImage(bytes, options);
+      break;
     case "svg":
-      return decodeSvgImage(bytes, options);
+      decoded = decodeSvgImage(bytes, options);
+      break;
     default:
       throw new Error(`Unsupported format: ${meta.format}`);
   }
+  if (canCache) {
+    DECODE_CACHE.set(bytes, decoded);
+  }
+  return decoded;
 }
 function encodeImage(img, options) {
   const fmt = options.format === "pdf" || options.format === "svg" ? "png" : options.format ?? (img.format === "pdf" || img.format === "svg" ? "png" : img.format);
@@ -5381,20 +5452,38 @@ function rotateImage(img, angle, background = { r: 0, g: 0, b: 0, a: 255 }) {
         const i10 = (y0 * img.width + (x0 + 1)) * 4;
         const i01 = ((y0 + 1) * img.width + x0) * 4;
         const i11 = ((y0 + 1) * img.width + (x0 + 1)) * 4;
-        for (let c = 0; c < 4; c++) {
-          const top = img.data[i00 + c] * (1 - fx) + img.data[i10 + c] * fx;
-          const bot = img.data[i01 + c] * (1 - fx) + img.data[i11 + c] * fx;
-          out[dIdx + c] = Math.round(top * (1 - fy) + bot * fy);
+        const w00 = (1 - fx) * (1 - fy);
+        const w10 = fx * (1 - fy);
+        const w01 = (1 - fx) * fy;
+        const w11 = fx * fy;
+        const a00 = img.data[i00 + 3] / 255;
+        const a10 = img.data[i10 + 3] / 255;
+        const a01 = img.data[i01 + 3] / 255;
+        const a11 = img.data[i11 + 3] / 255;
+        const outA = a00 * w00 + a10 * w10 + a01 * w01 + a11 * w11;
+        if (outA > 1e-6) {
+          for (let c = 0; c < 3; c++) {
+            const pm = img.data[i00 + c] * a00 * w00 + img.data[i10 + c] * a10 * w10 + img.data[i01 + c] * a01 * w01 + img.data[i11 + c] * a11 * w11;
+            out[dIdx + c] = Math.max(0, Math.min(255, Math.round(pm / outA)));
+          }
+          out[dIdx + 3] = Math.max(0, Math.min(255, Math.round(outA * 255)));
+        } else {
+          out[dIdx] = 0;
+          out[dIdx + 1] = 0;
+          out[dIdx + 2] = 0;
+          out[dIdx + 3] = 0;
         }
       }
     }
   }
+  const nextHasAlpha = img.hasAlpha || background.a < 255;
   return {
     ...img,
     width: dstW,
     height: dstH,
     data: out,
-    hasAlpha: img.hasAlpha || background.a < 255
+    hasAlpha: nextHasAlpha,
+    channels: nextHasAlpha ? img.channels < 3 ? 2 : 4 : img.channels
   };
 }
 function extractImage(img, region) {
@@ -5535,7 +5624,8 @@ function extendImage(img, spec) {
     width: dstW,
     height: dstH,
     data: out,
-    hasAlpha: img.hasAlpha || spec.background.a < 255
+    hasAlpha: img.hasAlpha || spec.background.a < 255,
+    channels: img.hasAlpha || spec.background.a < 255 ? img.channels < 3 ? 2 : 4 : img.channels
   };
 }
 function blendChannel(s, d, mode) {
@@ -5584,8 +5674,31 @@ function compositeImage(base, layers) {
     } else if (layer.input instanceof Uint8Array) {
       overlay = decodeImage(layer.input, {
         ...layer.density !== void 0 ? { density: layer.density } : {},
-        ...layer.raw !== void 0 ? { raw: layer.raw } : {}
+        ...layer.raw !== void 0 ? {
+          raw: {
+            ...layer.raw,
+            ...layer.premultiplied !== void 0 ? { premultiplied: layer.premultiplied } : {}
+          }
+        } : {}
       });
+      if (layer.premultiplied && !layer.raw) {
+        const unpremul = new Uint8Array(overlay.data.length);
+        for (let i = 0; i < overlay.width * overlay.height; i++) {
+          const a = overlay.data[i * 4 + 3];
+          if (a > 0 && a < 255) {
+            const scale = 255 / a;
+            unpremul[i * 4] = Math.min(255, Math.round(overlay.data[i * 4] * scale));
+            unpremul[i * 4 + 1] = Math.min(255, Math.round(overlay.data[i * 4 + 1] * scale));
+            unpremul[i * 4 + 2] = Math.min(255, Math.round(overlay.data[i * 4 + 2] * scale));
+          } else {
+            unpremul[i * 4] = overlay.data[i * 4];
+            unpremul[i * 4 + 1] = overlay.data[i * 4 + 1];
+            unpremul[i * 4 + 2] = overlay.data[i * 4 + 2];
+          }
+          unpremul[i * 4 + 3] = a;
+        }
+        overlay = { ...overlay, data: unpremul };
+      }
     } else {
       overlay = decodeImage(void 0, {
         create: layer.input.create,
@@ -5598,10 +5711,27 @@ function compositeImage(base, layers) {
       baseH,
       overlay.width,
       overlay.height,
-      layer.gravity ?? "northwest"
+      layer.gravity ?? "center"
     );
-    const startX = layer.left !== void 0 ? Math.round(layer.left) : grav.x;
-    const startY = layer.top !== void 0 ? Math.round(layer.top) : grav.y;
+    const startX = layer.left !== void 0 ? Math.round(layer.left) : layer.top !== void 0 ? 0 : grav.x;
+    const startY = layer.top !== void 0 ? Math.round(layer.top) : layer.left !== void 0 ? 0 : grav.y;
+    if (!layer.tile && !overlay.hasAlpha && (blend === "over" || blend === "source")) {
+      const copyStartX = Math.max(0, startX);
+      const copyEndX = Math.min(baseW, startX + overlay.width);
+      const copyW = copyEndX - copyStartX;
+      if (copyW > 0) {
+        const srcOffX = copyStartX - startX;
+        const copyStartY = Math.max(0, startY);
+        const copyEndY = Math.min(baseH, startY + overlay.height);
+        for (let dy = copyStartY; dy < copyEndY; dy++) {
+          const sy = dy - startY;
+          const sRowOff = (sy * overlay.width + srcOffX) * 4;
+          const dRowOff = (dy * baseW + copyStartX) * 4;
+          out.set(overlay.data.subarray(sRowOff, sRowOff + copyW * 4), dRowOff);
+        }
+      }
+      continue;
+    }
     const iterW = layer.tile ? baseW : overlay.width;
     const iterH = layer.tile ? baseH : overlay.height;
     for (let ty = 0; ty < 1; ty++) {
@@ -5609,11 +5739,11 @@ function compositeImage(base, layers) {
         for (let y = 0; y < iterH; y++) {
           const dy = layer.tile ? y : startY + y;
           if (dy < 0 || dy >= baseH) continue;
-          const sy = layer.tile ? dy % overlay.height : y;
+          const sy = layer.tile ? ((dy - startY) % overlay.height + overlay.height) % overlay.height : y;
           for (let x = 0; x < iterW; x++) {
             const dx = layer.tile ? x : startX + x;
             if (dx < 0 || dx >= baseW) continue;
-            const sx = layer.tile ? dx % overlay.width : x;
+            const sx = layer.tile ? ((dx - startX) % overlay.width + overlay.width) % overlay.width : x;
             const sIdx = (sy * overlay.width + sx) * 4;
             const dIdx = (dy * baseW + dx) * 4;
             const sr = overlay.data[sIdx] / 255;
@@ -5639,6 +5769,21 @@ function compositeImage(base, layers) {
               continue;
             }
             if (blend === "dest") continue;
+            if (blend === "over") {
+              const outA2 = sa + da * (1 - sa);
+              if (outA2 > 0) {
+                out[dIdx] = Math.max(0, Math.min(255, Math.round((sr * sa + dr * da * (1 - sa)) / outA2 * 255)));
+                out[dIdx + 1] = Math.max(0, Math.min(255, Math.round((sg * sa + dg * da * (1 - sa)) / outA2 * 255)));
+                out[dIdx + 2] = Math.max(0, Math.min(255, Math.round((sb * sa + db * da * (1 - sa)) / outA2 * 255)));
+                out[dIdx + 3] = Math.max(0, Math.min(255, Math.round(outA2 * 255)));
+              } else {
+                out[dIdx] = 0;
+                out[dIdx + 1] = 0;
+                out[dIdx + 2] = 0;
+                out[dIdx + 3] = 0;
+              }
+              continue;
+            }
             if (blend === "dest-over") {
               const outA2 = da + sa * (1 - da);
               if (outA2 > 0) {
@@ -5737,12 +5882,18 @@ function compositeImage(base, layers) {
               out[dIdx + 2] = 0;
               out[dIdx + 3] = 0;
             } else {
-              const br = blendChannel(sr, dr, blend);
-              const bg = blendChannel(sg, dg, blend);
-              const bb = blendChannel(sb, db, blend);
-              const cr = (sa * (1 - da) * sr + sa * da * br + (1 - sa) * da * dr) / outA;
-              const cg = (sa * (1 - da) * sg + sa * da * bg + (1 - sa) * da * dg) / outA;
-              const cb = (sa * (1 - da) * sb + sa * da * bb + (1 - sa) * da * db) / outA;
+              const srP = sr * sa;
+              const sgP = sg * sa;
+              const sbP = sb * sa;
+              const drP = dr * da;
+              const dgP = dg * da;
+              const dbP = db * da;
+              const br = blendChannel(srP, drP, blend);
+              const bg = blendChannel(sgP, dgP, blend);
+              const bb = blendChannel(sbP, dbP, blend);
+              const cr = ((1 - da) * srP + (1 - sa) * drP + sa * da * br) / outA;
+              const cg = ((1 - da) * sgP + (1 - sa) * dgP + sa * da * bg) / outA;
+              const cb = ((1 - da) * sbP + (1 - sa) * dbP + sa * da * bb) / outA;
               out[dIdx] = Math.max(0, Math.min(255, Math.round(cr * 255)));
               out[dIdx + 1] = Math.max(0, Math.min(255, Math.round(cg * 255)));
               out[dIdx + 2] = Math.max(0, Math.min(255, Math.round(cb * 255)));
@@ -5753,7 +5904,12 @@ function compositeImage(base, layers) {
       }
     }
   }
-  return { ...base, data: out };
+  return {
+    ...base,
+    data: out,
+    hasAlpha: true,
+    channels: base.channels < 3 ? 2 : 4
+  };
 }
 function grayscaleImage(img) {
   const out = new Uint8Array(img.data.length);
@@ -6018,10 +6174,11 @@ function blurImage(img, sigma = 1.5) {
         const sx = Math.max(0, Math.min(width - 1, x + k));
         const sIdx = (y * width + sx) * 4;
         const w = kernel[k + radius];
-        r += data[sIdx] * w;
-        g += data[sIdx + 1] * w;
-        b += data[sIdx + 2] * w;
-        a += data[sIdx + 3] * w;
+        const sa = data[sIdx + 3] / 255;
+        r += data[sIdx] * sa * w;
+        g += data[sIdx + 1] * sa * w;
+        b += data[sIdx + 2] * sa * w;
+        a += sa * w;
       }
       const dIdx = (y * width + x) * 4;
       temp[dIdx] = r;
@@ -6046,10 +6203,17 @@ function blurImage(img, sigma = 1.5) {
         a += temp[sIdx + 3] * w;
       }
       const dIdx = (y * width + x) * 4;
-      out[dIdx] = Math.max(0, Math.min(255, Math.round(r)));
-      out[dIdx + 1] = Math.max(0, Math.min(255, Math.round(g)));
-      out[dIdx + 2] = Math.max(0, Math.min(255, Math.round(b)));
-      out[dIdx + 3] = Math.max(0, Math.min(255, Math.round(a)));
+      if (a > 1e-6) {
+        out[dIdx] = Math.max(0, Math.min(255, Math.round(r / a)));
+        out[dIdx + 1] = Math.max(0, Math.min(255, Math.round(g / a)));
+        out[dIdx + 2] = Math.max(0, Math.min(255, Math.round(b / a)));
+        out[dIdx + 3] = Math.max(0, Math.min(255, Math.round(a * 255)));
+      } else {
+        out[dIdx] = 0;
+        out[dIdx + 1] = 0;
+        out[dIdx + 2] = 0;
+        out[dIdx + 3] = 0;
+      }
     }
   }
   return { ...img, data: out };