pixel-data-js 0.3.0 → 0.5.0

package/dist/index.dev.js

@@ -1,11 +1,5 @@
-// src/_types.ts
-var MaskType = /* @__PURE__ */ ((MaskType2) => {
-  MaskType2[MaskType2["ALPHA"] = 0] = "ALPHA";
-  MaskType2[MaskType2["BINARY"] = 1] = "BINARY";
-  return MaskType2;
-})(MaskType || {});
-
 // src/blend-modes.ts
+var overwriteColor32 = (src, dst) => src;
 var sourceOverColor32 = (src, dst) => {
   const a = src >>> 24 & 255;
   if (a === 255) return src;
@@ -22,6 +16,112 @@ var sourceOverColor32 = (src, dst) => {
   const outA = a + ((dst >>> 24 & 255) * invA >> 8);
   return (outA << 24 | outRB | outG) >>> 0;
 };
+var darkenColor32 = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 0) return dst;
+  const br = Math.min(src & 255, dst & 255);
+  const bg = Math.min(src >> 8 & 255, dst >> 8 & 255);
+  const bb = Math.min(src >> 16 & 255, dst >> 16 & 255);
+  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
+  const dr = dst & 255;
+  const dg = dst >> 8 & 255;
+  const db = dst >> 16 & 255;
+  const invA = 255 - sa;
+  const r = br * sa + dr * invA >> 8;
+  const g = bg * sa + dg * invA >> 8;
+  const b = bb * sa + db * invA >> 8;
+  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var multiplyColor32 = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 0) return dst;
+  const dr = dst & 255, dg = dst >> 8 & 255, db = dst >> 16 & 255;
+  const br = (src & 255) * dr + 128 >> 8;
+  const bg = (src >> 8 & 255) * dg >> 8;
+  const bb = (src >> 16 & 255) * db >> 8;
+  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
+  const invA = 255 - sa;
+  const r = br * sa + dr * invA >> 8;
+  const g = bg * sa + dg * invA >> 8;
+  const b = bb * sa + db * invA >> 8;
+  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var colorBurnColor32 = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 0) return dst;
+  const sr = src & 255, sg = src >> 8 & 255, sb = src >> 16 & 255;
+  const dr = dst & 255, dg = dst >> 8 & 255, db = dst >> 16 & 255;
+  const br = dr === 255 ? 255 : Math.max(0, 255 - (255 - dr << 8) / (sr || 1));
+  const bg = dg === 255 ? 255 : Math.max(0, 255 - (255 - dg << 8) / (sg || 1));
+  const bb = db === 255 ? 255 : Math.max(0, 255 - (255 - db << 8) / (sb || 1));
+  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
+  const invA = 255 - sa;
+  const r = br * sa + dr * invA >> 8;
+  const g = bg * sa + dg * invA >> 8;
+  const b = bb * sa + db * invA >> 8;
+  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var linearBurnColor32 = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 0) return dst;
+  const dr = dst & 255, dg = dst >> 8 & 255, db = dst >> 16 & 255;
+  const sr = src & 255, sg = src >> 8 & 255, sb = src >> 16 & 255;
+  const br = Math.max(0, dr + sr - 255);
+  const bg = Math.max(0, dg + sg - 255);
+  const bb = Math.max(0, db + sb - 255);
+  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
+  const invA = 255 - sa;
+  const r = br * sa + dr * invA >> 8;
+  const g = bg * sa + dg * invA >> 8;
+  const b = bb * sa + db * invA >> 8;
+  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var darkerColor32 = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 0) return dst;
+  const dr = dst & 255, dg = dst >> 8 & 255, db = dst >> 16 & 255;
+  const sr = src & 255, sg = src >> 8 & 255, sb = src >> 16 & 255;
+  const lumSrc = sr * 77 + sg * 151 + sb * 28;
+  const lumDst = dr * 77 + dg * 151 + db * 28;
+  let br, bg, bb;
+  if (lumSrc < lumDst) {
+    br = sr;
+    bg = sg;
+    bb = sb;
+  } else {
+    br = dr;
+    bg = dg;
+    bb = db;
+  }
+  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
+  const invA = 255 - sa;
+  const r = br * sa + dr * invA >> 8;
+  const g = bg * sa + dg * invA >> 8;
+  const b = bb * sa + db * invA >> 8;
+  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var lightenColor32 = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 0) return dst;
+  const br = Math.max(src & 255, dst & 255);
+  const bg = Math.max(src >> 8 & 255, dst >> 8 & 255);
+  const bb = Math.max(src >> 16 & 255, dst >> 16 & 255);
+  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
+  const dr = dst & 255;
+  const dg = dst >> 8 & 255;
+  const db = dst >> 16 & 255;
+  const invA = 255 - sa;
+  const r = br * sa + dr * invA >> 8;
+  const g = bg * sa + dg * invA >> 8;
+  const b = bb * sa + db * invA >> 8;
+  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
 var screenColor32 = (src, dst) => {
   const sa = src >>> 24 & 255;
   if (sa === 0) return dst;
@@ -37,6 +137,22 @@ var screenColor32 = (src, dst) => {
   const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
   return (a << 24 | b << 16 | g << 8 | r) >>> 0;
 };
+var colorDodgeColor32 = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 0) return dst;
+  const dr = dst & 255, dg = dst >> 8 & 255, db = dst >> 16 & 255;
+  const sr = src & 255, sg = src >> 8 & 255, sb = src >> 16 & 255;
+  const br = sr === 255 ? 255 : Math.min(255, (dr << 8) / (255 - sr));
+  const bg = sg === 255 ? 255 : Math.min(255, (dg << 8) / (255 - sg));
+  const bb = sb === 255 ? 255 : Math.min(255, (db << 8) / (255 - sb));
+  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
+  const invA = 255 - sa;
+  const r = br * sa + dr * invA >> 8;
+  const g = bg * sa + dg * invA >> 8;
+  const b = bb * sa + db * invA >> 8;
+  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
 var linearDodgeColor32 = (src, dst) => {
   const sa = src >>> 24 & 255;
   if (sa === 0) return dst;
@@ -52,13 +168,23 @@ var linearDodgeColor32 = (src, dst) => {
   const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
   return (a << 24 | b << 16 | g << 8 | r) >>> 0;
 };
-var multiplyColor32 = (src, dst) => {
+var lighterColor32 = (src, dst) => {
   const sa = src >>> 24 & 255;
   if (sa === 0) return dst;
   const dr = dst & 255, dg = dst >> 8 & 255, db = dst >> 16 & 255;
-  const br = (src & 255) * dr >> 8;
-  const bg = (src >> 8 & 255) * dg >> 8;
-  const bb = (src >> 16 & 255) * db >> 8;
+  const sr = src & 255, sg = src >> 8 & 255, sb = src >> 16 & 255;
+  const lumSrc = sr * 77 + sg * 151 + sb * 28;
+  const lumDst = dr * 77 + dg * 151 + db * 28;
+  let br, bg, bb;
+  if (lumSrc > lumDst) {
+    br = sr;
+    bg = sg;
+    bb = sb;
+  } else {
+    br = dr;
+    bg = dg;
+    bb = db;
+  }
   if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
   const invA = 255 - sa;
   const r = br * sa + dr * invA >> 8;
@@ -67,13 +193,14 @@ var multiplyColor32 = (src, dst) => {
   const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
   return (a << 24 | b << 16 | g << 8 | r) >>> 0;
 };
-var differenceColor32 = (src, dst) => {
+var overlayColor32 = (src, dst) => {
   const sa = src >>> 24 & 255;
   if (sa === 0) return dst;
+  const sr = src & 255, sg = src >> 8 & 255, sb = src >> 16 & 255;
   const dr = dst & 255, dg = dst >> 8 & 255, db = dst >> 16 & 255;
-  const br = Math.abs((src & 255) - dr);
-  const bg = Math.abs((src >> 8 & 255) - dg);
-  const bb = Math.abs((src >> 16 & 255) - db);
+  const br = dr < 128 ? 2 * sr * dr >> 8 : 255 - (2 * (255 - sr) * (255 - dr) >> 8);
+  const bg = dg < 128 ? 2 * sg * dg >> 8 : 255 - (2 * (255 - sg) * (255 - dg) >> 8);
+  const bb = db < 128 ? 2 * sb * db >> 8 : 255 - (2 * (255 - sb) * (255 - db) >> 8);
   if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
   const invA = 255 - sa;
   const r = br * sa + dr * invA >> 8;
@@ -82,11 +209,27 @@ var differenceColor32 = (src, dst) => {
   const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
   return (a << 24 | b << 16 | g << 8 | r) >>> 0;
 };
-var hardLightColor32 = (src, dst) => {
+var softLightColor32 = (src, dst) => {
   const sa = src >>> 24 & 255;
   if (sa === 0) return dst;
+  const dr = dst & 255, dg = dst >> 8 & 255, db = dst >> 16 & 255;
   const sr = src & 255, sg = src >> 8 & 255, sb = src >> 16 & 255;
+  const br = (255 - dr) * (sr * dr >> 8) + dr * (255 - ((255 - sr) * (255 - dr) >> 8)) >> 8;
+  const bg = (255 - dg) * (sg * dg >> 8) + dg * (255 - ((255 - sg) * (255 - dg) >> 8)) >> 8;
+  const bb = (255 - db) * (sb * db >> 8) + db * (255 - ((255 - sb) * (255 - db) >> 8)) >> 8;
+  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
+  const invA = 255 - sa;
+  const r = br * sa + dr * invA >> 8;
+  const g = bg * sa + dg * invA >> 8;
+  const b = bb * sa + db * invA >> 8;
+  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var hardLightColor32 = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 0) return dst;
   const dr = dst & 255, dg = dst >> 8 & 255, db = dst >> 16 & 255;
+  const sr = src & 255, sg = src >> 8 & 255, sb = src >> 16 & 255;
   const br = sr < 128 ? 2 * sr * dr >> 8 : 255 - (2 * (255 - sr) * (255 - dr) >> 8);
   const bg = sg < 128 ? 2 * sg * dg >> 8 : 255 - (2 * (255 - sg) * (255 - dg) >> 8);
   const bb = sb < 128 ? 2 * sb * db >> 8 : 255 - (2 * (255 - sb) * (255 - db) >> 8);
@@ -98,14 +241,46 @@ var hardLightColor32 = (src, dst) => {
   const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
   return (a << 24 | b << 16 | g << 8 | r) >>> 0;
 };
-var colorBurnColor32 = (src, dst) => {
+var vividLightColor32 = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 0) return dst;
+  const dr = dst & 255, dg = dst >> 8 & 255, db = dst >> 16 & 255;
+  const sr = src & 255, sg = src >> 8 & 255, sb = src >> 16 & 255;
+  const br = sr < 128 ? sr === 0 ? 0 : Math.max(0, 255 - (255 - dr << 8) / (2 * sr)) : sr === 255 ? 255 : Math.min(255, (dr << 8) / (2 * (255 - sr)));
+  const bg = sg < 128 ? sg === 0 ? 0 : Math.max(0, 255 - (255 - dg << 8) / (2 * sg)) : sg === 255 ? 255 : Math.min(255, (dg << 8) / (2 * (255 - sg)));
+  const bb = sb < 128 ? sb === 0 ? 0 : Math.max(0, 255 - (255 - db << 8) / (2 * sb)) : sb === 255 ? 255 : Math.min(255, (db << 8) / (2 * (255 - sb)));
+  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
+  const invA = 255 - sa;
+  const r = br * sa + dr * invA >> 8;
+  const g = bg * sa + dg * invA >> 8;
+  const b = bb * sa + db * invA >> 8;
+  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var linearLightColor32 = (src, dst) => {
   const sa = src >>> 24 & 255;
   if (sa === 0) return dst;
+  const dr = dst & 255, dg = dst >> 8 & 255, db = dst >> 16 & 255;
   const sr = src & 255, sg = src >> 8 & 255, sb = src >> 16 & 255;
+  const br = Math.max(0, Math.min(255, dr + 2 * sr - 255));
+  const bg = Math.max(0, Math.min(255, dg + 2 * sg - 255));
+  const bb = Math.max(0, Math.min(255, db + 2 * sb - 255));
+  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
+  const invA = 255 - sa;
+  const r = br * sa + dr * invA >> 8;
+  const g = bg * sa + dg * invA >> 8;
+  const b = bb * sa + db * invA >> 8;
+  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var pinLightColor32 = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 0) return dst;
   const dr = dst & 255, dg = dst >> 8 & 255, db = dst >> 16 & 255;
-  const br = dr === 255 ? 255 : Math.max(0, 255 - (255 - dr << 8) / (sr || 1));
-  const bg = dg === 255 ? 255 : Math.max(0, 255 - (255 - dg << 8) / (sg || 1));
-  const bb = db === 255 ? 255 : Math.max(0, 255 - (255 - db << 8) / (sb || 1));
+  const sr = src & 255, sg = src >> 8 & 255, sb = src >> 16 & 255;
+  const br = sr < 128 ? Math.min(dr, 2 * sr) : Math.max(dr, 2 * (sr - 128));
+  const bg = sg < 128 ? Math.min(dg, 2 * sg) : Math.max(dg, 2 * (sg - 128));
+  const bb = sb < 128 ? Math.min(db, 2 * sb) : Math.max(db, 2 * (sb - 128));
   if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
   const invA = 255 - sa;
   const r = br * sa + dr * invA >> 8;
@@ -114,14 +289,61 @@ var colorBurnColor32 = (src, dst) => {
   const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
   return (a << 24 | b << 16 | g << 8 | r) >>> 0;
 };
-var overlayColor32 = (src, dst) => {
+var hardMixColor32 = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 0) return dst;
+  const dr = dst & 255, dg = dst >> 8 & 255, db = dst >> 16 & 255;
+  const sr = src & 255, sg = src >> 8 & 255, sb = src >> 16 & 255;
+  const br = (sr < 128 ? sr === 0 ? 0 : Math.max(0, 255 - (255 - dr << 8) / (2 * sr)) : sr === 255 ? 255 : Math.min(255, (dr << 8) / (2 * (255 - sr)))) < 128 ? 0 : 255;
+  const bg = (sg < 128 ? sg === 0 ? 0 : Math.max(0, 255 - (255 - dg << 8) / (2 * sg)) : sg === 255 ? 255 : Math.min(255, (dg << 8) / (2 * (255 - sg)))) < 128 ? 0 : 255;
+  const bb = (sb < 128 ? sb === 0 ? 0 : Math.max(0, 255 - (255 - db << 8) / (2 * sb)) : sb === 255 ? 255 : Math.min(255, (db << 8) / (2 * (255 - sb)))) < 128 ? 0 : 255;
+  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
+  const invA = 255 - sa;
+  const r = br * sa + dr * invA >> 8;
+  const g = bg * sa + dg * invA >> 8;
+  const b = bb * sa + db * invA >> 8;
+  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var differenceColor32 = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 0) return dst;
+  const dr = dst & 255, dg = dst >> 8 & 255, db = dst >> 16 & 255;
+  const br = Math.abs((src & 255) - dr);
+  const bg = Math.abs((src >> 8 & 255) - dg);
+  const bb = Math.abs((src >> 16 & 255) - db);
+  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
+  const invA = 255 - sa;
+  const r = br * sa + dr * invA >> 8;
+  const g = bg * sa + dg * invA >> 8;
+  const b = bb * sa + db * invA >> 8;
+  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var exclusionColor32 = (src, dst) => {
   const sa = src >>> 24 & 255;
   if (sa === 0) return dst;
+  const dr = dst & 255, dg = dst >> 8 & 255, db = dst >> 16 & 255;
   const sr = src & 255, sg = src >> 8 & 255, sb = src >> 16 & 255;
+  const br = dr + sr - (dr * sr >> 7);
+  const bg = dg + sg - (dg * sg >> 7);
+  const bb = db + sb - (db * sb >> 7);
+  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
+  const invA = 255 - sa;
+  const r = br * sa + dr * invA >> 8;
+  const g = bg * sa + dg * invA >> 8;
+  const b = bb * sa + db * invA >> 8;
+  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
+};
+var subtractColor32 = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 0) return dst;
   const dr = dst & 255, dg = dst >> 8 & 255, db = dst >> 16 & 255;
-  const br = dr < 128 ? 2 * sr * dr >> 8 : 255 - (2 * (255 - sr) * (255 - dr) >> 8);
-  const bg = dg < 128 ? 2 * sg * dg >> 8 : 255 - (2 * (255 - sg) * (255 - dg) >> 8);
-  const bb = db < 128 ? 2 * sb * db >> 8 : 255 - (2 * (255 - sb) * (255 - db) >> 8);
+  const sr = src & 255, sg = src >> 8 & 255, sb = src >> 16 & 255;
+  const br = Math.max(0, dr - sr);
+  const bg = Math.max(0, dg - sg);
+  const bb = Math.max(0, db - sb);
   if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
   const invA = 255 - sa;
   const r = br * sa + dr * invA >> 8;
@@ -130,16 +352,100 @@ var overlayColor32 = (src, dst) => {
   const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
   return (a << 24 | b << 16 | g << 8 | r) >>> 0;
 };
-var COLOR_32_BLEND_MODES = {
-  sourceOver: sourceOverColor32,
-  screen: screenColor32,
-  linearDodge: linearDodgeColor32,
-  multiply: multiplyColor32,
-  difference: differenceColor32,
-  overlay: overlayColor32,
-  hardLight: hardLightColor32,
-  colorBurn: colorBurnColor32
+var divideColor32 = (src, dst) => {
+  const sa = src >>> 24 & 255;
+  if (sa === 0) return dst;
+  const dr = dst & 255, dg = dst >> 8 & 255, db = dst >> 16 & 255;
+  const sr = src & 255, sg = src >> 8 & 255, sb = src >> 16 & 255;
+  const br = sr === 0 ? 255 : Math.min(255, (dr << 8) / sr);
+  const bg = sg === 0 ? 255 : Math.min(255, (dg << 8) / sg);
+  const bb = sb === 0 ? 255 : Math.min(255, (db << 8) / sb);
+  if (sa === 255) return (4278190080 | bb << 16 | bg << 8 | br) >>> 0;
+  const invA = 255 - sa;
+  const r = br * sa + dr * invA >> 8;
+  const g = bg * sa + dg * invA >> 8;
+  const b = bb * sa + db * invA >> 8;
+  const a = 255 * sa + (dst >>> 24 & 255) * invA >> 8;
+  return (a << 24 | b << 16 | g << 8 | r) >>> 0;
 };
+var BlendMode = /* @__PURE__ */ ((BlendMode2) => {
+  BlendMode2[BlendMode2["overwrite"] = 0] = "overwrite";
+  BlendMode2[BlendMode2["sourceOver"] = 1] = "sourceOver";
+  BlendMode2[BlendMode2["darken"] = 2] = "darken";
+  BlendMode2[BlendMode2["multiply"] = 3] = "multiply";
+  BlendMode2[BlendMode2["colorBurn"] = 4] = "colorBurn";
+  BlendMode2[BlendMode2["linearBurn"] = 5] = "linearBurn";
+  BlendMode2[BlendMode2["darkerColor"] = 6] = "darkerColor";
+  BlendMode2[BlendMode2["lighten"] = 7] = "lighten";
+  BlendMode2[BlendMode2["screen"] = 8] = "screen";
+  BlendMode2[BlendMode2["colorDodge"] = 9] = "colorDodge";
+  BlendMode2[BlendMode2["linearDodge"] = 10] = "linearDodge";
+  BlendMode2[BlendMode2["lighterColor"] = 11] = "lighterColor";
+  BlendMode2[BlendMode2["overlay"] = 12] = "overlay";
+  BlendMode2[BlendMode2["softLight"] = 13] = "softLight";
+  BlendMode2[BlendMode2["hardLight"] = 14] = "hardLight";
+  BlendMode2[BlendMode2["vividLight"] = 15] = "vividLight";
+  BlendMode2[BlendMode2["linearLight"] = 16] = "linearLight";
+  BlendMode2[BlendMode2["pinLight"] = 17] = "pinLight";
+  BlendMode2[BlendMode2["hardMix"] = 18] = "hardMix";
+  BlendMode2[BlendMode2["difference"] = 19] = "difference";
+  BlendMode2[BlendMode2["exclusion"] = 20] = "exclusion";
+  BlendMode2[BlendMode2["subtract"] = 21] = "subtract";
+  BlendMode2[BlendMode2["divide"] = 22] = "divide";
+  return BlendMode2;
+})(BlendMode || {});
+var BLENDER_REGISTRY = [
+  [0 /* overwrite */, overwriteColor32],
+  [1 /* sourceOver */, sourceOverColor32],
+  [2 /* darken */, darkenColor32],
+  [3 /* multiply */, multiplyColor32],
+  [4 /* colorBurn */, colorBurnColor32],
+  [5 /* linearBurn */, linearBurnColor32],
+  [6 /* darkerColor */, darkerColor32],
+  [7 /* lighten */, lightenColor32],
+  [8 /* screen */, screenColor32],
+  [9 /* colorDodge */, colorDodgeColor32],
+  [10 /* linearDodge */, linearDodgeColor32],
+  [11 /* lighterColor */, lighterColor32],
+  [12 /* overlay */, overlayColor32],
+  [13 /* softLight */, softLightColor32],
+  [14 /* hardLight */, hardLightColor32],
+  [15 /* vividLight */, vividLightColor32],
+  [16 /* linearLight */, linearLightColor32],
+  [17 /* pinLight */, pinLightColor32],
+  [18 /* hardMix */, hardMixColor32],
+  [19 /* difference */, differenceColor32],
+  [20 /* exclusion */, exclusionColor32],
+  [21 /* subtract */, subtractColor32],
+  [22 /* divide */, divideColor32]
+];
+var COLOR_32_BLEND_MODES = [];
+for (const [index, blend] of BLENDER_REGISTRY) {
+  COLOR_32_BLEND_MODES[index] = blend;
+}
+var COLOR_32_BLEND_TO_INDEX = new Map(
+  BLENDER_REGISTRY.map((entry, index) => {
+    return [
+      entry[1],
+      index
+    ];
+  })
+);
+var INDEX_TO_COLOR_32_BLEND = new Map(
+  BLENDER_REGISTRY.map((entry, index) => {
+    return [
+      index,
+      entry[1]
+    ];
+  })
+);
+
+// src/_types.ts
+var MaskType = /* @__PURE__ */ ((MaskType2) => {
+  MaskType2[MaskType2["ALPHA"] = 0] = "ALPHA";
+  MaskType2[MaskType2["BINARY"] = 1] = "BINARY";
+  return MaskType2;
+})(MaskType || {});
 
 // src/color.ts
 function packColor(r, g, b, a) {
@@ -204,20 +510,8 @@ function color32ToCssRGBA(color) {
   return `rgba(${r},${g},${b},${alpha})`;
 }
 
-// src/ImageData/copyImageData.ts
-function copyImageData({ data, width, height }) {
-  return new ImageData(data.slice(), width, height);
-}
-function copyImageDataLike({ data, width, height }) {
-  return {
-    data: data.slice(),
-    width,
-    height
-  };
-}
-
-// src/ImageData/extractImageData.ts
-function extractImageData(imageData, _x, _y, _w, _h) {
+// src/ImageData/extractImageDataPixels.ts
+function extractImageDataPixels(imageData, _x, _y, _w, _h) {
   const { x, y, w, h } = typeof _x === "object" ? _x : { x: _x, y: _y, w: _w, h: _h };
   const { width: srcW, height: srcH, data: src } = imageData;
   if (w <= 0 || h <= 0) return new Uint8ClampedArray(0);
@@ -239,28 +533,509 @@ function extractImageData(imageData, _x, _y, _w, _h) {
   return out;
 }
 
-// src/ImageData/serialization.ts
-function base64EncodeArrayBuffer(buffer) {
-  const binary = String.fromCharCode(...new Uint8Array(buffer));
-  return btoa(binary);
-}
-function base64DecodeArrayBuffer(encoded) {
-  const binary = atob(encoded);
-  const bytes = new Uint8ClampedArray(binary.length);
-  for (let i = 0; i < binary.length; i++) {
-    bytes[i] = binary.charCodeAt(i);
+// src/Mask/extractMask.ts
+function extractMask(mask, maskWidth, xOrRect, y, w, h) {
+  let finalX;
+  let finalY;
+  let finalW;
+  let finalH;
+  if (typeof xOrRect === "object") {
+    finalX = xOrRect.x;
+    finalY = xOrRect.y;
+    finalW = xOrRect.w;
+    finalH = xOrRect.h;
+  } else {
+    finalX = xOrRect;
+    finalY = y;
+    finalW = w;
+    finalH = h;
   }
-  return bytes;
+  const out = new Uint8Array(finalW * finalH);
+  const srcH = mask.length / maskWidth;
+  for (let row = 0; row < finalH; row++) {
+    const currentSrcY = finalY + row;
+    if (currentSrcY < 0 || currentSrcY >= srcH) {
+      continue;
+    }
+    const start = Math.max(0, finalX);
+    const end = Math.min(maskWidth, finalX + finalW);
+    if (start < end) {
+      const srcOffset = currentSrcY * maskWidth + start;
+      const dstOffset = row * finalW + (start - finalX);
+      const count = end - start;
+      out.set(
+        mask.subarray(srcOffset, srcOffset + count),
+        dstOffset
+      );
+    }
+  }
+  return out;
 }
-function serializeImageData(imageData) {
-  return {
-    width: imageData.width,
-    height: imageData.height,
-    data: base64EncodeArrayBuffer(imageData.data.buffer)
-  };
+
+// src/Rect/trimRectBounds.ts
+function trimRectBounds(target, bounds) {
+  const originalX = target.x;
+  const originalY = target.y;
+  const originalW = target.w;
+  const intersectedX = Math.max(target.x, bounds.x);
+  const intersectedY = Math.max(target.y, bounds.y);
+  const intersectedMaxX = Math.min(
+    target.x + target.w,
+    bounds.x + bounds.w
+  );
+  const intersectedMaxY = Math.min(
+    target.y + target.h,
+    bounds.y + bounds.h
+  );
+  if (intersectedMaxX <= intersectedX || intersectedMaxY <= intersectedY) {
+    target.w = 0;
+    target.h = 0;
+    if ("mask" in target && target.mask) {
+      target.mask = new Uint8Array(0);
+    }
+    return;
+  }
+  const intersectedW = intersectedMaxX - intersectedX;
+  const intersectedH = intersectedMaxY - intersectedY;
+  const offsetX = intersectedX - originalX;
+  const offsetY = intersectedY - originalY;
+  target.x = intersectedX;
+  target.y = intersectedY;
+  target.w = intersectedW;
+  target.h = intersectedH;
+  if ("mask" in target && target.mask) {
+    const currentMask = extractMask(
+      target.mask,
+      originalW,
+      offsetX,
+      offsetY,
+      intersectedW,
+      intersectedH
+    );
+    let minX = intersectedW;
+    let maxX = -1;
+    let minY = intersectedH;
+    let maxY = -1;
+    for (let y = 0; y < intersectedH; y++) {
+      for (let x = 0; x < intersectedW; x++) {
+        if (currentMask[y * intersectedW + x] !== 0) {
+          if (x < minX) minX = x;
+          if (x > maxX) maxX = x;
+          if (y < minY) minY = y;
+          if (y > maxY) maxY = y;
+        }
+      }
+    }
+    if (maxX === -1) {
+      target.w = 0;
+      target.h = 0;
+      target.mask = new Uint8Array(0);
+      return;
+    }
+    const finalW = maxX - minX + 1;
+    const finalH = maxY - minY + 1;
+    if (finalW !== intersectedW || finalH !== intersectedH) {
+      target.mask = extractMask(
+        currentMask,
+        intersectedW,
+        minX,
+        minY,
+        finalW,
+        finalH
+      );
+      target.x += minX;
+      target.y += minY;
+      target.w = finalW;
+      target.h = finalH;
+    } else {
+      target.mask = currentMask;
+    }
+  }
 }
-function serializeNullableImageData(imageData) {
-  if (!imageData) return null;
+
+// src/Algorithm/floodFillSelection.ts
+function floodFillSelection(img, startX, startY, {
+  contiguous = true,
+  tolerance = 0,
+  bounds
+} = {}) {
+  let imageData;
+  let data32;
+  if ("data32" in img) {
+    data32 = img.data32;
+    imageData = img.imageData;
+  } else {
+    data32 = new Uint32Array(
+      img.data.buffer,
+      img.data.byteOffset,
+      img.data.byteLength >> 2
+    );
+    imageData = img;
+  }
+  const {
+    width,
+    height
+  } = img;
+  const limit = bounds || {
+    x: 0,
+    y: 0,
+    w: width,
+    h: height
+  };
+  const xMin = Math.max(0, limit.x);
+  const xMax = Math.min(width - 1, limit.x + limit.w - 1);
+  const yMin = Math.max(0, limit.y);
+  const yMax = Math.min(height - 1, limit.y + limit.h - 1);
+  if (startX < xMin || startX > xMax || startY < yMin || startY > yMax) {
+    return null;
+  }
+  const baseColor = data32[startY * width + startX];
+  let matchCount = 0;
+  const matchX = new Uint16Array(width * height);
+  const matchY = new Uint16Array(width * height);
+  let minX = startX;
+  let maxX = startX;
+  let minY = startY;
+  let maxY = startY;
+  if (contiguous) {
+    const visited = new Uint8Array(width * height);
+    const stack = new Uint32Array(width * height);
+    let stackPtr = 0;
+    stack[stackPtr++] = startY << 16 | startX;
+    visited[startY * width + startX] = 1;
+    while (stackPtr > 0) {
+      const val = stack[--stackPtr];
+      const x = val & 65535;
+      const y = val >>> 16;
+      matchX[matchCount] = x;
+      matchY[matchCount] = y;
+      matchCount++;
+      if (x < minX) minX = x;
+      if (x > maxX) maxX = x;
+      if (y < minY) minY = y;
+      if (y > maxY) maxY = y;
+      if (x + 1 <= xMax) {
+        const idx = y * width + (x + 1);
+        if (!visited[idx] && colorDistance(data32[idx], baseColor) <= tolerance) {
+          visited[idx] = 1;
+          stack[stackPtr++] = y << 16 | x + 1;
+        }
+      }
+      if (x - 1 >= xMin) {
+        const idx = y * width + (x - 1);
+        if (!visited[idx] && colorDistance(data32[idx], baseColor) <= tolerance) {
+          visited[idx] = 1;
+          stack[stackPtr++] = y << 16 | x - 1;
+        }
+      }
+      if (y + 1 <= yMax) {
+        const idx = (y + 1) * width + x;
+        if (!visited[idx] && colorDistance(data32[idx], baseColor) <= tolerance) {
+          visited[idx] = 1;
+          stack[stackPtr++] = y + 1 << 16 | x;
+        }
+      }
+      if (y - 1 >= yMin) {
+        const idx = (y - 1) * width + x;
+        if (!visited[idx] && colorDistance(data32[idx], baseColor) <= tolerance) {
+          visited[idx] = 1;
+          stack[stackPtr++] = y - 1 << 16 | x;
+        }
+      }
+    }
+  } else {
+    for (let y = yMin; y <= yMax; y++) {
+      for (let x = xMin; x <= xMax; x++) {
+        const color = data32[y * width + x];
+        if (colorDistance(color, baseColor) <= tolerance) {
+          matchX[matchCount] = x;
+          matchY[matchCount] = y;
+          matchCount++;
+          if (x < minX) minX = x;
+          if (x > maxX) maxX = x;
+          if (y < minY) minY = y;
+          if (y > maxY) maxY = y;
+        }
+      }
+    }
+  }
+  if (matchCount === 0) {
+    return null;
+  }
+  const selectionRect = {
+    x: minX,
+    y: minY,
+    w: maxX - minX + 1,
+    h: maxY - minY + 1,
+    mask: new Uint8Array((maxX - minX + 1) * (maxY - minY + 1)),
+    maskType: 1 /* BINARY */
+  };
+  const sw = selectionRect.w;
+  const sh = selectionRect.h;
+  const finalMask = selectionRect.mask;
+  for (let i = 0; i < matchCount; i++) {
+    const mx = matchX[i] - selectionRect.x;
+    const my = matchY[i] - selectionRect.y;
+    if (mx >= 0 && mx < sw && my >= 0 && my < sh) {
+      finalMask[my * sw + mx] = 1;
+    }
+  }
+  trimRectBounds(
+    selectionRect,
+    { x: 0, y: 0, w: width, h: height }
+  );
+  const extracted = extractImageDataPixels(
+    imageData,
+    selectionRect.x,
+    selectionRect.y,
+    selectionRect.w,
+    selectionRect.h
+  );
+  return {
+    startX,
+    startY,
+    selectionRect,
+    pixels: extracted
+  };
+}
+
+// src/Canvas/_constants.ts
+var OFFSCREEN_CANVAS_CTX_FAILED = "Failed to create OffscreenCanvas context";
+var CANVAS_CTX_FAILED = "Failed to create Canvas context";
+
+// src/Canvas/PixelCanvas.ts
+function makePixelCanvas(canvas) {
+  const ctx = canvas.getContext("2d");
+  if (!ctx) throw new Error(CANVAS_CTX_FAILED);
+  ctx.imageSmoothingEnabled = false;
+  return {
+    canvas,
+    ctx,
+    resize(w, h) {
+      canvas.width = w;
+      canvas.height = h;
+      ctx.imageSmoothingEnabled = false;
+    }
+  };
+}
+
+// src/Canvas/ReusableCanvas.ts
+function makeReusableCanvas() {
+  let canvas = null;
+  let ctx = null;
+  function get2(width, height) {
+    if (canvas === null) {
+      canvas = document.createElement("canvas");
+      ctx = canvas.getContext("2d");
+      if (!ctx) throw new Error(CANVAS_CTX_FAILED);
+    }
+    if (canvas.width !== width || canvas.height !== height) {
+      canvas.width = width;
+      canvas.height = height;
+      ctx.imageSmoothingEnabled = false;
+    } else {
+      ctx.clearRect(0, 0, width, height);
+    }
+    return { canvas, ctx };
+  }
+  get2.reset = () => {
+    canvas = null;
+    ctx = null;
+  };
+  return get2;
+}
+
+// src/ImageData/imgBlobToImageData.ts
+async function imgBlobToImageData(blob) {
+  let bitmap = null;
+  try {
+    bitmap = await createImageBitmap(blob);
+    const canvas = new OffscreenCanvas(
+      bitmap.width,
+      bitmap.height
+    );
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+      throw new Error("Failed to get 2D context");
+    }
+    ctx.drawImage(bitmap, 0, 0);
+    return ctx.getImageData(
+      0,
+      0,
+      bitmap.width,
+      bitmap.height
+    );
+  } finally {
+    bitmap?.close();
+  }
+}
+
+// src/Clipboard/getImageDataFromClipboard.ts
+async function getImageDataFromClipboard(clipboardEvent) {
+  const items = clipboardEvent?.clipboardData?.items;
+  if (!items?.length) return null;
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    if (item.type.startsWith("image/")) {
+      const blob = item.getAsFile();
+      if (!blob) {
+        continue;
+      }
+      return imgBlobToImageData(blob);
+    }
+  }
+  return null;
+}
+
+// src/ImageData/imageDataToImgBlob.ts
+async function imageDataToImgBlob(imageData) {
+  const canvas = new OffscreenCanvas(imageData.width, imageData.height);
+  const ctx = canvas.getContext("2d");
+  if (!ctx) throw new Error("could not create 2d context");
+  ctx.putImageData(imageData, 0, 0);
+  return canvas.convertToBlob({
+    type: "image/png"
+  });
+}
+
+// src/Clipboard/writeImgBlobToClipboard.ts
+async function writeImgBlobToClipboard(blob) {
+  const item = new ClipboardItem({
+    "image/png": blob
+  });
+  await navigator.clipboard.write([item]);
+}
+
+// src/Clipboard/writeImageDataToClipboard.ts
+async function writeImageDataToClipboard(imageData) {
+  const blob = await imageDataToImgBlob(imageData);
+  return writeImgBlobToClipboard(blob);
+}
+
+// src/ImageData/copyImageData.ts
+function copyImageData({ data, width, height }) {
+  return new ImageData(data.slice(), width, height);
+}
+function copyImageDataLike({ data, width, height }) {
+  return {
+    data: data.slice(),
+    width,
+    height
+  };
+}
+
+// src/PixelData/pixelDataToAlphaMask.ts
+function pixelDataToAlphaMask(pixelData) {
+  const {
+    data32,
+    width,
+    height
+  } = pixelData;
+  const len = data32.length;
+  const mask = new Uint8Array(width * height);
+  for (let i = 0; i < len; i++) {
+    const val = data32[i];
+    mask[i] = val >>> 24 & 255;
+  }
+  return mask;
+}
+
+// src/ImageData/imageDataToAlphaMask.ts
+function imageDataToAlphaMask(imageData) {
+  const {
+    width,
+    height,
+    data
+  } = imageData;
+  const data32 = new Uint32Array(
+    data.buffer,
+    data.byteOffset,
+    data.byteLength >> 2
+  );
+  const len = data32.length;
+  const mask = new Uint8Array(width * height);
+  for (let i = 0; i < len; i++) {
+    const val = data32[i];
+    mask[i] = val >>> 24 & 255;
+  }
+  return mask;
+}
+
+// src/ImageData/imageDataToDataUrl.ts
+var get = makeReusableCanvas();
+function imageDataToDataUrl(imageData) {
+  const { canvas, ctx } = get(imageData.width, imageData.height);
+  ctx.putImageData(imageData, 0, 0);
+  return canvas.toDataURL();
+}
+imageDataToDataUrl.reset = get.reset;
+
+// src/ImageData/invertImageData.ts
+function invertImageData(imageData) {
+  const data = imageData.data;
+  let length = data.length;
+  for (let i = 0; i < length; i += 4) {
+    data[i] = 255 - data[i];
+    data[i + 1] = 255 - data[i + 1];
+    data[i + 2] = 255 - data[i + 2];
+  }
+  return imageData;
+}
+
+// src/ImageData/resizeImageData.ts
+function resizeImageData(current, newWidth, newHeight, offsetX = 0, offsetY = 0) {
+  const result = new ImageData(newWidth, newHeight);
+  const {
+    width: oldW,
+    height: oldH,
+    data: oldData
+  } = current;
+  const newData = result.data;
+  const x0 = Math.max(0, offsetX);
+  const y0 = Math.max(0, offsetY);
+  const x1 = Math.min(newWidth, offsetX + oldW);
+  const y1 = Math.min(newHeight, offsetY + oldH);
+  if (x1 <= x0 || y1 <= y0) {
+    return result;
+  }
+  const rowCount = y1 - y0;
+  const rowLen = (x1 - x0) * 4;
+  for (let row = 0; row < rowCount; row++) {
+    const dstY = y0 + row;
+    const srcY = dstY - offsetY;
+    const srcX = x0 - offsetX;
+    const dstStart = (dstY * newWidth + x0) * 4;
+    const srcStart = (srcY * oldW + srcX) * 4;
+    newData.set(
+      oldData.subarray(srcStart, srcStart + rowLen),
+      dstStart
+    );
+  }
+  return result;
+}
+
+// src/ImageData/serialization.ts
+function base64EncodeArrayBuffer(buffer) {
+  const binary = String.fromCharCode(...new Uint8Array(buffer));
+  return btoa(binary);
+}
+function base64DecodeArrayBuffer(encoded) {
+  const binary = atob(encoded);
+  const bytes = new Uint8ClampedArray(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+function serializeImageData(imageData) {
+  return {
+    width: imageData.width,
+    height: imageData.height,
+    data: base64EncodeArrayBuffer(imageData.data.buffer)
+  };
+}
+function serializeNullableImageData(imageData) {
+  if (!imageData) return null;
   return serializeImageData(imageData);
 }
 function deserializeRawImageData(serialized) {
@@ -279,6 +1054,407 @@ function deserializeNullableImageData(serialized) {
   return deserializeImageData(serialized);
 }
 
+// src/ImageData/writeImageDataPixels.ts
+function writeImageDataPixels(imageData, data, _x, _y, _w, _h) {
+  const { x, y, w, h } = typeof _x === "object" ? _x : { x: _x, y: _y, w: _w, h: _h };
+  const { width: dstW, height: dstH, data: dst } = imageData;
+  const x0 = Math.max(0, x);
+  const y0 = Math.max(0, y);
+  const x1 = Math.min(dstW, x + w);
+  const y1 = Math.min(dstH, y + h);
+  if (x1 <= x0 || y1 <= y0) return;
+  const rowLen = (x1 - x0) * 4;
+  const srcCol = x0 - x;
+  const srcYOffset = y0 - y;
+  const actualH = y1 - y0;
+  for (let row = 0; row < actualH; row++) {
+    const dstStart = ((y0 + row) * dstW + x0) * 4;
+    const srcRow = srcYOffset + row;
+    const o = (srcRow * w + srcCol) * 4;
+    dst.set(data.subarray(o, o + rowLen), dstStart);
+  }
+}
+
+// src/Input/fileInputChangeToImageData.ts
+async function fileInputChangeToImageData(event) {
+  const target = event.target;
+  const file = target.files?.[0];
+  if (!file) return null;
+  return await fileToImageData(file);
+}
+
+// src/Input/fileToImageData.ts
+var UnsupportedFormatError = class extends Error {
+  constructor(mimeType) {
+    super(`File type ${mimeType} is not a supported image format.`);
+    this.name = "UnsupportedFormatError";
+  }
+};
+async function fileToImageData(file) {
+  if (!file) return null;
+  if (!file.type.startsWith("image/")) {
+    throw new UnsupportedFormatError(file.type);
+  }
+  let bitmap = null;
+  try {
+    bitmap = await createImageBitmap(file);
+    const canvas = new OffscreenCanvas(
+      bitmap.width,
+      bitmap.height
+    );
+    const ctx = canvas.getContext("2d");
+    if (!ctx) throw new Error(OFFSCREEN_CANVAS_CTX_FAILED);
+    ctx.drawImage(
+      bitmap,
+      0,
+      0
+    );
+    return ctx.getImageData(
+      0,
+      0,
+      bitmap.width,
+      bitmap.height
+    );
+  } finally {
+    bitmap?.close();
+  }
+}
+
+// src/Input/getSupportedRasterFormats.ts
+var formatsPromise = null;
+var defaultRasterMimes = [
+  "image/png",
+  "image/jpeg",
+  "image/webp",
+  "image/avif",
+  "image/gif",
+  "image/bmp"
+];
+async function getSupportedPixelFormats(rasterMimes = defaultRasterMimes) {
+  if (formatsPromise) {
+    return formatsPromise;
+  }
+  const probeCanvas = async () => {
+    const canvas = new OffscreenCanvas(1, 1);
+    const results = await Promise.all(
+      rasterMimes.map(async (mime) => {
+        try {
+          const blob = await canvas.convertToBlob({
+            type: mime
+          });
+          return blob.type === mime ? mime : null;
+        } catch {
+          return null;
+        }
+      })
+    );
+    return results.filter((type) => {
+      return type !== null;
+    });
+  };
+  formatsPromise = probeCanvas().catch((error) => {
+    formatsPromise = null;
+    throw error;
+  });
+  return formatsPromise;
+}
+
+// src/Mask/copyMask.ts
+function copyMask(src) {
+  return src.slice();
+}
+
+// src/Mask/invertMask.ts
+function invertBinaryMask(dst) {
+  const len = dst.length;
+  for (let i = 0; i < len; i++) {
+    dst[i] = dst[i] === 0 ? 1 : 0;
+  }
+}
+function invertAlphaMask(dst) {
+  const len = dst.length;
+  for (let i = 0; i < len; i++) {
+    dst[i] = 255 - dst[i];
+  }
+}
+
+// src/Mask/mergeMasks.ts
+function mergeMasks(dst, dstWidth, src, opts) {
+  const {
+    x: targetX = 0,
+    y: targetY = 0,
+    w: width = 0,
+    h: height = 0,
+    alpha: globalAlpha = 255,
+    maskType = 0 /* ALPHA */,
+    mw,
+    mx = 0,
+    my = 0,
+    invertMask = false
+  } = opts;
+  if (width <= 0 || height <= 0 || globalAlpha === 0) {
+    return;
+  }
+  const sPitch = mw ?? width;
+  const isAlpha = maskType === 0 /* ALPHA */;
+  for (let iy = 0; iy < height; iy++) {
+    const dy = targetY + iy;
+    const sy = my + iy;
+    if (dy < 0 || sy < 0) {
+      continue;
+    }
+    for (let ix = 0; ix < width; ix++) {
+      const dx = targetX + ix;
+      const sx = mx + ix;
+      if (dx < 0 || dx >= dstWidth || sx < 0 || sx >= sPitch) {
+        continue;
+      }
+      const dIdx = dy * dstWidth + dx;
+      const sIdx = sy * sPitch + sx;
+      const mVal = src[sIdx];
+      let weight = globalAlpha;
+      if (isAlpha) {
+        const effectiveM = invertMask ? 255 - mVal : mVal;
+        if (effectiveM === 0) {
+          dst[dIdx] = 0;
+          continue;
+        }
+        weight = globalAlpha === 255 ? effectiveM : effectiveM * globalAlpha + 128 >> 8;
+      } else {
+        const isHit = invertMask ? mVal === 0 : mVal === 1;
+        if (!isHit) {
+          dst[dIdx] = 0;
+          continue;
+        }
+        weight = globalAlpha;
+      }
+      if (weight === 0) {
+        dst[dIdx] = 0;
+        continue;
+      }
+      const da = dst[dIdx];
+      if (da === 0) {
+      } else if (weight === 255) {
+      } else if (da === 255) {
+        dst[dIdx] = weight;
+      } else {
+        dst[dIdx] = da * weight + 128 >> 8;
+      }
+    }
+  }
+}
+
+// src/PixelData.ts
+var PixelData = class {
+  constructor(imageData) {
+    this.imageData = imageData;
+    this.width = imageData.width;
+    this.height = imageData.height;
+    this.data32 = new Uint32Array(
+      imageData.data.buffer,
+      imageData.data.byteOffset,
+      imageData.data.byteLength >> 2
+    );
+  }
+  data32;
+  width;
+  height;
+};
+
+// src/PixelData/applyMaskToPixelData.ts
+function applyMaskToPixelData(dst, mask, opts) {
+  const {
+    x: targetX = 0,
+    y: targetY = 0,
+    w: width = dst.width,
+    h: height = dst.height,
+    alpha: globalAlpha = 255,
+    maskType = 0 /* ALPHA */,
+    mw,
+    mx = 0,
+    my = 0,
+    invertMask = false
+  } = opts;
+  let x = targetX;
+  let y = targetY;
+  let w = width;
+  let h = height;
+  if (x < 0) {
+    w += x;
+    x = 0;
+  }
+  if (y < 0) {
+    h += y;
+    y = 0;
+  }
+  const actualW = Math.min(w, dst.width - x);
+  const actualH = Math.min(h, dst.height - y);
+  if (actualW <= 0 || actualH <= 0 || globalAlpha === 0) {
+    return;
+  }
+  const dst32 = dst.data32;
+  const dw = dst.width;
+  const mPitch = mw ?? width;
+  const isAlpha = maskType === 0 /* ALPHA */;
+  const dx = x - targetX;
+  const dy = y - targetY;
+  let dIdx = y * dw + x;
+  let mIdx = (my + dy) * mPitch + (mx + dx);
+  const dStride = dw - actualW;
+  const mStride = mPitch - actualW;
+  for (let iy = 0; iy < actualH; iy++) {
+    for (let ix = 0; ix < actualW; ix++) {
+      const mVal = mask[mIdx];
+      let weight = globalAlpha;
+      if (isAlpha) {
+        const effectiveM = invertMask ? 255 - mVal : mVal;
+        if (effectiveM === 0) {
+          dst32[dIdx] = (dst32[dIdx] & 16777215) >>> 0;
+          dIdx++;
+          mIdx++;
+          continue;
+        }
+        weight = globalAlpha === 255 ? effectiveM : effectiveM * globalAlpha + 128 >> 8;
+      } else {
+        const isHit = invertMask ? mVal === 0 : mVal === 1;
+        if (!isHit) {
+          dst32[dIdx] = (dst32[dIdx] & 16777215) >>> 0;
+          dIdx++;
+          mIdx++;
+          continue;
+        }
+        weight = globalAlpha;
+      }
+      if (weight === 0) {
+        dst32[dIdx] = (dst32[dIdx] & 16777215) >>> 0;
+      } else {
+        const d = dst32[dIdx];
+        const da = d >>> 24;
+        let finalAlpha = da;
+        if (da === 0) {
+        } else if (weight === 255) {
+        } else if (da === 255) {
+          finalAlpha = weight;
+        } else {
+          finalAlpha = da * weight + 128 >> 8;
+        }
+        dst32[dIdx] = (d & 16777215 | finalAlpha << 24) >>> 0;
+      }
+      dIdx++;
+      mIdx++;
+    }
+    dIdx += dStride;
+    mIdx += mStride;
+  }
+}
+
+// src/PixelData/blendColorPixelData.ts
+function blendColorPixelData(dst, color, opts) {
+  const {
+    x: targetX = 0,
+    y: targetY = 0,
+    w: width = dst.width,
+    h: height = dst.height,
+    alpha: globalAlpha = 255,
+    blendFn = sourceOverColor32,
+    mask,
+    maskType = 0 /* ALPHA */,
+    mw,
+    mx = 0,
+    my = 0,
+    invertMask = false
+  } = opts;
+  if (globalAlpha === 0) return;
+  let x = targetX;
+  let y = targetY;
+  let w = width;
+  let h = height;
+  if (x < 0) {
+    w += x;
+    x = 0;
+  }
+  if (y < 0) {
+    h += y;
+    y = 0;
+  }
+  const actualW = Math.min(w, dst.width - x);
+  const actualH = Math.min(h, dst.height - y);
+  if (actualW <= 0 || actualH <= 0) return;
+  const dst32 = dst.data32;
+  const dw = dst.width;
+  const mPitch = mw ?? width;
+  const isAlphaMask = maskType === 0 /* ALPHA */;
+  const dx = x - targetX;
+  const dy = y - targetY;
+  let dIdx = y * dw + x;
+  let mIdx = (my + dy) * mPitch + (mx + dx);
+  const dStride = dw - actualW;
+  const mStride = mPitch - actualW;
+  const baseSrcColor = color;
+  const baseSrcAlpha = baseSrcColor >>> 24;
+  for (let iy = 0; iy < actualH; iy++) {
+    for (let ix = 0; ix < actualW; ix++) {
+      if (baseSrcAlpha === 0) {
+        dIdx++;
+        mIdx++;
+        continue;
+      }
+      let weight = globalAlpha;
+      if (mask) {
+        const mVal = mask[mIdx];
+        if (isAlphaMask) {
+          const effectiveM = invertMask ? 255 - mVal : mVal;
+          if (effectiveM === 0) {
+            dIdx++;
+            mIdx++;
+            continue;
+          }
+          if (globalAlpha === 255) {
+            weight = effectiveM;
+          } else if (effectiveM === 255) {
+            weight = globalAlpha;
+          } else {
+            weight = effectiveM * globalAlpha + 128 >> 8;
+          }
+        } else {
+          const isHit = invertMask ? mVal === 0 : mVal === 1;
+          if (!isHit) {
+            dIdx++;
+            mIdx++;
+            continue;
+          }
+          weight = globalAlpha;
+        }
+        if (weight === 0) {
+          dIdx++;
+          mIdx++;
+          continue;
+        }
+      }
+      let currentSrcAlpha = baseSrcAlpha;
+      let currentSrcColor = baseSrcColor;
+      if (weight < 255) {
+        if (baseSrcAlpha === 255) {
+          currentSrcAlpha = weight;
+        } else {
+          currentSrcAlpha = baseSrcAlpha * weight + 128 >> 8;
+        }
+        if (currentSrcAlpha === 0) {
+          dIdx++;
+          mIdx++;
+          continue;
+        }
+        currentSrcColor = (baseSrcColor & 16777215 | currentSrcAlpha << 24) >>> 0;
+      }
+      dst32[dIdx] = blendFn(currentSrcColor, dst32[dIdx]);
+      dIdx++;
+      mIdx++;
+    }
+    dIdx += dStride;
+    mIdx += mStride;
+  }
+}
+
 // src/PixelData/blendPixelData.ts
 function blendPixelData(dst, src, opts) {
   const {
@@ -414,40 +1590,151 @@ function blendPixelData(dst, src, opts) {
     mIdx += mStride;
   }
 }
+
+// src/PixelData/fillPixelData.ts
+function fillPixelData(dst, color, _x, _y, _w, _h) {
+  let x;
+  let y;
+  let w;
+  let h;
+  if (typeof _x === "object") {
+    x = _x.x ?? 0;
+    y = _x.y ?? 0;
+    w = _x.w ?? dst.width;
+    h = _x.h ?? dst.height;
+  } else if (typeof _x === "number") {
+    x = _x;
+    y = _y;
+    w = _w;
+    h = _h;
+  } else {
+    x = 0;
+    y = 0;
+    w = dst.width;
+    h = dst.height;
+  }
+  if (x < 0) {
+    w += x;
+    x = 0;
+  }
+  if (y < 0) {
+    h += y;
+    y = 0;
+  }
+  const actualW = Math.min(w, dst.width - x);
+  const actualH = Math.min(h, dst.height - y);
+  if (actualW <= 0 || actualH <= 0) {
+    return;
+  }
+  const dst32 = dst.data32;
+  const dw = dst.width;
+  if (actualW === dw && actualH === dst.height && x === 0 && y === 0) {
+    dst32.fill(color);
+    return;
+  }
+  for (let iy = 0; iy < actualH; iy++) {
+    const start = (y + iy) * dw + x;
+    const end = start + actualW;
+    dst32.fill(color, start, end);
+  }
+}
+
+// src/PixelData/clearPixelData.ts
+function clearPixelData(dst, rect) {
+  fillPixelData(dst, 0, rect);
+}
+
+// src/PixelData/invertPixelData.ts
+function invertPixelData(pixelData) {
+  const data32 = pixelData.data32;
+  const len = data32.length;
+  for (let i = 0; i < len; i++) {
+    data32[i] = data32[i] ^ 16777215;
+  }
+  return pixelData;
+}
 export {
+  BlendMode,
   COLOR_32_BLEND_MODES,
+  COLOR_32_BLEND_TO_INDEX,
+  INDEX_TO_COLOR_32_BLEND,
   MaskType,
+  PixelData,
+  UnsupportedFormatError,
+  applyMaskToPixelData,
   base64DecodeArrayBuffer,
   base64EncodeArrayBuffer,
+  blendColorPixelData,
   blendPixelData,
+  clearPixelData,
   color32ToCssRGBA,
   color32ToHex,
   colorBurnColor32,
   colorDistance,
+  colorDodgeColor32,
   copyImageData,
   copyImageDataLike,
+  copyMask,
+  darkenColor32,
+  darkerColor32,
   deserializeImageData,
   deserializeNullableImageData,
   deserializeRawImageData,
   differenceColor32,
-  extractImageData,
+  divideColor32,
+  exclusionColor32,
+  extractImageDataPixels,
+  extractMask,
+  fileInputChangeToImageData,
+  fileToImageData,
+  fillPixelData,
+  floodFillSelection,
+  getImageDataFromClipboard,
+  getSupportedPixelFormats,
   hardLightColor32,
+  hardMixColor32,
+  imageDataToAlphaMask,
+  imageDataToDataUrl,
+  imageDataToImgBlob,
+  imgBlobToImageData,
+  invertAlphaMask,
+  invertBinaryMask,
+  invertImageData,
+  invertPixelData,
   lerpColor32,
   lerpColor32Fast,
+  lightenColor32,
+  lighterColor32,
+  linearBurnColor32,
   linearDodgeColor32,
+  linearLightColor32,
+  makePixelCanvas,
+  makeReusableCanvas,
+  mergeMasks,
   multiplyColor32,
   overlayColor32,
+  overwriteColor32,
   packColor,
   packRGBA,
+  pinLightColor32,
+  pixelDataToAlphaMask,
+  resizeImageData,
   screenColor32,
   serializeImageData,
   serializeNullableImageData,
+  softLightColor32,
   sourceOverColor32,
+  subtractColor32,
+  trimRectBounds,
   unpackAlpha,
   unpackBlue,
   unpackColor,
   unpackColorTo,
   unpackGreen,
-  unpackRed
+  unpackRed,
+  vividLightColor32,
+  writeImageDataPixels,
+  writeImageDataToClipboard,
+  writeImgBlobToClipboard
 };
 //# sourceMappingURL=index.dev.js.map