emf-converter 4.3.4 → 4.3.5

package/README.md

@@ -214,7 +214,7 @@ Everything below is verified against output painted by Windows itself; `src/gdi-
 
 Everything is measured against output painted by Windows itself; `src/gdi-parity.fixture.test.ts` holds the exact per-fixture bounds. Open work items are tracked in [docs/outstanding-work.md](docs/outstanding-work.md).
 
-- **Colour adjustment and image effects**: The `HALFTONE` stretch mode reproduces Windows' halftone engine for 32-bit output: an enlargement smooths isolated pixels and then takes the nearest source pixel, and a reduction averages each pixel's footprint and then sharpens. All seven plain `HALFTONE` fixtures (2x, 3x, 0.5x, 0.65x and 1.37x) match exactly. It is not verified for a stretch that enlarges one axis and reduces the other. `EMR_SETCOLORADJUSTMENT` is applied to the source of `HALFTONE` `StretchBlt` and `StretchDIBits` calls, as in GDI. Windows does not publish its adjustment formulas. The converter uses a model fitted to two Windows captures: contrast and brightness on CIE L*, colourfulness and red-green tint on u'v' chromaticity, with gamma as the source encoding, so a gamma on its own changes nothing. Windows also dithers the adjusted colours over 32 levels per channel, and that pattern is not reproduced. On the fixtures, 0% to 15.1% of pixels differ by more than 24. The log filter uses an unverified curve, and the illuminant is ignored. EMF+ image effects (`SerializableObject`) are applied to the image's pixels before it is drawn. Colour matrix and lookup table effects follow GDI+'s definitions; MS-EMFPLUS does not specify the algorithms of the others (blur, sharpen, brightness/contrast, levels, colour balance, colour curves, hue/saturation/lightness, tint, red-eye), so those use documented approximations and have not been checked against GDI+ output. An effect is applied to the draw's source rectangle only, and a blur with `expandEdge` grows it by the blur radius, as GDI+ does. When the source rectangle is not in pixels, the effect is applied to the whole image without that growth. An effect is skipped when the image cannot be decoded to pixels: PNG and BMP always can be, while JPEG, GIF, TIFF and similar formats need a canvas backend (a browser or `@napi-rs/canvas`).
+- **Colour adjustment and image effects**: The `HALFTONE` stretch mode reproduces Windows' halftone engine for 32-bit output: an enlargement smooths isolated pixels and then takes the nearest source pixel, and a reduction averages each pixel's footprint and then sharpens. All seven plain `HALFTONE` fixtures (2x, 3x, 0.5x, 0.65x and 1.37x) match exactly. It is not verified for a stretch that enlarges one axis and reduces the other. `EMR_SETCOLORADJUSTMENT` is applied to the source of `HALFTONE` `StretchBlt` and `StretchDIBits` calls, as in GDI. Windows does not publish its adjustment formulas. The converter uses a model fitted to two Windows captures: contrast and brightness on CIE L*, colourfulness and red-green tint on u'v' chromaticity, with gamma as the source encoding, so a gamma on its own changes nothing. Windows also dithers the adjusted colours over 32 levels per channel, and that pattern is not reproduced. On the fixtures, 0% to 15.1% of pixels differ by more than 24. The log filter uses an unverified curve, and the illuminant is ignored. EMF+ image effects (`SerializableObject`) are applied to the image's pixels before it is drawn. MS-EMFPLUS does not specify the algorithms, so they were measured against the effected bitmaps GDI+ itself writes into its recordings. Colour matrix, lookup table, brightness/contrast, colour balance, levels and sharpen match GDI+ exactly; blur matches to within one level (GDI+ blurs along rows only, plus a vertical blur of the top row, and so does the converter); colour curves match exactly for exposure, density, midtone and black saturation and to within one level on up to 2.3% of pixels for contrast, highlight, shadow and white saturation, whose control points were measured at intensity ±50 and are scaled for other values; hue/saturation/lightness uses GDI+'s integer HSL, but its hue rounding is only partly reproduced, so lightness and saturation changes differ on under 1% of pixels and a hue rotation is more than two levels off on 0.3% to 32% of pixels (up to 11 levels); tint is within two levels (three on 0.07% of pixels); red-eye correction is an approximation, as GDI+'s pupil detection and textured repaint are not reproduced (up to 17% of pixels differ). GDI+ follows each effect draw with a plain draw of the bitmap it effected, so Windows' playback depends on the effect only where that bitmap is translucent; played back, the image effect fixtures match Windows to within one level, except one edge of a rotated blurred draw (0.22% of pixels). An effect is applied to the draw's source rectangle only, reading one more column and row, as GDI+ does; a blur with `expandEdge` blurs transparency in at the edges but, as in GDI+, draws nothing beyond the source rectangle. When the source rectangle is not in pixels, the effect is applied to the whole image. GDI+ records a colour curve effect under the lookup table's identifier and its own playback draws the image without the effect; the converter does the same. An effect is skipped when the image cannot be decoded to pixels: PNG and BMP always can be, while JPEG, GIF, TIFF and similar formats need a canvas backend (a browser or `@napi-rs/canvas`).
 - **Pen transforms**: EMF+ pen transforms (uniform, nonuniform and skewed) match GDI+ exactly on the 17 pen-transform fixtures, including dashes, which GDI+ lays out along the path in world space at the untransformed pen width. The fixtures include dashes only under a non-uniform scale. Dashes under a uniform scale follow the same rule but have not been checked. A pen transform that cannot be inverted is ignored. Of the anchor caps, only `ArrowAnchor` is drawn with its real shape. The others are drawn as their base cap.
 - **Text**: ANSI, multi-string and small-text records now render; the Windows text fixtures retain a few glyph-edge differences and a `PolyTextOut` C1 control-glyph difference (under 0.1% of pixels; bounds in `src/emf-text-records.fixture.test.ts`). ANSI decoding uses the host's `TextDecoder` for common Windows code pages; unsupported encodings (including Johab and OEM on standard runtimes) fall back to Windows-1252. Vertical `ETO_PDY` advances require the `fonts` engine. Without `fonts`, SVG text measurements use deterministic estimates, so precise justification requires supplying the matching fonts.
 - **Wide pens and paths**: flat-capped GDI pens 7 px and wider can differ by a few pixels at round joins, and dashed wide Bezier curves follow `WidenPath` (which Windows' direct drawing does not quite match); at most 0.2% of pixels on the fixtures. `EMR_WIDENPATH` does not reproduce the extra inner join triangles GDI's own `WidenPath` emits (visible only when the widened outline is itself stroked). EMF+ 1-pixel antialiased lines can differ by one antialiasing sample at their ends, some closed widened outlines by one sample along an edge, and Inset or compound pens on closed figures are approximate.

package/dist/index.js

@@ -12319,7 +12319,7 @@ function blendSeparable(rgba, width, box, iu0, wu, iv0, wv, verticalFirst, edge
 }
 var OUTSIDE_TRANSPARENT = -1;
 var OUTSIDE_CLAMP = -2;
-function wrapTap(t, lo, hi, mirror, edge) {
+function wrapTap(t, lo, hi, mirror2, edge) {
   if (t >= lo && t < hi) {
     return t;
   }
@@ -12330,7 +12330,7 @@ function wrapTap(t, lo, hi, mirror, edge) {
     return OUTSIDE_CLAMP;
   }
   const n = hi - lo;
-  if (!mirror) {
+  if (!mirror2) {
     return lo + ((t - lo) % n + n) % n;
   }
   const q = ((t - lo) % (2 * n) + 2 * n) % (2 * n);
@@ -17630,9 +17630,9 @@ function buildPattern(ctx, rect, tw, th, wrap, brush, delta, sampling, colorAt)
   if (typeof ctx.createPattern !== "function") {
     return null;
   }
-  const mirror = wrap === "clamp" ? { x: false, y: false } : mirrorFlags(wrap);
-  const w = tw * (mirror.x ? 2 : 1);
-  const h = th * (mirror.y ? 2 : 1);
+  const mirror2 = wrap === "clamp" ? { x: false, y: false } : mirrorFlags(wrap);
+  const w = tw * (mirror2.x ? 2 : 1);
+  const h = th * (mirror2.y ? 2 : 1);
   const temp = createTempCanvas(w, h);
   if (!temp) {
     return null;
@@ -18054,8 +18054,8 @@ function createHatchPattern(ctx, hatch, origin, user, deviceToCanvas) {
 }
 
 // src/emf-plus-brush-texture.ts
-function wrapTexel(i, n, mirror) {
-  if (!mirror) {
+function wrapTexel(i, n, mirror2) {
+  if (!mirror2) {
     return (i % n + n) % n;
   }
   const p = (i % (2 * n) + 2 * n) % (2 * n);
@@ -19116,11 +19116,11 @@ function boundaryBox2(points) {
   }
   return x1 > x0 && y1 > y0 ? { x: x0, y: y0, w: x1 - x0, h: y1 - y0 } : null;
 }
-function foldIntoTile(v, origin, size, mirror, lag) {
+function foldIntoTile(v, origin, size, mirror2, lag) {
   const rel = v - origin;
   const k = Math.floor(rel / size);
   const local = rel - k * size;
-  if (mirror && (k % 2 + 2) % 2 === 1) {
+  if (mirror2 && (k % 2 + 2) % 2 === 1) {
     return origin + size - lag - local;
   }
   return origin + local;
@@ -23974,6 +23974,7 @@ function readGuid(view, off) {
   ].join("-");
 }
 var clamp = (v, lo, hi) => v < lo ? lo : v > hi ? hi : v;
+var COLOR_CURVE_PARAMS_SIZE = 12;
 function parseSerializableObject(view, dataOff, dataSize) {
   if (dataSize < 20) {
     return null;
@@ -23998,7 +23999,7 @@ function parseSerializableObject(view, dataOff, dataSize) {
     case "colorBalance":
       return need(12) ? { kind, cyanRed: i32(0, -100, 100), magentaGreen: i32(1, -100, 100), yellowBlue: i32(2, -100, 100) } : null;
     case "colorCurve":
-      return need(12) ? {
+      return need(COLOR_CURVE_PARAMS_SIZE) ? {
         kind,
         adjustment: view.getInt32(p, true),
         channel: view.getInt32(p + 4, true),
@@ -24052,66 +24053,101 @@ function parseSerializableObject(view, dataOff, dataSize) {
       return need(8) ? { kind, hue: i32(0, -180, 180), amount: i32(1, -100, 100) } : null;
   }
 }
-function buildLut(f) {
+var roundHalfDown = (v) => Math.ceil(v - 0.5);
+function buildLut(f, round = Math.round) {
   const lut = new Uint8Array(256);
   for (let v = 0; v < 256; v++) {
-    lut[v] = clamp(Math.round(f(v)), 0, 255);
+    lut[v] = clamp(round(f(v)), 0, 255);
   }
   return lut;
 }
-function contrastCurve(c) {
-  const gain = c >= 100 ? 1e6 : c >= 0 ? 100 / (100 - c) : (100 + c) / 100;
-  return (v) => (v - 127.5) * gain + 127.5;
-}
-function balanceCurve(t) {
-  const f = t / 100;
-  return (v) => f >= 0 ? v + (255 - v) * f : v * (1 + f);
-}
-function midtoneCurve(t) {
-  const gamma = 2 ** (-t / 100);
-  return (v) => 255 * (v / 255) ** gamma;
+function midtoneGamma(t) {
+  return t >= 0 ? 1 / (1 + t / 50) : 1 - t / 50;
+}
+function brightnessContrastLut(brightness, contrast) {
+  const gain = contrast >= 100 ? 1e6 : contrast >= 0 ? 100 / (100 - contrast) : (100 + contrast) / 100;
+  const half = brightness / 2;
+  return buildLut((v) => (v + half - 127.5) * gain + 127.5 + half);
+}
+function balanceLut(t) {
+  return buildLut((v) => v * (1 + t / 100));
+}
+function splineLut(ys) {
+  const n = ys.length;
+  const h = 255 / (n - 1);
+  const m = new Float64Array(n);
+  const c = new Float64Array(n);
+  const d = new Float64Array(n);
+  for (let i = 1; i < n - 1; i++) {
+    const rhs = 6 * (ys[i + 1] - 2 * ys[i] + ys[i - 1]) / (h * h);
+    const den = 4 - c[i - 1];
+    c[i] = 1 / den;
+    d[i] = (rhs - d[i - 1]) / den;
+  }
+  for (let i = n - 2; i >= 1; i--) {
+    m[i] = d[i] - c[i] * m[i + 1];
+  }
+  return buildLut((v) => {
+    const i = Math.min(n - 2, Math.floor(v / h));
+    const b = (v - i * h) / h;
+    const a = 1 - b;
+    return a * ys[i] + b * ys[i + 1] + ((a * a * a - a) * m[i] + (b * b * b - b) * m[i + 1]) * h * h / 6;
+  });
 }
+var CURVE_POINTS = 23;
+var CURVE_X = Array.from({ length: CURVE_POINTS }, (_, k) => k * 255 / (CURVE_POINTS - 1));
+var CURVE_TABLES = {
+  "contrast+": [0, 3.8, 8, 12.2, 17.4, 23.5, 31.1, 40.2, 53, 70.2, 94.5, 127.5, 160.5, 184.8, 202, 214.8, 223.9, 231.5, 237.6, 242.8, 247, 251.2, 255],
+  "contrast-": [0, 33.1, 57.2, 74.7, 87.2, 96.6, 103.9, 109.8, 115.3, 119.6, 123.7, 127.5, 131.3, 135.4, 139.7, 145.2, 151.1, 158.4, 167.8, 180.3, 197.8, 221.9, 255],
+  "highlight+": [0, 11.6, 23.2, 34.8, 46.4, 58, 69.6, 81.1, 92.7, 104.3, 116, 127.6, 142.3, 160.6, 186.4, 208, 220.6, 229.4, 236.2, 242, 246.6, 251, 255],
+  "highlight-": [0, 11.6, 23.2, 34.8, 46.4, 58, 69.5, 81.1, 92.7, 104.4, 115.9, 127.5, 136.7, 144.9, 151.4, 157.1, 161.8, 167.2, 174.3, 185.3, 200.9, 223.7, 255],
+  "shadow+": [0, 31.3, 54, 70, 82.5, 92.3, 99.5, 104.8, 109.5, 115, 121.3, 127.7, 139.2, 150.6, 162.3, 173.8, 185.5, 197, 208.6, 220.2, 231.8, 243.4, 255],
+  "shadow-": [0, 4, 8.4, 13, 18.7, 25.7, 34.4, 45, 58.4, 80, 105.8, 127.5, 139.2, 150.7, 162.3, 173.9, 185.4, 197, 208.6, 220.2, 231.8, 243.4, 255]
+};
 function curveAdjustmentLut(adjustment, intensity) {
   const t = intensity;
+  let ys;
   switch (adjustment) {
     case CurveAdjustment.Exposure:
-      return buildLut((v) => v * (1 + t / 255));
+      ys = CURVE_X.map((x) => roundHalfDown(x) + t);
+      break;
     case CurveAdjustment.Density:
-      return buildLut((v) => v * (1 - t / 255));
+      ys = CURVE_X.map((x) => x + t);
+      break;
     case CurveAdjustment.Contrast:
-      return buildLut(contrastCurve(clamp(t, -100, 100)));
     case CurveAdjustment.Highlight:
     case CurveAdjustment.Shadow: {
-      const high = adjustment === CurveAdjustment.Highlight;
-      const amp = clamp(t, -100, 100) * 0.32;
-      return buildLut((v) => {
-        const inside = high ? v > 128 : v < 128;
-        if (!inside) {
-          return v;
-        }
-        const u = high ? (v - 128) / 127 : v / 128;
-        return v + amp * Math.sin(Math.PI * u);
-      });
+      const c = clamp(t, -100, 100);
+      const name = ["contrast", "highlight", "shadow"][adjustment - CurveAdjustment.Contrast] + (c >= 0 ? "+" : "-");
+      const table = CURVE_TABLES[name];
+      ys = CURVE_X.map((x, k) => x + Math.abs(c) / 50 * (table[k] - x));
+      break;
+    }
+    case CurveAdjustment.Midtone: {
+      const g = midtoneGamma(clamp(t, -100, 100));
+      ys = CURVE_X.map((x) => 255 * (x / 255) ** g);
+      break;
     }
-    case CurveAdjustment.Midtone:
-      return buildLut(midtoneCurve(clamp(t, -100, 100)));
     case CurveAdjustment.WhiteSaturation: {
       const w = Math.max(1, clamp(t, 0, 255));
-      return buildLut((v) => v * 255 / w);
+      ys = CURVE_X.map((x) => x * 255 / w);
+      break;
     }
     case CurveAdjustment.BlackSaturation: {
       const b = Math.min(254, clamp(t, 0, 255));
-      return buildLut((v) => (v - b) * 255 / (255 - b));
+      ys = CURVE_X.map((x) => (x - b) * 255 / (255 - b));
+      break;
     }
     default:
       return null;
   }
+  return splineLut(ys.map((y) => clamp(y, 0, 255)));
 }
 function levelsLut(highlight, midtone, shadow) {
   const black = shadow / 100 * 255;
   const white = Math.max(black + 1, highlight / 100 * 255);
-  const gamma = midtoneCurve(midtone);
-  return buildLut((v) => gamma(clamp((v - black) / (white - black), 0, 1) * 255));
+  const gamma = midtoneGamma(midtone);
+  return buildLut((v) => 255 * clamp((v - black) / (white - black), 0, 1) ** gamma, roundHalfDown);
 }
 function applyLuts(src, r, g, b, a = null) {
   const out = new Uint8ClampedArray(src);
@@ -24137,26 +24173,6 @@ function applyColorMatrix(src, m) {
   }
   return out;
 }
-function rgbToHsl(r, g, b) {
-  const max = Math.max(r, g, b);
-  const min = Math.min(r, g, b);
-  const l = (max + min) / 2;
-  const d = max - min;
-  if (d === 0) {
-    return [0, 0, l];
-  }
-  const s = d / (1 - Math.abs(2 * l - 1));
-  let h;
-  if (max === r) {
-    h = (g - b) / d % 6;
-  } else if (max === g) {
-    h = (b - r) / d + 2;
-  } else {
-    h = (r - g) / d + 4;
-  }
-  h *= 60;
-  return [h < 0 ? h + 360 : h, s, l];
-}
 function hslToRgb(h, s, l) {
   const c = (1 - Math.abs(2 * l - 1)) * s;
   const hp = (h % 360 + 360) % 360 / 60;
@@ -24165,29 +24181,80 @@ function hslToRgb(h, s, l) {
   const [r, g, b] = hp < 1 ? [c, x, 0] : hp < 2 ? [x, c, 0] : hp < 3 ? [0, c, x] : hp < 4 ? [0, x, c] : hp < 5 ? [x, 0, c] : [c, 0, x];
   return [r + m, g + m, b + m];
 }
+var HUE_SEXTANT = 43;
+var HUE_CIRCLE = 6 * HUE_SEXTANT;
+function gdipHue(r, g, b) {
+  const max = Math.max(r, g, b);
+  const d = max - Math.min(r, g, b);
+  const f = (x) => Math.floor(x * HUE_SEXTANT / d);
+  if (max === r && g >= b) {
+    return f(g - b);
+  }
+  if (max === g) {
+    return b >= r ? 87 + f(b - r) : 86 - f(r - b);
+  }
+  if (max === b && b !== r) {
+    return r >= g ? 172 + f(r - g) : 171 - f(g - r);
+  }
+  const t = f(b - g);
+  return (256 - t - (t >= 40 ? 1 : 0)) % 256;
+}
 function applyHueSaturationLightness(src, hue, saturation, lightness2) {
   const out = new Uint8ClampedArray(src);
-  const push = (v, t) => t >= 0 ? v + (1 - v) * (t / 100) : v * (1 + t / 100);
+  const shift = Math.round(hue * HUE_CIRCLE / 360);
+  const sMul = 1 + saturation / 100;
   for (let i = 0; i < src.length; i += 4) {
-    const [h, s, l] = rgbToHsl(src[i] / 255, src[i + 1] / 255, src[i + 2] / 255);
-    const [r, g, b] = hslToRgb(h + hue, push(s, saturation), push(l, lightness2));
-    out[i] = Math.round(r * 255);
-    out[i + 1] = Math.round(g * 255);
-    out[i + 2] = Math.round(b * 255);
+    const r = src[i];
+    const g = src[i + 1];
+    const b = src[i + 2];
+    const max = Math.max(r, g, b);
+    const min = Math.min(r, g, b);
+    const l = clamp(Math.round(((max + min >> 1) * 100 + 255 * lightness2) / 100), 0, 255);
+    if (max === min) {
+      out[i] = out[i + 1] = out[i + 2] = l;
+      continue;
+    }
+    const sum = max + min;
+    const s = clamp((max - min) / (sum <= 255 ? sum : 510 - sum) * sMul, 0, 1);
+    const hi = l <= 127 ? l * (1 + s) : l + s * (255 - l);
+    const m1 = l <= 127 ? 2 * l - Math.trunc(hi) : Math.round(2 * l - hi);
+    const m2 = 2 * l - m1;
+    const q = ((gdipHue(r, g, b) + shift) % HUE_CIRCLE + HUE_CIRCLE) % HUE_CIRCLE;
+    const sextant = Math.min(5, Math.floor(q / HUE_SEXTANT));
+    const f = (q - sextant * HUE_SEXTANT) / HUE_SEXTANT;
+    const up = Math.trunc(m1 + (m2 - m1) * f);
+    const down = Math.trunc(m1 + (m2 - m1) * (1 - f));
+    const [nr, ng, nb] = [
+      [m2, up, m1],
+      [down, m2, m1],
+      [m1, m2, up],
+      [m1, down, m2],
+      [up, m1, m2],
+      [m2, m1, down]
+    ][sextant];
+    out[i] = nr;
+    out[i + 1] = ng;
+    out[i + 2] = nb;
   }
   return out;
 }
-var LUMA = [0.299, 0.587, 0.114];
+var LUMA_709 = [0.2126, 0.7152, 0.0722];
+var TINT_CHROMA_SCALE = 0.985;
 function applyTint(src, hue, amount) {
   const tint = hslToRgb(hue, 1, 0.5);
-  const y = tint[0] * LUMA[0] + tint[1] * LUMA[1] + tint[2] * LUMA[2];
-  const k = amount / 100 * 255;
-  const add = tint.map((c) => (c - y) * k);
+  const ty = tint[0] * LUMA_709[0] + tint[1] * LUMA_709[1] + tint[2] * LUMA_709[2];
+  const chroma = tint.map((c) => (c - ty) * TINT_CHROMA_SCALE);
+  const a = amount / 100;
   const out = new Uint8ClampedArray(src);
   for (let i = 0; i < src.length; i += 4) {
-    out[i] = Math.round(src[i] + add[0]);
-    out[i + 1] = Math.round(src[i + 1] + add[1]);
-    out[i + 2] = Math.round(src[i + 2] + add[2]);
+    const r = src[i];
+    const g = src[i + 1];
+    const b = src[i + 2];
+    const y = r * LUMA_709[0] + g * LUMA_709[1] + b * LUMA_709[2];
+    const v = Math.max(r, g, b);
+    out[i] = Math.round((1 - a) * r + a * (y + v * chroma[0]));
+    out[i + 1] = Math.round((1 - a) * g + a * (y + v * chroma[1]));
+    out[i + 2] = Math.round((1 - a) * b + a * (y + v * chroma[2]));
   }
   return out;
 }
@@ -24204,7 +24271,7 @@ function applyRedEyeCorrection(src, width, height, areas) {
         const r = out[i];
         const g = out[i + 1];
         const b = out[i + 2];
-        if (r > g && r > b) {
+        if (r >= 2 * g && r >= 2 * b && r > 64) {
           out[i] = Math.round((g + b) / 2);
         }
       }
@@ -24212,83 +24279,96 @@ function applyRedEyeCorrection(src, width, height, areas) {
   }
   return out;
 }
-function boxRadiiForSigma(sigma) {
-  const target = sigma * sigma;
-  let k = 0;
-  while ((k + 1) * (k + 2) <= target) {
-    k++;
+function blurKernel(radius) {
+  const taps = Math.ceil(radius);
+  const k = new Float64Array(2 * taps + 1);
+  if (taps === 0) {
+    k[0] = 1;
+    return k;
   }
-  const v = (n) => n * (n + 1) / 3;
-  let best = 0;
-  for (let m = 1; m <= 3; m++) {
-    if (Math.abs((3 - m) * v(k) + m * v(k + 1) - target) < Math.abs((3 - best) * v(k) + best * v(k + 1) - target)) {
-      best = m;
-    }
-  }
-  return [0, 1, 2].map((i) => i < best ? k + 1 : k);
-}
-function boxPass(src, w, h, r, horizontal) {
-  if (r <= 0) {
-    return src;
-  }
-  const out = new Float64Array(src.length);
-  const lines = horizontal ? h : w;
-  const len = horizontal ? w : h;
-  const step = horizontal ? 4 : w * 4;
-  const norm = 1 / (2 * r + 1);
-  for (let line = 0; line < lines; line++) {
-    const base = horizontal ? line * w * 4 : line * 4;
-    for (let c = 0; c < 4; c++) {
-      const at = (p) => src[base + clamp(p, 0, len - 1) * step + c];
-      let sum = 0;
-      for (let p = -r; p <= r; p++) {
-        sum += at(p);
-      }
-      for (let p = 0; p < len; p++) {
-        out[base + p * step + c] = sum * norm;
-        sum += at(p + r + 1) - at(p - r);
-      }
-    }
+  const sigma = radius / 1.98;
+  let sum = 0;
+  for (let i = -taps; i <= taps; i++) {
+    const w = Math.exp(-(i * i) / (2 * sigma * sigma));
+    k[i + taps] = w;
+    sum += w;
   }
-  return out;
+  for (let i = 0; i < k.length; i++) {
+    k[i] /= sum;
+  }
+  return k;
 }
-function blurFloat(src, w, h, radius) {
-  let buf = new Float64Array(src.length);
-  for (let i = 0; i < src.length; i += 4) {
-    const a = src[i + 3] / 255;
-    buf[i] = src[i] * a;
-    buf[i + 1] = src[i + 1] * a;
-    buf[i + 2] = src[i + 2] * a;
-    buf[i + 3] = src[i + 3];
+function mirror(p, n) {
+  if (n === 1) {
+    return 0;
   }
-  for (const r of boxRadiiForSigma(radius / 2)) {
-    buf = boxPass(buf, w, h, r, true);
-    buf = boxPass(buf, w, h, r, false);
+  while (p < 0 || p >= n) {
+    p = p < 0 ? -p : 2 * (n - 1) - p;
   }
-  for (let i = 0; i < buf.length; i += 4) {
-    const a = buf[i + 3] / 255;
-    for (let c = 0; c < 3; c++) {
-      buf[i + c] = a > 0 ? buf[i + c] / a : 0;
+  return p;
+}
+function gdipBlur(src, w, h, radius, vRow = 0, vZeroAbove = false) {
+  const k = blurKernel(radius);
+  const taps = (k.length - 1) / 2;
+  const out = new Float64Array(w * h * 4);
+  for (let y = 0; y < h; y++) {
+    const row = y * w * 4;
+    for (let x = 0; x < w; x++) {
+      let s0 = 0;
+      let s1 = 0;
+      let s2 = 0;
+      let s3 = 0;
+      for (let j = -taps; j <= taps; j++) {
+        const p = row + mirror(x + j, w) * 4;
+        const kw = k[j + taps];
+        s0 += kw * src[p];
+        s1 += kw * src[p + 1];
+        s2 += kw * src[p + 2];
+        s3 += kw * src[p + 3];
+      }
+      const o = row + x * 4;
+      out[o] = s0;
+      out[o + 1] = s1;
+      out[o + 2] = s2;
+      out[o + 3] = s3;
+    }
+  }
+  if (taps > 0 && vRow >= 0 && vRow < h) {
+    const col = new Float64Array(w * 4);
+    for (let j = -taps; j <= taps; j++) {
+      const yy = vRow + j;
+      if (vZeroAbove && yy < vRow) {
+        continue;
+      }
+      const base = mirror(yy, h) * w * 4;
+      for (let i = 0; i < w * 4; i++) {
+        col[i] += k[j + taps] * out[base + i];
+      }
     }
+    out.set(col, vRow * w * 4);
   }
-  return buf;
+  return out;
 }
 function applyBlur(src, w, h, radius) {
-  const blurred = blurFloat(src, w, h, radius);
-  const out = new Uint8ClampedArray(src.length);
-  for (let i = 0; i < src.length; i++) {
-    out[i] = Math.round(blurred[i]);
+  return Uint8ClampedArray.from(gdipBlur(src, w, h, radius), Math.round);
+}
+var SHARPEN_FALLOFF = Math.log2(96 / 25);
+function sharpenGain(radius, amount) {
+  const x = amount / 100;
+  if (radius <= 3) {
+    return x * 2 * radius / 3;
   }
-  return out;
+  return x * 2 * (3 / radius) ** SHARPEN_FALLOFF;
 }
 function applySharpen(src, w, h, radius, amount) {
-  const blurred = blurFloat(src, w, h, radius);
-  const k = amount / 100;
+  const blurred = gdipBlur(src, w, h, radius);
+  const gain = sharpenGain(radius, amount);
   const out = new Uint8ClampedArray(src);
   for (let i = 0; i < src.length; i += 4) {
     for (let c = 0; c < 3; c++) {
-      out[i + c] = Math.round(src[i + c] + k * (src[i + c] - blurred[i + c]));
+      out[i + c] = Math.round(src[i + c] + gain * (src[i + c] - Math.round(blurred[i + c])));
     }
+    out[i + 3] = Math.max(src[i + 3], out[i], out[i + 1], out[i + 2]);
   }
   return out;
 }
@@ -24302,16 +24382,15 @@ function applyImageEffect(rgba, width, height, effect) {
     case "sharpen":
       return applySharpen(rgba, width, height, effect.radius, effect.amount);
     case "brightnessContrast": {
-      const contrast = contrastCurve(effect.contrast);
-      const lut = buildLut((v) => contrast(v) + effect.brightness);
+      const lut = brightnessContrastLut(effect.brightness, effect.contrast);
       return applyLuts(rgba, lut, lut, lut);
     }
     case "colorBalance":
       return applyLuts(
         rgba,
-        buildLut(balanceCurve(effect.cyanRed)),
-        buildLut(balanceCurve(effect.magentaGreen)),
-        buildLut(balanceCurve(effect.yellowBlue))
+        balanceLut(effect.cyanRed),
+        balanceLut(effect.magentaGreen),
+        balanceLut(effect.yellowBlue)
       );
     case "colorCurve": {
       const lut = curveAdjustmentLut(effect.adjustment, effect.intensity);
@@ -24338,6 +24417,38 @@ function applyImageEffect(rgba, width, height, effect) {
       return applyTint(rgba, effect.hue, effect.amount);
   }
 }
+function copyBlock(src, width, sx, sy, w, h, dst, bw, dx, dy) {
+  for (let y = 0; y < h; y++) {
+    const from = ((sy + y) * width + sx) * 4;
+    dst.set(src.subarray(from, from + w * 4), ((dy + y) * bw + dx) * 4);
+  }
+}
+function expandedBlur(rgba, width, height, radius, x0, y0, x1, y1) {
+  const r = Math.ceil(radius);
+  const bw = x1 - x0 + 2 * r;
+  const bh = y1 - y0 + 2 * r;
+  const buf = new Uint8ClampedArray(bw * bh * 4);
+  const inside = x0 - r >= 0 && y0 - r >= 0 && x1 + r <= width && y1 + r <= height;
+  if (inside) {
+    copyBlock(rgba, width, x0, y0, x1 - x0, y1 - y0, buf, bw, r, r);
+  } else {
+    const gx0 = Math.max(0, x0 - r);
+    const gy0 = Math.max(0, y0 - r);
+    const gx1 = Math.min(width, x1 + r);
+    const gy1 = Math.min(height, y1 + r);
+    copyBlock(rgba, width, gx0, gy0, gx1 - gx0, gy1 - gy0, buf, bw, gx0 - (x0 - r), gy0 - (y0 - r));
+  }
+  const blurred = gdipBlur(buf, bw, bh, radius, inside ? r : 0, inside);
+  const w = x1 - x0;
+  const out = new Uint8ClampedArray(w * (y1 - y0) * 4);
+  for (let y = 0; y < y1 - y0; y++) {
+    const from = ((y + r) * bw + r) * 4;
+    for (let i = 0; i < w * 4; i++) {
+      out[y * w * 4 + i] = Math.round(blurred[from + i]);
+    }
+  }
+  return out;
+}
 function applyImageEffectToRect(rgba, width, height, effect, src) {
   if (width <= 0 || height <= 0 || rgba.length !== width * height * 4) {
     return null;
@@ -24349,38 +24460,43 @@ function applyImageEffectToRect(rgba, width, height, effect, src) {
   if (src) {
     x0 = clamp(Math.floor(src.x), 0, width);
     y0 = clamp(Math.floor(src.y), 0, height);
-    x1 = clamp(Math.ceil(src.x + src.w), 0, width);
-    y1 = clamp(Math.ceil(src.y + src.h), 0, height);
-    if (x1 <= x0 || y1 <= y0) {
+    x1 = clamp(Math.ceil(src.x + src.w) + 1, 0, width);
+    y1 = clamp(Math.ceil(src.y + src.h) + 1, 0, height);
+    if (x1 <= x0 || y1 <= y0 || src.x + src.w <= x0 || src.y + src.h <= y0) {
       return null;
     }
   }
-  const pad = src && effect.kind === "blur" && effect.expandEdge ? Math.ceil(effect.radius) : 0;
-  const cw = x1 - x0;
-  const ch = y1 - y0;
-  const w = cw + 2 * pad;
-  const h = ch + 2 * pad;
+  const w = x1 - x0;
+  const h = y1 - y0;
+  const shownWidth = src ? Math.min(w, Math.ceil(src.x + src.w) - x0) : w;
+  const shownHeight = src ? Math.min(h, Math.ceil(src.y + src.h) - y0) : h;
+  const result = (out2) => {
+    if (shownWidth === w && shownHeight === h) {
+      return { rgba: out2, x: x0, y: y0, width: w, height: h };
+    }
+    const shown = new Uint8ClampedArray(shownWidth * shownHeight * 4);
+    copyBlock(out2, w, 0, 0, shownWidth, shownHeight, shown, shownWidth, 0, 0);
+    return { rgba: shown, x: x0, y: y0, width: shownWidth, height: shownHeight };
+  };
+  if (src && effect.kind === "blur" && effect.expandEdge) {
+    return result(expandedBlur(rgba, width, height, effect.radius, x0, y0, x1, y1));
+  }
   let region = rgba;
-  if (w !== width || h !== height || x0 !== 0 || y0 !== 0) {
+  if (w !== width || h !== height) {
     region = new Uint8ClampedArray(w * h * 4);
-    for (let y = 0; y < ch; y++) {
-      const from = ((y0 + y) * width + x0) * 4;
-      region.set(rgba.subarray(from, from + cw * 4), ((pad + y) * w + pad) * 4);
-    }
+    copyBlock(rgba, width, x0, y0, w, h, region, w, 0, 0);
   }
-  const ox = x0 - pad;
-  const oy = y0 - pad;
   const local = effect.kind === "redEyeCorrection" ? {
     kind: effect.kind,
     areas: effect.areas.map((a) => ({
-      left: a.left - ox,
-      top: a.top - oy,
-      right: a.right - ox,
-      bottom: a.bottom - oy
+      left: a.left - x0,
+      top: a.top - y0,
+      right: a.right - x0,
+      bottom: a.bottom - y0
     }))
   } : effect;
   const out = applyImageEffect(region, w, h, local);
-  return out ? { rgba: out, x: ox, y: oy, width: w, height: h, pad } : null;
+  return out ? result(out) : null;
 }
 
 // src/emf-plus-draw-image.ts
@@ -24544,11 +24660,10 @@ function effectedDraw(img, bitmap, effect, draw, source) {
   if (!rect) {
     return { bitmap: out, draw };
   }
-  const grow = region.pad;
-  const srcX = rect.srcX - grow - region.x;
-  const srcY = rect.srcY - grow - region.y;
-  const srcW = rect.srcW + 2 * grow;
-  const srcH = rect.srcH + 2 * grow;
+  const srcX = rect.srcX - region.x;
+  const srcY = rect.srcY - region.y;
+  const srcW = rect.srcW;
+  const srcH = rect.srcH;
   const shift = [1, 0, 0, 1, region.x, region.y];
   const toWorld = mulMatrix(rect.toWorld(rect.srcX, rect.srcY, rect.srcW, rect.srcH), shift);
   return {

package/dist/index.mjs

@@ -12317,7 +12317,7 @@ function blendSeparable(rgba, width, box, iu0, wu, iv0, wv, verticalFirst, edge
 }
 var OUTSIDE_TRANSPARENT = -1;
 var OUTSIDE_CLAMP = -2;
-function wrapTap(t, lo, hi, mirror, edge) {
+function wrapTap(t, lo, hi, mirror2, edge) {
   if (t >= lo && t < hi) {
     return t;
   }
@@ -12328,7 +12328,7 @@ function wrapTap(t, lo, hi, mirror, edge) {
     return OUTSIDE_CLAMP;
   }
   const n = hi - lo;
-  if (!mirror) {
+  if (!mirror2) {
     return lo + ((t - lo) % n + n) % n;
   }
   const q = ((t - lo) % (2 * n) + 2 * n) % (2 * n);
@@ -17628,9 +17628,9 @@ function buildPattern(ctx, rect, tw, th, wrap, brush, delta, sampling, colorAt)
   if (typeof ctx.createPattern !== "function") {
     return null;
   }
-  const mirror = wrap === "clamp" ? { x: false, y: false } : mirrorFlags(wrap);
-  const w = tw * (mirror.x ? 2 : 1);
-  const h = th * (mirror.y ? 2 : 1);
+  const mirror2 = wrap === "clamp" ? { x: false, y: false } : mirrorFlags(wrap);
+  const w = tw * (mirror2.x ? 2 : 1);
+  const h = th * (mirror2.y ? 2 : 1);
   const temp = createTempCanvas(w, h);
   if (!temp) {
     return null;
@@ -18052,8 +18052,8 @@ function createHatchPattern(ctx, hatch, origin, user, deviceToCanvas) {
 }
 
 // src/emf-plus-brush-texture.ts
-function wrapTexel(i, n, mirror) {
-  if (!mirror) {
+function wrapTexel(i, n, mirror2) {
+  if (!mirror2) {
     return (i % n + n) % n;
   }
   const p = (i % (2 * n) + 2 * n) % (2 * n);
@@ -19114,11 +19114,11 @@ function boundaryBox2(points) {
   }
   return x1 > x0 && y1 > y0 ? { x: x0, y: y0, w: x1 - x0, h: y1 - y0 } : null;
 }
-function foldIntoTile(v, origin, size, mirror, lag) {
+function foldIntoTile(v, origin, size, mirror2, lag) {
   const rel = v - origin;
   const k = Math.floor(rel / size);
   const local = rel - k * size;
-  if (mirror && (k % 2 + 2) % 2 === 1) {
+  if (mirror2 && (k % 2 + 2) % 2 === 1) {
     return origin + size - lag - local;
   }
   return origin + local;
@@ -23972,6 +23972,7 @@ function readGuid(view, off) {
   ].join("-");
 }
 var clamp = (v, lo, hi) => v < lo ? lo : v > hi ? hi : v;
+var COLOR_CURVE_PARAMS_SIZE = 12;
 function parseSerializableObject(view, dataOff, dataSize) {
   if (dataSize < 20) {
     return null;
@@ -23996,7 +23997,7 @@ function parseSerializableObject(view, dataOff, dataSize) {
     case "colorBalance":
       return need(12) ? { kind, cyanRed: i32(0, -100, 100), magentaGreen: i32(1, -100, 100), yellowBlue: i32(2, -100, 100) } : null;
     case "colorCurve":
-      return need(12) ? {
+      return need(COLOR_CURVE_PARAMS_SIZE) ? {
         kind,
         adjustment: view.getInt32(p, true),
         channel: view.getInt32(p + 4, true),
@@ -24050,66 +24051,101 @@ function parseSerializableObject(view, dataOff, dataSize) {
       return need(8) ? { kind, hue: i32(0, -180, 180), amount: i32(1, -100, 100) } : null;
   }
 }
-function buildLut(f) {
+var roundHalfDown = (v) => Math.ceil(v - 0.5);
+function buildLut(f, round = Math.round) {
   const lut = new Uint8Array(256);
   for (let v = 0; v < 256; v++) {
-    lut[v] = clamp(Math.round(f(v)), 0, 255);
+    lut[v] = clamp(round(f(v)), 0, 255);
   }
   return lut;
 }
-function contrastCurve(c) {
-  const gain = c >= 100 ? 1e6 : c >= 0 ? 100 / (100 - c) : (100 + c) / 100;
-  return (v) => (v - 127.5) * gain + 127.5;
-}
-function balanceCurve(t) {
-  const f = t / 100;
-  return (v) => f >= 0 ? v + (255 - v) * f : v * (1 + f);
-}
-function midtoneCurve(t) {
-  const gamma = 2 ** (-t / 100);
-  return (v) => 255 * (v / 255) ** gamma;
+function midtoneGamma(t) {
+  return t >= 0 ? 1 / (1 + t / 50) : 1 - t / 50;
+}
+function brightnessContrastLut(brightness, contrast) {
+  const gain = contrast >= 100 ? 1e6 : contrast >= 0 ? 100 / (100 - contrast) : (100 + contrast) / 100;
+  const half = brightness / 2;
+  return buildLut((v) => (v + half - 127.5) * gain + 127.5 + half);
+}
+function balanceLut(t) {
+  return buildLut((v) => v * (1 + t / 100));
+}
+function splineLut(ys) {
+  const n = ys.length;
+  const h = 255 / (n - 1);
+  const m = new Float64Array(n);
+  const c = new Float64Array(n);
+  const d = new Float64Array(n);
+  for (let i = 1; i < n - 1; i++) {
+    const rhs = 6 * (ys[i + 1] - 2 * ys[i] + ys[i - 1]) / (h * h);
+    const den = 4 - c[i - 1];
+    c[i] = 1 / den;
+    d[i] = (rhs - d[i - 1]) / den;
+  }
+  for (let i = n - 2; i >= 1; i--) {
+    m[i] = d[i] - c[i] * m[i + 1];
+  }
+  return buildLut((v) => {
+    const i = Math.min(n - 2, Math.floor(v / h));
+    const b = (v - i * h) / h;
+    const a = 1 - b;
+    return a * ys[i] + b * ys[i + 1] + ((a * a * a - a) * m[i] + (b * b * b - b) * m[i + 1]) * h * h / 6;
+  });
 }
+var CURVE_POINTS = 23;
+var CURVE_X = Array.from({ length: CURVE_POINTS }, (_, k) => k * 255 / (CURVE_POINTS - 1));
+var CURVE_TABLES = {
+  "contrast+": [0, 3.8, 8, 12.2, 17.4, 23.5, 31.1, 40.2, 53, 70.2, 94.5, 127.5, 160.5, 184.8, 202, 214.8, 223.9, 231.5, 237.6, 242.8, 247, 251.2, 255],
+  "contrast-": [0, 33.1, 57.2, 74.7, 87.2, 96.6, 103.9, 109.8, 115.3, 119.6, 123.7, 127.5, 131.3, 135.4, 139.7, 145.2, 151.1, 158.4, 167.8, 180.3, 197.8, 221.9, 255],
+  "highlight+": [0, 11.6, 23.2, 34.8, 46.4, 58, 69.6, 81.1, 92.7, 104.3, 116, 127.6, 142.3, 160.6, 186.4, 208, 220.6, 229.4, 236.2, 242, 246.6, 251, 255],
+  "highlight-": [0, 11.6, 23.2, 34.8, 46.4, 58, 69.5, 81.1, 92.7, 104.4, 115.9, 127.5, 136.7, 144.9, 151.4, 157.1, 161.8, 167.2, 174.3, 185.3, 200.9, 223.7, 255],
+  "shadow+": [0, 31.3, 54, 70, 82.5, 92.3, 99.5, 104.8, 109.5, 115, 121.3, 127.7, 139.2, 150.6, 162.3, 173.8, 185.5, 197, 208.6, 220.2, 231.8, 243.4, 255],
+  "shadow-": [0, 4, 8.4, 13, 18.7, 25.7, 34.4, 45, 58.4, 80, 105.8, 127.5, 139.2, 150.7, 162.3, 173.9, 185.4, 197, 208.6, 220.2, 231.8, 243.4, 255]
+};
 function curveAdjustmentLut(adjustment, intensity) {
   const t = intensity;
+  let ys;
   switch (adjustment) {
     case CurveAdjustment.Exposure:
-      return buildLut((v) => v * (1 + t / 255));
+      ys = CURVE_X.map((x) => roundHalfDown(x) + t);
+      break;
     case CurveAdjustment.Density:
-      return buildLut((v) => v * (1 - t / 255));
+      ys = CURVE_X.map((x) => x + t);
+      break;
     case CurveAdjustment.Contrast:
-      return buildLut(contrastCurve(clamp(t, -100, 100)));
     case CurveAdjustment.Highlight:
     case CurveAdjustment.Shadow: {
-      const high = adjustment === CurveAdjustment.Highlight;
-      const amp = clamp(t, -100, 100) * 0.32;
-      return buildLut((v) => {
-        const inside = high ? v > 128 : v < 128;
-        if (!inside) {
-          return v;
-        }
-        const u = high ? (v - 128) / 127 : v / 128;
-        return v + amp * Math.sin(Math.PI * u);
-      });
+      const c = clamp(t, -100, 100);
+      const name = ["contrast", "highlight", "shadow"][adjustment - CurveAdjustment.Contrast] + (c >= 0 ? "+" : "-");
+      const table = CURVE_TABLES[name];
+      ys = CURVE_X.map((x, k) => x + Math.abs(c) / 50 * (table[k] - x));
+      break;
+    }
+    case CurveAdjustment.Midtone: {
+      const g = midtoneGamma(clamp(t, -100, 100));
+      ys = CURVE_X.map((x) => 255 * (x / 255) ** g);
+      break;
     }
-    case CurveAdjustment.Midtone:
-      return buildLut(midtoneCurve(clamp(t, -100, 100)));
     case CurveAdjustment.WhiteSaturation: {
       const w = Math.max(1, clamp(t, 0, 255));
-      return buildLut((v) => v * 255 / w);
+      ys = CURVE_X.map((x) => x * 255 / w);
+      break;
     }
     case CurveAdjustment.BlackSaturation: {
       const b = Math.min(254, clamp(t, 0, 255));
-      return buildLut((v) => (v - b) * 255 / (255 - b));
+      ys = CURVE_X.map((x) => (x - b) * 255 / (255 - b));
+      break;
     }
     default:
       return null;
   }
+  return splineLut(ys.map((y) => clamp(y, 0, 255)));
 }
 function levelsLut(highlight, midtone, shadow) {
   const black = shadow / 100 * 255;
   const white = Math.max(black + 1, highlight / 100 * 255);
-  const gamma = midtoneCurve(midtone);
-  return buildLut((v) => gamma(clamp((v - black) / (white - black), 0, 1) * 255));
+  const gamma = midtoneGamma(midtone);
+  return buildLut((v) => 255 * clamp((v - black) / (white - black), 0, 1) ** gamma, roundHalfDown);
 }
 function applyLuts(src, r, g, b, a = null) {
   const out = new Uint8ClampedArray(src);
@@ -24135,26 +24171,6 @@ function applyColorMatrix(src, m) {
   }
   return out;
 }
-function rgbToHsl(r, g, b) {
-  const max = Math.max(r, g, b);
-  const min = Math.min(r, g, b);
-  const l = (max + min) / 2;
-  const d = max - min;
-  if (d === 0) {
-    return [0, 0, l];
-  }
-  const s = d / (1 - Math.abs(2 * l - 1));
-  let h;
-  if (max === r) {
-    h = (g - b) / d % 6;
-  } else if (max === g) {
-    h = (b - r) / d + 2;
-  } else {
-    h = (r - g) / d + 4;
-  }
-  h *= 60;
-  return [h < 0 ? h + 360 : h, s, l];
-}
 function hslToRgb(h, s, l) {
   const c = (1 - Math.abs(2 * l - 1)) * s;
   const hp = (h % 360 + 360) % 360 / 60;
@@ -24163,29 +24179,80 @@ function hslToRgb(h, s, l) {
   const [r, g, b] = hp < 1 ? [c, x, 0] : hp < 2 ? [x, c, 0] : hp < 3 ? [0, c, x] : hp < 4 ? [0, x, c] : hp < 5 ? [x, 0, c] : [c, 0, x];
   return [r + m, g + m, b + m];
 }
+var HUE_SEXTANT = 43;
+var HUE_CIRCLE = 6 * HUE_SEXTANT;
+function gdipHue(r, g, b) {
+  const max = Math.max(r, g, b);
+  const d = max - Math.min(r, g, b);
+  const f = (x) => Math.floor(x * HUE_SEXTANT / d);
+  if (max === r && g >= b) {
+    return f(g - b);
+  }
+  if (max === g) {
+    return b >= r ? 87 + f(b - r) : 86 - f(r - b);
+  }
+  if (max === b && b !== r) {
+    return r >= g ? 172 + f(r - g) : 171 - f(g - r);
+  }
+  const t = f(b - g);
+  return (256 - t - (t >= 40 ? 1 : 0)) % 256;
+}
 function applyHueSaturationLightness(src, hue, saturation, lightness2) {
   const out = new Uint8ClampedArray(src);
-  const push = (v, t) => t >= 0 ? v + (1 - v) * (t / 100) : v * (1 + t / 100);
+  const shift = Math.round(hue * HUE_CIRCLE / 360);
+  const sMul = 1 + saturation / 100;
   for (let i = 0; i < src.length; i += 4) {
-    const [h, s, l] = rgbToHsl(src[i] / 255, src[i + 1] / 255, src[i + 2] / 255);
-    const [r, g, b] = hslToRgb(h + hue, push(s, saturation), push(l, lightness2));
-    out[i] = Math.round(r * 255);
-    out[i + 1] = Math.round(g * 255);
-    out[i + 2] = Math.round(b * 255);
+    const r = src[i];
+    const g = src[i + 1];
+    const b = src[i + 2];
+    const max = Math.max(r, g, b);
+    const min = Math.min(r, g, b);
+    const l = clamp(Math.round(((max + min >> 1) * 100 + 255 * lightness2) / 100), 0, 255);
+    if (max === min) {
+      out[i] = out[i + 1] = out[i + 2] = l;
+      continue;
+    }
+    const sum = max + min;
+    const s = clamp((max - min) / (sum <= 255 ? sum : 510 - sum) * sMul, 0, 1);
+    const hi = l <= 127 ? l * (1 + s) : l + s * (255 - l);
+    const m1 = l <= 127 ? 2 * l - Math.trunc(hi) : Math.round(2 * l - hi);
+    const m2 = 2 * l - m1;
+    const q = ((gdipHue(r, g, b) + shift) % HUE_CIRCLE + HUE_CIRCLE) % HUE_CIRCLE;
+    const sextant = Math.min(5, Math.floor(q / HUE_SEXTANT));
+    const f = (q - sextant * HUE_SEXTANT) / HUE_SEXTANT;
+    const up = Math.trunc(m1 + (m2 - m1) * f);
+    const down = Math.trunc(m1 + (m2 - m1) * (1 - f));
+    const [nr, ng, nb] = [
+      [m2, up, m1],
+      [down, m2, m1],
+      [m1, m2, up],
+      [m1, down, m2],
+      [up, m1, m2],
+      [m2, m1, down]
+    ][sextant];
+    out[i] = nr;
+    out[i + 1] = ng;
+    out[i + 2] = nb;
   }
   return out;
 }
-var LUMA = [0.299, 0.587, 0.114];
+var LUMA_709 = [0.2126, 0.7152, 0.0722];
+var TINT_CHROMA_SCALE = 0.985;
 function applyTint(src, hue, amount) {
   const tint = hslToRgb(hue, 1, 0.5);
-  const y = tint[0] * LUMA[0] + tint[1] * LUMA[1] + tint[2] * LUMA[2];
-  const k = amount / 100 * 255;
-  const add = tint.map((c) => (c - y) * k);
+  const ty = tint[0] * LUMA_709[0] + tint[1] * LUMA_709[1] + tint[2] * LUMA_709[2];
+  const chroma = tint.map((c) => (c - ty) * TINT_CHROMA_SCALE);
+  const a = amount / 100;
   const out = new Uint8ClampedArray(src);
   for (let i = 0; i < src.length; i += 4) {
-    out[i] = Math.round(src[i] + add[0]);
-    out[i + 1] = Math.round(src[i + 1] + add[1]);
-    out[i + 2] = Math.round(src[i + 2] + add[2]);
+    const r = src[i];
+    const g = src[i + 1];
+    const b = src[i + 2];
+    const y = r * LUMA_709[0] + g * LUMA_709[1] + b * LUMA_709[2];
+    const v = Math.max(r, g, b);
+    out[i] = Math.round((1 - a) * r + a * (y + v * chroma[0]));
+    out[i + 1] = Math.round((1 - a) * g + a * (y + v * chroma[1]));
+    out[i + 2] = Math.round((1 - a) * b + a * (y + v * chroma[2]));
   }
   return out;
 }
@@ -24202,7 +24269,7 @@ function applyRedEyeCorrection(src, width, height, areas) {
         const r = out[i];
         const g = out[i + 1];
         const b = out[i + 2];
-        if (r > g && r > b) {
+        if (r >= 2 * g && r >= 2 * b && r > 64) {
           out[i] = Math.round((g + b) / 2);
         }
       }
@@ -24210,83 +24277,96 @@ function applyRedEyeCorrection(src, width, height, areas) {
   }
   return out;
 }
-function boxRadiiForSigma(sigma) {
-  const target = sigma * sigma;
-  let k = 0;
-  while ((k + 1) * (k + 2) <= target) {
-    k++;
+function blurKernel(radius) {
+  const taps = Math.ceil(radius);
+  const k = new Float64Array(2 * taps + 1);
+  if (taps === 0) {
+    k[0] = 1;
+    return k;
   }
-  const v = (n) => n * (n + 1) / 3;
-  let best = 0;
-  for (let m = 1; m <= 3; m++) {
-    if (Math.abs((3 - m) * v(k) + m * v(k + 1) - target) < Math.abs((3 - best) * v(k) + best * v(k + 1) - target)) {
-      best = m;
-    }
-  }
-  return [0, 1, 2].map((i) => i < best ? k + 1 : k);
-}
-function boxPass(src, w, h, r, horizontal) {
-  if (r <= 0) {
-    return src;
-  }
-  const out = new Float64Array(src.length);
-  const lines = horizontal ? h : w;
-  const len = horizontal ? w : h;
-  const step = horizontal ? 4 : w * 4;
-  const norm = 1 / (2 * r + 1);
-  for (let line = 0; line < lines; line++) {
-    const base = horizontal ? line * w * 4 : line * 4;
-    for (let c = 0; c < 4; c++) {
-      const at = (p) => src[base + clamp(p, 0, len - 1) * step + c];
-      let sum = 0;
-      for (let p = -r; p <= r; p++) {
-        sum += at(p);
-      }
-      for (let p = 0; p < len; p++) {
-        out[base + p * step + c] = sum * norm;
-        sum += at(p + r + 1) - at(p - r);
-      }
-    }
+  const sigma = radius / 1.98;
+  let sum = 0;
+  for (let i = -taps; i <= taps; i++) {
+    const w = Math.exp(-(i * i) / (2 * sigma * sigma));
+    k[i + taps] = w;
+    sum += w;
   }
-  return out;
+  for (let i = 0; i < k.length; i++) {
+    k[i] /= sum;
+  }
+  return k;
 }
-function blurFloat(src, w, h, radius) {
-  let buf = new Float64Array(src.length);
-  for (let i = 0; i < src.length; i += 4) {
-    const a = src[i + 3] / 255;
-    buf[i] = src[i] * a;
-    buf[i + 1] = src[i + 1] * a;
-    buf[i + 2] = src[i + 2] * a;
-    buf[i + 3] = src[i + 3];
+function mirror(p, n) {
+  if (n === 1) {
+    return 0;
   }
-  for (const r of boxRadiiForSigma(radius / 2)) {
-    buf = boxPass(buf, w, h, r, true);
-    buf = boxPass(buf, w, h, r, false);
+  while (p < 0 || p >= n) {
+    p = p < 0 ? -p : 2 * (n - 1) - p;
   }
-  for (let i = 0; i < buf.length; i += 4) {
-    const a = buf[i + 3] / 255;
-    for (let c = 0; c < 3; c++) {
-      buf[i + c] = a > 0 ? buf[i + c] / a : 0;
+  return p;
+}
+function gdipBlur(src, w, h, radius, vRow = 0, vZeroAbove = false) {
+  const k = blurKernel(radius);
+  const taps = (k.length - 1) / 2;
+  const out = new Float64Array(w * h * 4);
+  for (let y = 0; y < h; y++) {
+    const row = y * w * 4;
+    for (let x = 0; x < w; x++) {
+      let s0 = 0;
+      let s1 = 0;
+      let s2 = 0;
+      let s3 = 0;
+      for (let j = -taps; j <= taps; j++) {
+        const p = row + mirror(x + j, w) * 4;
+        const kw = k[j + taps];
+        s0 += kw * src[p];
+        s1 += kw * src[p + 1];
+        s2 += kw * src[p + 2];
+        s3 += kw * src[p + 3];
+      }
+      const o = row + x * 4;
+      out[o] = s0;
+      out[o + 1] = s1;
+      out[o + 2] = s2;
+      out[o + 3] = s3;
+    }
+  }
+  if (taps > 0 && vRow >= 0 && vRow < h) {
+    const col = new Float64Array(w * 4);
+    for (let j = -taps; j <= taps; j++) {
+      const yy = vRow + j;
+      if (vZeroAbove && yy < vRow) {
+        continue;
+      }
+      const base = mirror(yy, h) * w * 4;
+      for (let i = 0; i < w * 4; i++) {
+        col[i] += k[j + taps] * out[base + i];
+      }
     }
+    out.set(col, vRow * w * 4);
   }
-  return buf;
+  return out;
 }
 function applyBlur(src, w, h, radius) {
-  const blurred = blurFloat(src, w, h, radius);
-  const out = new Uint8ClampedArray(src.length);
-  for (let i = 0; i < src.length; i++) {
-    out[i] = Math.round(blurred[i]);
+  return Uint8ClampedArray.from(gdipBlur(src, w, h, radius), Math.round);
+}
+var SHARPEN_FALLOFF = Math.log2(96 / 25);
+function sharpenGain(radius, amount) {
+  const x = amount / 100;
+  if (radius <= 3) {
+    return x * 2 * radius / 3;
   }
-  return out;
+  return x * 2 * (3 / radius) ** SHARPEN_FALLOFF;
 }
 function applySharpen(src, w, h, radius, amount) {
-  const blurred = blurFloat(src, w, h, radius);
-  const k = amount / 100;
+  const blurred = gdipBlur(src, w, h, radius);
+  const gain = sharpenGain(radius, amount);
   const out = new Uint8ClampedArray(src);
   for (let i = 0; i < src.length; i += 4) {
     for (let c = 0; c < 3; c++) {
-      out[i + c] = Math.round(src[i + c] + k * (src[i + c] - blurred[i + c]));
+      out[i + c] = Math.round(src[i + c] + gain * (src[i + c] - Math.round(blurred[i + c])));
     }
+    out[i + 3] = Math.max(src[i + 3], out[i], out[i + 1], out[i + 2]);
   }
   return out;
 }
@@ -24300,16 +24380,15 @@ function applyImageEffect(rgba, width, height, effect) {
     case "sharpen":
       return applySharpen(rgba, width, height, effect.radius, effect.amount);
     case "brightnessContrast": {
-      const contrast = contrastCurve(effect.contrast);
-      const lut = buildLut((v) => contrast(v) + effect.brightness);
+      const lut = brightnessContrastLut(effect.brightness, effect.contrast);
       return applyLuts(rgba, lut, lut, lut);
     }
     case "colorBalance":
       return applyLuts(
         rgba,
-        buildLut(balanceCurve(effect.cyanRed)),
-        buildLut(balanceCurve(effect.magentaGreen)),
-        buildLut(balanceCurve(effect.yellowBlue))
+        balanceLut(effect.cyanRed),
+        balanceLut(effect.magentaGreen),
+        balanceLut(effect.yellowBlue)
       );
     case "colorCurve": {
       const lut = curveAdjustmentLut(effect.adjustment, effect.intensity);
@@ -24336,6 +24415,38 @@ function applyImageEffect(rgba, width, height, effect) {
       return applyTint(rgba, effect.hue, effect.amount);
   }
 }
+function copyBlock(src, width, sx, sy, w, h, dst, bw, dx, dy) {
+  for (let y = 0; y < h; y++) {
+    const from = ((sy + y) * width + sx) * 4;
+    dst.set(src.subarray(from, from + w * 4), ((dy + y) * bw + dx) * 4);
+  }
+}
+function expandedBlur(rgba, width, height, radius, x0, y0, x1, y1) {
+  const r = Math.ceil(radius);
+  const bw = x1 - x0 + 2 * r;
+  const bh = y1 - y0 + 2 * r;
+  const buf = new Uint8ClampedArray(bw * bh * 4);
+  const inside = x0 - r >= 0 && y0 - r >= 0 && x1 + r <= width && y1 + r <= height;
+  if (inside) {
+    copyBlock(rgba, width, x0, y0, x1 - x0, y1 - y0, buf, bw, r, r);
+  } else {
+    const gx0 = Math.max(0, x0 - r);
+    const gy0 = Math.max(0, y0 - r);
+    const gx1 = Math.min(width, x1 + r);
+    const gy1 = Math.min(height, y1 + r);
+    copyBlock(rgba, width, gx0, gy0, gx1 - gx0, gy1 - gy0, buf, bw, gx0 - (x0 - r), gy0 - (y0 - r));
+  }
+  const blurred = gdipBlur(buf, bw, bh, radius, inside ? r : 0, inside);
+  const w = x1 - x0;
+  const out = new Uint8ClampedArray(w * (y1 - y0) * 4);
+  for (let y = 0; y < y1 - y0; y++) {
+    const from = ((y + r) * bw + r) * 4;
+    for (let i = 0; i < w * 4; i++) {
+      out[y * w * 4 + i] = Math.round(blurred[from + i]);
+    }
+  }
+  return out;
+}
 function applyImageEffectToRect(rgba, width, height, effect, src) {
   if (width <= 0 || height <= 0 || rgba.length !== width * height * 4) {
     return null;
@@ -24347,38 +24458,43 @@ function applyImageEffectToRect(rgba, width, height, effect, src) {
   if (src) {
     x0 = clamp(Math.floor(src.x), 0, width);
     y0 = clamp(Math.floor(src.y), 0, height);
-    x1 = clamp(Math.ceil(src.x + src.w), 0, width);
-    y1 = clamp(Math.ceil(src.y + src.h), 0, height);
-    if (x1 <= x0 || y1 <= y0) {
+    x1 = clamp(Math.ceil(src.x + src.w) + 1, 0, width);
+    y1 = clamp(Math.ceil(src.y + src.h) + 1, 0, height);
+    if (x1 <= x0 || y1 <= y0 || src.x + src.w <= x0 || src.y + src.h <= y0) {
       return null;
     }
   }
-  const pad = src && effect.kind === "blur" && effect.expandEdge ? Math.ceil(effect.radius) : 0;
-  const cw = x1 - x0;
-  const ch = y1 - y0;
-  const w = cw + 2 * pad;
-  const h = ch + 2 * pad;
+  const w = x1 - x0;
+  const h = y1 - y0;
+  const shownWidth = src ? Math.min(w, Math.ceil(src.x + src.w) - x0) : w;
+  const shownHeight = src ? Math.min(h, Math.ceil(src.y + src.h) - y0) : h;
+  const result = (out2) => {
+    if (shownWidth === w && shownHeight === h) {
+      return { rgba: out2, x: x0, y: y0, width: w, height: h };
+    }
+    const shown = new Uint8ClampedArray(shownWidth * shownHeight * 4);
+    copyBlock(out2, w, 0, 0, shownWidth, shownHeight, shown, shownWidth, 0, 0);
+    return { rgba: shown, x: x0, y: y0, width: shownWidth, height: shownHeight };
+  };
+  if (src && effect.kind === "blur" && effect.expandEdge) {
+    return result(expandedBlur(rgba, width, height, effect.radius, x0, y0, x1, y1));
+  }
   let region = rgba;
-  if (w !== width || h !== height || x0 !== 0 || y0 !== 0) {
+  if (w !== width || h !== height) {
     region = new Uint8ClampedArray(w * h * 4);
-    for (let y = 0; y < ch; y++) {
-      const from = ((y0 + y) * width + x0) * 4;
-      region.set(rgba.subarray(from, from + cw * 4), ((pad + y) * w + pad) * 4);
-    }
+    copyBlock(rgba, width, x0, y0, w, h, region, w, 0, 0);
   }
-  const ox = x0 - pad;
-  const oy = y0 - pad;
   const local = effect.kind === "redEyeCorrection" ? {
     kind: effect.kind,
     areas: effect.areas.map((a) => ({
-      left: a.left - ox,
-      top: a.top - oy,
-      right: a.right - ox,
-      bottom: a.bottom - oy
+      left: a.left - x0,
+      top: a.top - y0,
+      right: a.right - x0,
+      bottom: a.bottom - y0
     }))
   } : effect;
   const out = applyImageEffect(region, w, h, local);
-  return out ? { rgba: out, x: ox, y: oy, width: w, height: h, pad } : null;
+  return out ? result(out) : null;
 }
 
 // src/emf-plus-draw-image.ts
@@ -24542,11 +24658,10 @@ function effectedDraw(img, bitmap, effect, draw, source) {
   if (!rect) {
     return { bitmap: out, draw };
   }
-  const grow = region.pad;
-  const srcX = rect.srcX - grow - region.x;
-  const srcY = rect.srcY - grow - region.y;
-  const srcW = rect.srcW + 2 * grow;
-  const srcH = rect.srcH + 2 * grow;
+  const srcX = rect.srcX - region.x;
+  const srcY = rect.srcY - region.y;
+  const srcW = rect.srcW;
+  const srcH = rect.srcH;
   const shift = [1, 0, 0, 1, region.x, region.y];
   const toWorld = mulMatrix(rect.toWorld(rect.srcX, rect.srcY, rect.srcW, rect.srcH), shift);
   return {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "emf-converter",
-	"version": "4.3.4",
+	"version": "4.3.5",
 	"description": "Convert EMF/WMF metafile binaries to PNG data URLs or SVG (markup, data URL, React/JSX)",
 	"keywords": [
 		"canvas",