emf-converter 4.2.0 → 4.3.0

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.
 
-- **Colour adjustment and image effects**: `EMR_SETCOLORADJUSTMENT` is read but not yet applied, and the `HALFTONE` stretch mode is not bit-exact. 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. A blur with `expandEdge` keeps the image's size instead of growing it, and an effect is skipped when the image's pixels are not available (a PNG or JPEG in SVG output without an image decoder).
+- **Colour adjustment and image effects**: The `HALFTONE` stretch mode resamples with an area-averaging box filter. Integer enlargements match Windows exactly; reductions do not, because Windows' halftone engine uses a narrower kernel and its own colour mapping (1.05% of pixels differ on the fixture). `EMR_SETCOLORADJUSTMENT` is applied to the source of `HALFTONE` `StretchBlt` and `StretchDIBits` calls, as in GDI. Windows does not publish its adjustment formulas, so gamma, reference black/white, contrast, brightness, colourfulness, red-green tint, negative and log filter use documented approximations, and Windows' dithering of the adjusted colours is not reproduced (6.6% of pixels differ by more than 24 on the fixture). 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`).
 - **Pen transforms**: nonuniform and skewed EMF+ pen transforms are drawn with the transformed (elliptical or sheared) nib, but unlike uniform ones they are not yet verified against Windows output, and a singular pen transform is ignored.
 - **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

@@ -19177,7 +19177,7 @@ function paintBrushThroughMask(rCtx, sampler, box, drawCoverage, mode = "canvas"
   const device = plusWorldMatrix(rCtx);
   const m = mask.ctx;
   const shift = aliased ? aliasedSampleShift(rCtx) : geometry ? plusCanvasShift(rCtx) : 0;
-  m.setTransform(device[0], device[1], device[2], device[3], device[4] - box.x + shift + Number(process.env.HDX ?? 0), device[5] - box.y + shift + Number(process.env.HDY ?? 0));
+  m.setTransform(device[0], device[1], device[2], device[3], device[4] - box.x + shift, device[5] - box.y + shift);
   m.fillStyle = "#000";
   m.strokeStyle = "#000";
   drawCoverage(rasterMode !== "canvas" ? flatteningContext(m, device) : m);
@@ -19982,6 +19982,97 @@ function handleEmfGdiShapeRecord(rCtx, recType, dataOff, recSize) {
   }
 }
 
+// src/emf-gdi-color-adjust.ts
+var CA_NEGATIVE = 1;
+var CA_LOG_FILTER = 2;
+var COLOR_ADJUSTMENT_SIZE = 24;
+function readColorAdjustment(view, off) {
+  const ca = {
+    flags: view.getUint16(off + 2, true),
+    illuminant: view.getUint16(off + 4, true),
+    redGamma: view.getUint16(off + 6, true),
+    greenGamma: view.getUint16(off + 8, true),
+    blueGamma: view.getUint16(off + 10, true),
+    referenceBlack: view.getUint16(off + 12, true),
+    referenceWhite: view.getUint16(off + 14, true),
+    contrast: view.getInt16(off + 16, true),
+    brightness: view.getInt16(off + 18, true),
+    colorfulness: view.getInt16(off + 20, true),
+    redGreenTint: view.getInt16(off + 22, true)
+  };
+  const within = (v, lo, hi) => v >= lo && v <= hi;
+  const valid = (ca.flags & -4) === 0 && within(ca.illuminant, 0, 8) && within(ca.redGamma, 2500, 65e3) && within(ca.greenGamma, 2500, 65e3) && within(ca.blueGamma, 2500, 65e3) && within(ca.referenceBlack, 0, 4e3) && within(ca.referenceWhite, 6e3, 1e4) && within(ca.contrast, -100, 100) && within(ca.brightness, -100, 100) && within(ca.colorfulness, -100, 100) && within(ca.redGreenTint, -100, 100);
+  return valid ? ca : null;
+}
+function isIdentityColorAdjustment(ca) {
+  return !ca || ca.flags === 0 && ca.redGamma === 1e4 && ca.greenGamma === 1e4 && ca.blueGamma === 1e4 && ca.referenceBlack === 0 && ca.referenceWhite === 1e4 && ca.contrast === 0 && ca.brightness === 0 && ca.colorfulness === 0 && ca.redGreenTint === 0;
+}
+function colorfulnessScale(c) {
+  return c > 0 ? 1 + 2 * c / 100 : 1 + c / 100;
+}
+var clamp012 = (v) => v < 0 ? 0 : v > 1 ? 1 : v;
+function colorAdjustmentMapper(ca) {
+  const black = ca.referenceBlack / 1e4;
+  const span = Math.max(1e-6, ca.referenceWhite / 1e4 - black);
+  const gammas = [ca.redGamma / 1e4, ca.greenGamma / 1e4, ca.blueGamma / 1e4];
+  const curves = gammas.map((gamma) => {
+    const table = new Float64Array(256);
+    for (let i = 0; i < 256; i++) {
+      let v = clamp012((i / 255 - black) / span);
+      v = Math.pow(v, gamma);
+      table[i] = ca.flags & CA_NEGATIVE ? 1 - v : v;
+    }
+    return table;
+  });
+  const chroma = colorfulnessScale(ca.colorfulness);
+  const contrast = 1 + ca.contrast / 100;
+  const brightness = 0.8 * ca.brightness / 100;
+  const tint = 0.3 * ca.redGreenTint / 100;
+  const log = (ca.flags & CA_LOG_FILTER) !== 0;
+  const out = (v) => {
+    v = clamp012(v);
+    if (log) {
+      v = Math.log10(1 + 9 * v);
+    }
+    return Math.round(v * 255);
+  };
+  return (rgb2) => {
+    const r = curves[0][rgb2 >> 16 & 255];
+    const g = curves[1][rgb2 >> 8 & 255];
+    const b = curves[2][rgb2 & 255];
+    let y = 0.299 * r + 0.587 * g + 0.114 * b;
+    let cr = (r - y) * chroma;
+    const cb = (b - y) * chroma;
+    y = (y - 0.5) * contrast + 0.5 + brightness;
+    cr += tint;
+    const r2 = y + cr;
+    const b2 = y + cb;
+    const g2 = (y - 0.299 * r2 - 0.114 * b2) / 0.587;
+    return out(r2) << 16 | out(g2) << 8 | out(b2);
+  };
+}
+function applyColorAdjustment(pixels, ca) {
+  if (!ca || isIdentityColorAdjustment(ca)) {
+    return;
+  }
+  const map = colorAdjustmentMapper(ca);
+  const d = pixels.data;
+  const cache = /* @__PURE__ */ new Map();
+  for (let i = 0; i + 3 < d.length; i += 4) {
+    const rgb2 = d[i] << 16 | d[i + 1] << 8 | d[i + 2];
+    let v = cache.get(rgb2);
+    if (v === void 0) {
+      v = map(rgb2);
+      if (cache.size < 65536) {
+        cache.set(rgb2, v);
+      }
+    }
+    d[i] = v >> 16 & 255;
+    d[i + 1] = v >> 8 & 255;
+    d[i + 2] = v & 255;
+  }
+}
+
 // src/emf-gdi-stretch.ts
 var BLACKONWHITE = 1;
 var WHITEONBLACK = 2;
@@ -20054,6 +20145,66 @@ function stretchGdi(src, sx, sy, sw, sh, dw, dh, mode) {
   }
   return { width: W, height: H, data };
 }
+function axisBoxWeights(srcStart, srcLen, dstLen, reverse) {
+  const out = [];
+  if (dstLen <= 0 || srcLen <= 0) {
+    return out;
+  }
+  const at = (k) => reverse ? srcStart + srcLen - 1 - k : srcStart + k;
+  for (let i = 0; i < dstLen; i++) {
+    const a = i * srcLen;
+    const b = (i + 1) * srcLen;
+    const taps = [];
+    for (let k = Math.floor(a / dstLen); k * dstLen < b; k++) {
+      const overlap = Math.min(b, (k + 1) * dstLen) - Math.max(a, k * dstLen);
+      if (overlap > 0) {
+        taps.push([at(k), overlap / srcLen]);
+      }
+    }
+    out.push(taps);
+  }
+  return out;
+}
+function stretchHalftone(src, sx, sy, sw, sh, dw, dh) {
+  const W = Math.max(0, Math.round(Math.abs(dw)));
+  const H = Math.max(0, Math.round(Math.abs(dh)));
+  const flipX = dw < 0 !== sw < 0;
+  const flipY = dh < 0 !== sh < 0;
+  const cols = axisBoxWeights(Math.round(Math.min(sx, sx + sw)), Math.round(Math.abs(sw)), W, flipX);
+  const rows = axisBoxWeights(Math.round(Math.min(sy, sy + sh)), Math.round(Math.abs(sh)), H, flipY);
+  const data = new Uint8ClampedArray(W * H * 4);
+  const s = src.data;
+  for (let y = 0; y < H; y++) {
+    const ys = rows[y] ?? [];
+    for (let x = 0; x < W; x++) {
+      const xs = cols[x] ?? [];
+      let r = 0;
+      let g = 0;
+      let b = 0;
+      for (const [yy, wy] of ys) {
+        if (yy < 0 || yy >= src.height) {
+          continue;
+        }
+        for (const [xx, wx] of xs) {
+          if (xx < 0 || xx >= src.width) {
+            continue;
+          }
+          const w = wx * wy;
+          const i = (yy * src.width + xx) * 4;
+          r += s[i] * w;
+          g += s[i + 1] * w;
+          b += s[i + 2] * w;
+        }
+      }
+      const o = (y * W + x) * 4;
+      data[o] = Math.floor(r + 1e-6);
+      data[o + 1] = Math.floor(g + 1e-6);
+      data[o + 2] = Math.floor(b + 1e-6);
+      data[o + 3] = 255;
+    }
+  }
+  return { width: W, height: H, data };
+}
 
 // src/emf-gdi-draw-bitmap.ts
 function patternOperand(rCtx, brush) {
@@ -20077,46 +20228,18 @@ function patternOperand(rCtx, brush) {
 function drawSourceMapped(target, decoded, req, offsetX, offsetY, mode) {
   const dLeft = Math.min(req.dx, req.dx + req.dw) - offsetX;
   const dTop = Math.min(req.dy, req.dy + req.dh) - offsetY;
-  if (mode !== HALFTONE) {
-    const px = stretchGdi(decoded.pixels, req.sx, req.sy, req.sw, req.sh, req.dw, req.dh, mode);
-    const tile = createTempCanvas(px.width, px.height);
-    if (!tile) {
-      return;
-    }
-    canvasPutImageData(tile.ctx, createImageDataCompat(px.data, px.width, px.height), 0, 0);
-    target.save();
-    target.globalCompositeOperation = "source-over";
-    canvasDrawImage(target, tile.canvas, Math.round(dLeft), Math.round(dTop), px.width, px.height);
-    target.restore();
+  const px = mode === HALFTONE ? stretchHalftone(decoded.pixels, req.sx, req.sy, req.sw, req.sh, req.dw, req.dh) : stretchGdi(decoded.pixels, req.sx, req.sy, req.sw, req.sh, req.dw, req.dh, mode);
+  if (px.width === 0 || px.height === 0) {
     return;
   }
-  const flipX = req.dw < 0 !== req.sw < 0;
-  const flipY = req.dh < 0 !== req.sh < 0;
-  const adw = Math.abs(req.dw);
-  const adh = Math.abs(req.dh);
+  const tile = createTempCanvas(px.width, px.height);
+  if (!tile) {
+    return;
+  }
+  canvasPutImageData(tile.ctx, createImageDataCompat(px.data, px.width, px.height), 0, 0);
   target.save();
-  target.imageSmoothingEnabled = true;
-  target.transform(
-    flipX ? -1 : 1,
-    0,
-    0,
-    flipY ? -1 : 1,
-    flipX ? dLeft * 2 + adw : 0,
-    flipY ? dTop * 2 + adh : 0
-  );
-  const draw = target.drawImage;
-  draw.call(
-    target,
-    decoded.canvas,
-    Math.min(req.sx, req.sx + req.sw),
-    Math.min(req.sy, req.sy + req.sh),
-    Math.abs(req.sw),
-    Math.abs(req.sh),
-    dLeft,
-    dTop,
-    adw,
-    adh
-  );
+  target.globalCompositeOperation = "source-over";
+  canvasDrawImage(target, tile.canvas, Math.round(dLeft), Math.round(dTop), px.width, px.height);
   target.restore();
 }
 function decodeSource(rCtx, req) {
@@ -20133,17 +20256,15 @@ function decodeSource(rCtx, req) {
   if (!image) {
     return null;
   }
-  const temp = createTempCanvas(image.width, image.height);
-  if (!temp) {
-    return null;
+  if (req.stretch && rCtx.state.stretchBltMode === HALFTONE) {
+    applyColorAdjustment(image, rCtx.state.colorAdjustment);
   }
-  canvasPutImageData(temp.ctx, image, 0, 0);
   let { sy } = req;
   if (req.dibOrigin === "bottom-left" && rCtx.view.getInt32(req.source.bmi + 8, true) > 0) {
     sy = image.height - sy - req.sh;
   }
   return {
-    decoded: { pixels: image, canvas: temp.canvas },
+    decoded: { pixels: image },
     req: { ...req, sy }
   };
 }
@@ -20256,7 +20377,7 @@ function nudgedFloor(num, den, dx, dy) {
   const q = Math.floor(num / den);
   return num === q * den && nudgedSign(0, dx, dy) < 0 ? q - 1 : q;
 }
-function executeRotatedBlit(rCtx, logDx, logDy, logDw, logDh, rop, source, sx, sy, sw, sh, dibOrigin) {
+function executeRotatedBlit(rCtx, logDx, logDy, logDw, logDh, rop, source, sx, sy, sw, sh, dibOrigin, stretch) {
   const { ctx } = rCtx;
   const index = rop3Index(rop);
   if (index === 170) {
@@ -20292,7 +20413,8 @@ function executeRotatedBlit(rCtx, logDx, logDy, logDw, logDh, rop, source, sx, s
       sy,
       sw,
       sh,
-      dibOrigin
+      dibOrigin,
+      stretch
     });
     if (!decoded) {
       return;
@@ -20460,7 +20582,8 @@ function handleBlt(rCtx, offset, dataOff, recSize, stretch) {
       srcRect.sy,
       srcRect.sw,
       srcRect.sh,
-      "top-left"
+      "top-left",
+      stretch
     );
     return true;
   }
@@ -20472,7 +20595,8 @@ function handleBlt(rCtx, offset, dataOff, recSize, stretch) {
     dh: gmh(rCtx, cyDest),
     source,
     ...srcRect,
-    dibOrigin: "top-left"
+    dibOrigin: "top-left",
+    stretch
   });
   return true;
 }
@@ -20499,7 +20623,7 @@ function handleStretchDibits(rCtx, offset, dataOff, recSize) {
   const sw = view.getInt32(dataOff + 32, true);
   const sh = view.getInt32(dataOff + 36, true);
   if (hasWorldRotation(rCtx)) {
-    executeRotatedBlit(rCtx, xDest, yDest, cxDest, cyDest, rop, source, sx, sy, sw, sh, "bottom-left");
+    executeRotatedBlit(rCtx, xDest, yDest, cxDest, cyDest, rop, source, sx, sy, sw, sh, "bottom-left", true);
     return true;
   }
   executeBlit(rCtx, {
@@ -20513,7 +20637,8 @@ function handleStretchDibits(rCtx, offset, dataOff, recSize) {
     sy,
     sw,
     sh,
-    dibOrigin: "bottom-left"
+    dibOrigin: "bottom-left",
+    stretch: true
   });
   return true;
 }
@@ -23029,20 +23154,9 @@ function handleEmfGdiMiscRecord(rCtx, recType, dataOff, recSize) {
       return true;
     }
     case EMR_SETCOLORADJUSTMENT: {
-      if (recSize >= 32) {
-        state.colorAdjustment = {
-          flags: view.getUint16(dataOff + 2, true),
-          illuminant: view.getUint16(dataOff + 4, true),
-          redGamma: view.getUint16(dataOff + 6, true),
-          greenGamma: view.getUint16(dataOff + 8, true),
-          blueGamma: view.getUint16(dataOff + 10, true),
-          referenceBlack: view.getUint16(dataOff + 12, true),
-          referenceWhite: view.getUint16(dataOff + 14, true),
-          contrast: view.getInt16(dataOff + 16, true),
-          brightness: view.getInt16(dataOff + 18, true),
-          colorfulness: view.getInt16(dataOff + 20, true),
-          redGreenTint: view.getInt16(dataOff + 22, true)
-        };
+      const ca = recSize >= 8 + COLOR_ADJUSTMENT_SIZE ? readColorAdjustment(view, dataOff) : null;
+      if (ca) {
+        state.colorAdjustment = ca;
       }
       return true;
     }
@@ -23940,6 +24054,50 @@ function applyImageEffect(rgba, width, height, effect) {
       return applyTint(rgba, effect.hue, effect.amount);
   }
 }
+function applyImageEffectToRect(rgba, width, height, effect, src) {
+  if (width <= 0 || height <= 0 || rgba.length !== width * height * 4) {
+    return null;
+  }
+  let x0 = 0;
+  let y0 = 0;
+  let x1 = width;
+  let y1 = height;
+  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) {
+      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;
+  let region = rgba;
+  if (w !== width || h !== height || x0 !== 0 || y0 !== 0) {
+    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);
+    }
+  }
+  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
+    }))
+  } : effect;
+  const out = applyImageEffect(region, w, h, local);
+  return out ? { rgba: out, x: ox, y: oy, width: w, height: h, pad } : null;
+}
 
 // src/emf-plus-draw-image.ts
 function surfaceSize4(ctx) {
@@ -24076,7 +24234,7 @@ function drawNestedMetafile(rCtx, img, cached, source) {
   rCtx.deferredImages.push(...deferred);
   return true;
 }
-function effectedBitmap(img, bitmap, effect) {
+function effectedDraw(img, bitmap, effect, draw, source) {
   let src = bitmap;
   if (!src && img.data) {
     const bmp = decodeBmpFile(img.data.slice(0));
@@ -24087,21 +24245,61 @@ function effectedBitmap(img, bitmap, effect) {
   if (!src) {
     return null;
   }
-  const rgba = applyImageEffect(src.rgba, src.width, src.height, effect);
-  return rgba ? { kind: "bitmap", width: src.width, height: src.height, rgba } : null;
+  const rect = source && source.unit === UNIT_PIXEL && source.srcW > 0 && source.srcH > 0 && [source.srcX, source.srcY, source.srcW, source.srcH].every(Number.isFinite) ? source : null;
+  const region = applyImageEffectToRect(
+    src.rgba,
+    src.width,
+    src.height,
+    effect,
+    rect && { x: rect.srcX, y: rect.srcY, w: rect.srcW, h: rect.srcH }
+  );
+  if (!region) {
+    return null;
+  }
+  const out = { kind: "bitmap", width: region.width, height: region.height, rgba: region.rgba };
+  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 shift = [1, 0, 0, 1, region.x, region.y];
+  const toWorld = mulMatrix(rect.toWorld(rect.srcX, rect.srcY, rect.srcW, rect.srcH), shift);
+  return {
+    bitmap: out,
+    draw: {
+      ...draw,
+      // The Canvas fallback scales the whole effected bitmap.
+      transform: mulMatrix(draw.transform, toWorld),
+      dx: 0,
+      dy: 0,
+      dw: region.width,
+      dh: region.height,
+      resample: draw.resample && {
+        ...draw.resample,
+        srcX,
+        srcY,
+        srcW,
+        srcH,
+        toDevice: mulMatrix(draw.resample.toDevice, shift)
+      }
+    }
+  };
 }
 function drawEmfPlusImageNow(rCtx, img, draw, source, effect = null) {
   const cached = img.cacheKey !== void 0 ? rCtx.imageCache?.get(img.cacheKey) : void 0;
   if (img.type === 2) {
     return drawNestedMetafile(rCtx, img, cached, source);
   }
-  let bitmap = cached && cached.kind === "bitmap" ? cached : null;
-  const effected = effect ? effectedBitmap(img, bitmap, effect) : null;
+  const bitmap = cached && cached.kind === "bitmap" ? cached : null;
+  const effected = effect ? effectedDraw(img, bitmap, effect, draw, source) : null;
   if (effected) {
-    bitmap = effected;
+    return isSvgContext(rCtx.ctx) ? paintBitmapSvg(rCtx.ctx, img, effected.bitmap, effected.draw, true) : paintBitmapRaster(rCtx.ctx, effected.bitmap, effected.draw);
   }
   if (isSvgContext(rCtx.ctx)) {
-    return paintBitmapSvg(rCtx.ctx, img, bitmap, draw, effected !== null);
+    return paintBitmapSvg(rCtx.ctx, img, bitmap, draw);
   }
   return bitmap ? paintBitmapRaster(rCtx.ctx, bitmap, draw) : false;
 }
@@ -24393,28 +24591,32 @@ function strokePlusGeometry(rCtx, pen, buildPath, points, closedFigure = false)
       if (mode !== "canvas" && size && strokeGdiplus(rCtx, pen, nib, sampler, buildPath, device, size, mode, closedFigure)) {
         return;
       }
-      const miter = Math.max(1, ctx.miterLimit || 10);
-      const margin = pen.width * scale * miter / 2 + 2;
-      const box = size ? deviceBounds(points, device, size, margin) : null;
+      const outline = hasCustomCap(pen) ? penOutlineWorld(rCtx, pen, nib, buildPath, closedFigure) : null;
+      let box = null;
+      if (size && outline) {
+        box = deviceBounds(outline.flat(), device, size, 2);
+      } else if (size) {
+        const miter = Math.max(1, ctx.miterLimit || 10);
+        const margin = pen.width * scale * miter / 2 + 2;
+        box = deviceBounds(points, device, size, margin);
+      }
       if (size && !box) {
         return;
       }
-      if (box && paintBrushThroughMask(
-        rCtx,
-        sampler,
-        box,
-        (c) => {
-          applyPlusPenStyle(c, pen, widthScale);
-          stroke(c);
-          c.beginPath();
-          buildPath(c);
-          if (nib) {
-            c.transform(nib[0], nib[1], nib[2], nib[3], 0, 0);
-          }
-        },
-        mode,
-        (c, x, y) => c.isPointInStroke(x, y) && (!inset || c.isPointInPath(x, y))
-      )) {
+      const drawMask = outline ? (c) => {
+        traceOutline(c, outline);
+        c.fill("nonzero");
+      } : (c) => {
+        applyPlusPenStyle(c, pen, widthScale);
+        stroke(c);
+        c.beginPath();
+        buildPath(c);
+        if (nib) {
+          c.transform(nib[0], nib[1], nib[2], nib[3], 0, 0);
+        }
+      };
+      const hitTest = outline ? (c, x, y) => c.isPointInPath(x, y, "nonzero") : (c, x, y) => c.isPointInStroke(x, y) && (!inset || c.isPointInPath(x, y));
+      if (box && paintBrushThroughMask(rCtx, sampler, box, drawMask, mode, hitTest)) {
         return;
       }
     }
@@ -24579,18 +24781,18 @@ function customCapOutline(figures, width, devicePen, pen) {
   outline.push(...geo.polygons);
   return outline;
 }
-function fillPenOutline(rCtx, pen, nib, paint, buildPath, closedFigure) {
+function penOutlineWorld(rCtx, pen, nib, buildPath, closedFigure) {
   const device = plusWorldMatrix(rCtx);
   const frame2 = penFrame(device, nib);
   const deviceInv = invertAffine(device);
   if (!frame2 || !deviceInv || !(frame2.unit > 0)) {
-    return false;
+    return null;
   }
   let figures;
   try {
     figures = recordDeviceFigures(buildPath, frame2.record);
   } catch {
-    return false;
+    return null;
   }
   if (closedFigure) {
     figures = figures.map((f) => ({ ...f, closed: true }));
@@ -24598,25 +24800,33 @@ function fillPenOutline(rCtx, pen, nib, paint, buildPath, closedFigure) {
   const width = (pen.width || 1) * frame2.unit;
   const devicePen = framePen(pen, frame2.unit);
   const outline = hasCustomCap(pen) ? customCapOutline(figures, width, devicePen, pen) : widenFigures(figures, devicePen);
-  const toWorld = mulMatrix(deviceInv, frame2.toDevice);
+  const m = mulMatrix(deviceInv, frame2.toDevice);
+  return outline.map((poly) => poly.map((p) => ({ x: m[0] * p.x + m[2] * p.y + m[4], y: m[1] * p.x + m[3] * p.y + m[5] })));
+}
+function traceOutline(c, outline) {
+  c.beginPath();
+  for (const poly of outline) {
+    poly.forEach((p, i) => {
+      if (i === 0) {
+        c.moveTo(p.x, p.y);
+      } else {
+        c.lineTo(p.x, p.y);
+      }
+    });
+    c.closePath();
+  }
+}
+function fillPenOutline(rCtx, pen, nib, paint, buildPath, closedFigure) {
+  const outline = penOutlineWorld(rCtx, pen, nib, buildPath, closedFigure);
+  if (!outline) {
+    return false;
+  }
   const { ctx } = rCtx;
   ctx.save();
   try {
     ctx.fillStyle = paint;
     applyPlusWorldTransform(rCtx);
-    ctx.beginPath();
-    for (const poly of outline) {
-      poly.forEach((p, i) => {
-        const x = toWorld[0] * p.x + toWorld[2] * p.y + toWorld[4];
-        const y = toWorld[1] * p.x + toWorld[3] * p.y + toWorld[5];
-        if (i === 0) {
-          ctx.moveTo(x, y);
-        } else {
-          ctx.lineTo(x, y);
-        }
-      });
-      ctx.closePath();
-    }
+    traceOutline(ctx, outline);
     ctx.fill("nonzero");
   } finally {
     ctx.restore();

package/dist/index.mjs

@@ -19175,7 +19175,7 @@ function paintBrushThroughMask(rCtx, sampler, box, drawCoverage, mode = "canvas"
   const device = plusWorldMatrix(rCtx);
   const m = mask.ctx;
   const shift = aliased ? aliasedSampleShift(rCtx) : geometry ? plusCanvasShift(rCtx) : 0;
-  m.setTransform(device[0], device[1], device[2], device[3], device[4] - box.x + shift + Number(process.env.HDX ?? 0), device[5] - box.y + shift + Number(process.env.HDY ?? 0));
+  m.setTransform(device[0], device[1], device[2], device[3], device[4] - box.x + shift, device[5] - box.y + shift);
   m.fillStyle = "#000";
   m.strokeStyle = "#000";
   drawCoverage(rasterMode !== "canvas" ? flatteningContext(m, device) : m);
@@ -19980,6 +19980,97 @@ function handleEmfGdiShapeRecord(rCtx, recType, dataOff, recSize) {
   }
 }
 
+// src/emf-gdi-color-adjust.ts
+var CA_NEGATIVE = 1;
+var CA_LOG_FILTER = 2;
+var COLOR_ADJUSTMENT_SIZE = 24;
+function readColorAdjustment(view, off) {
+  const ca = {
+    flags: view.getUint16(off + 2, true),
+    illuminant: view.getUint16(off + 4, true),
+    redGamma: view.getUint16(off + 6, true),
+    greenGamma: view.getUint16(off + 8, true),
+    blueGamma: view.getUint16(off + 10, true),
+    referenceBlack: view.getUint16(off + 12, true),
+    referenceWhite: view.getUint16(off + 14, true),
+    contrast: view.getInt16(off + 16, true),
+    brightness: view.getInt16(off + 18, true),
+    colorfulness: view.getInt16(off + 20, true),
+    redGreenTint: view.getInt16(off + 22, true)
+  };
+  const within = (v, lo, hi) => v >= lo && v <= hi;
+  const valid = (ca.flags & -4) === 0 && within(ca.illuminant, 0, 8) && within(ca.redGamma, 2500, 65e3) && within(ca.greenGamma, 2500, 65e3) && within(ca.blueGamma, 2500, 65e3) && within(ca.referenceBlack, 0, 4e3) && within(ca.referenceWhite, 6e3, 1e4) && within(ca.contrast, -100, 100) && within(ca.brightness, -100, 100) && within(ca.colorfulness, -100, 100) && within(ca.redGreenTint, -100, 100);
+  return valid ? ca : null;
+}
+function isIdentityColorAdjustment(ca) {
+  return !ca || ca.flags === 0 && ca.redGamma === 1e4 && ca.greenGamma === 1e4 && ca.blueGamma === 1e4 && ca.referenceBlack === 0 && ca.referenceWhite === 1e4 && ca.contrast === 0 && ca.brightness === 0 && ca.colorfulness === 0 && ca.redGreenTint === 0;
+}
+function colorfulnessScale(c) {
+  return c > 0 ? 1 + 2 * c / 100 : 1 + c / 100;
+}
+var clamp012 = (v) => v < 0 ? 0 : v > 1 ? 1 : v;
+function colorAdjustmentMapper(ca) {
+  const black = ca.referenceBlack / 1e4;
+  const span = Math.max(1e-6, ca.referenceWhite / 1e4 - black);
+  const gammas = [ca.redGamma / 1e4, ca.greenGamma / 1e4, ca.blueGamma / 1e4];
+  const curves = gammas.map((gamma) => {
+    const table = new Float64Array(256);
+    for (let i = 0; i < 256; i++) {
+      let v = clamp012((i / 255 - black) / span);
+      v = Math.pow(v, gamma);
+      table[i] = ca.flags & CA_NEGATIVE ? 1 - v : v;
+    }
+    return table;
+  });
+  const chroma = colorfulnessScale(ca.colorfulness);
+  const contrast = 1 + ca.contrast / 100;
+  const brightness = 0.8 * ca.brightness / 100;
+  const tint = 0.3 * ca.redGreenTint / 100;
+  const log = (ca.flags & CA_LOG_FILTER) !== 0;
+  const out = (v) => {
+    v = clamp012(v);
+    if (log) {
+      v = Math.log10(1 + 9 * v);
+    }
+    return Math.round(v * 255);
+  };
+  return (rgb2) => {
+    const r = curves[0][rgb2 >> 16 & 255];
+    const g = curves[1][rgb2 >> 8 & 255];
+    const b = curves[2][rgb2 & 255];
+    let y = 0.299 * r + 0.587 * g + 0.114 * b;
+    let cr = (r - y) * chroma;
+    const cb = (b - y) * chroma;
+    y = (y - 0.5) * contrast + 0.5 + brightness;
+    cr += tint;
+    const r2 = y + cr;
+    const b2 = y + cb;
+    const g2 = (y - 0.299 * r2 - 0.114 * b2) / 0.587;
+    return out(r2) << 16 | out(g2) << 8 | out(b2);
+  };
+}
+function applyColorAdjustment(pixels, ca) {
+  if (!ca || isIdentityColorAdjustment(ca)) {
+    return;
+  }
+  const map = colorAdjustmentMapper(ca);
+  const d = pixels.data;
+  const cache = /* @__PURE__ */ new Map();
+  for (let i = 0; i + 3 < d.length; i += 4) {
+    const rgb2 = d[i] << 16 | d[i + 1] << 8 | d[i + 2];
+    let v = cache.get(rgb2);
+    if (v === void 0) {
+      v = map(rgb2);
+      if (cache.size < 65536) {
+        cache.set(rgb2, v);
+      }
+    }
+    d[i] = v >> 16 & 255;
+    d[i + 1] = v >> 8 & 255;
+    d[i + 2] = v & 255;
+  }
+}
+
 // src/emf-gdi-stretch.ts
 var BLACKONWHITE = 1;
 var WHITEONBLACK = 2;
@@ -20052,6 +20143,66 @@ function stretchGdi(src, sx, sy, sw, sh, dw, dh, mode) {
   }
   return { width: W, height: H, data };
 }
+function axisBoxWeights(srcStart, srcLen, dstLen, reverse) {
+  const out = [];
+  if (dstLen <= 0 || srcLen <= 0) {
+    return out;
+  }
+  const at = (k) => reverse ? srcStart + srcLen - 1 - k : srcStart + k;
+  for (let i = 0; i < dstLen; i++) {
+    const a = i * srcLen;
+    const b = (i + 1) * srcLen;
+    const taps = [];
+    for (let k = Math.floor(a / dstLen); k * dstLen < b; k++) {
+      const overlap = Math.min(b, (k + 1) * dstLen) - Math.max(a, k * dstLen);
+      if (overlap > 0) {
+        taps.push([at(k), overlap / srcLen]);
+      }
+    }
+    out.push(taps);
+  }
+  return out;
+}
+function stretchHalftone(src, sx, sy, sw, sh, dw, dh) {
+  const W = Math.max(0, Math.round(Math.abs(dw)));
+  const H = Math.max(0, Math.round(Math.abs(dh)));
+  const flipX = dw < 0 !== sw < 0;
+  const flipY = dh < 0 !== sh < 0;
+  const cols = axisBoxWeights(Math.round(Math.min(sx, sx + sw)), Math.round(Math.abs(sw)), W, flipX);
+  const rows = axisBoxWeights(Math.round(Math.min(sy, sy + sh)), Math.round(Math.abs(sh)), H, flipY);
+  const data = new Uint8ClampedArray(W * H * 4);
+  const s = src.data;
+  for (let y = 0; y < H; y++) {
+    const ys = rows[y] ?? [];
+    for (let x = 0; x < W; x++) {
+      const xs = cols[x] ?? [];
+      let r = 0;
+      let g = 0;
+      let b = 0;
+      for (const [yy, wy] of ys) {
+        if (yy < 0 || yy >= src.height) {
+          continue;
+        }
+        for (const [xx, wx] of xs) {
+          if (xx < 0 || xx >= src.width) {
+            continue;
+          }
+          const w = wx * wy;
+          const i = (yy * src.width + xx) * 4;
+          r += s[i] * w;
+          g += s[i + 1] * w;
+          b += s[i + 2] * w;
+        }
+      }
+      const o = (y * W + x) * 4;
+      data[o] = Math.floor(r + 1e-6);
+      data[o + 1] = Math.floor(g + 1e-6);
+      data[o + 2] = Math.floor(b + 1e-6);
+      data[o + 3] = 255;
+    }
+  }
+  return { width: W, height: H, data };
+}
 
 // src/emf-gdi-draw-bitmap.ts
 function patternOperand(rCtx, brush) {
@@ -20075,46 +20226,18 @@ function patternOperand(rCtx, brush) {
 function drawSourceMapped(target, decoded, req, offsetX, offsetY, mode) {
   const dLeft = Math.min(req.dx, req.dx + req.dw) - offsetX;
   const dTop = Math.min(req.dy, req.dy + req.dh) - offsetY;
-  if (mode !== HALFTONE) {
-    const px = stretchGdi(decoded.pixels, req.sx, req.sy, req.sw, req.sh, req.dw, req.dh, mode);
-    const tile = createTempCanvas(px.width, px.height);
-    if (!tile) {
-      return;
-    }
-    canvasPutImageData(tile.ctx, createImageDataCompat(px.data, px.width, px.height), 0, 0);
-    target.save();
-    target.globalCompositeOperation = "source-over";
-    canvasDrawImage(target, tile.canvas, Math.round(dLeft), Math.round(dTop), px.width, px.height);
-    target.restore();
+  const px = mode === HALFTONE ? stretchHalftone(decoded.pixels, req.sx, req.sy, req.sw, req.sh, req.dw, req.dh) : stretchGdi(decoded.pixels, req.sx, req.sy, req.sw, req.sh, req.dw, req.dh, mode);
+  if (px.width === 0 || px.height === 0) {
     return;
   }
-  const flipX = req.dw < 0 !== req.sw < 0;
-  const flipY = req.dh < 0 !== req.sh < 0;
-  const adw = Math.abs(req.dw);
-  const adh = Math.abs(req.dh);
+  const tile = createTempCanvas(px.width, px.height);
+  if (!tile) {
+    return;
+  }
+  canvasPutImageData(tile.ctx, createImageDataCompat(px.data, px.width, px.height), 0, 0);
   target.save();
-  target.imageSmoothingEnabled = true;
-  target.transform(
-    flipX ? -1 : 1,
-    0,
-    0,
-    flipY ? -1 : 1,
-    flipX ? dLeft * 2 + adw : 0,
-    flipY ? dTop * 2 + adh : 0
-  );
-  const draw = target.drawImage;
-  draw.call(
-    target,
-    decoded.canvas,
-    Math.min(req.sx, req.sx + req.sw),
-    Math.min(req.sy, req.sy + req.sh),
-    Math.abs(req.sw),
-    Math.abs(req.sh),
-    dLeft,
-    dTop,
-    adw,
-    adh
-  );
+  target.globalCompositeOperation = "source-over";
+  canvasDrawImage(target, tile.canvas, Math.round(dLeft), Math.round(dTop), px.width, px.height);
   target.restore();
 }
 function decodeSource(rCtx, req) {
@@ -20131,17 +20254,15 @@ function decodeSource(rCtx, req) {
   if (!image) {
     return null;
   }
-  const temp = createTempCanvas(image.width, image.height);
-  if (!temp) {
-    return null;
+  if (req.stretch && rCtx.state.stretchBltMode === HALFTONE) {
+    applyColorAdjustment(image, rCtx.state.colorAdjustment);
   }
-  canvasPutImageData(temp.ctx, image, 0, 0);
   let { sy } = req;
   if (req.dibOrigin === "bottom-left" && rCtx.view.getInt32(req.source.bmi + 8, true) > 0) {
     sy = image.height - sy - req.sh;
   }
   return {
-    decoded: { pixels: image, canvas: temp.canvas },
+    decoded: { pixels: image },
     req: { ...req, sy }
   };
 }
@@ -20254,7 +20375,7 @@ function nudgedFloor(num, den, dx, dy) {
   const q = Math.floor(num / den);
   return num === q * den && nudgedSign(0, dx, dy) < 0 ? q - 1 : q;
 }
-function executeRotatedBlit(rCtx, logDx, logDy, logDw, logDh, rop, source, sx, sy, sw, sh, dibOrigin) {
+function executeRotatedBlit(rCtx, logDx, logDy, logDw, logDh, rop, source, sx, sy, sw, sh, dibOrigin, stretch) {
   const { ctx } = rCtx;
   const index = rop3Index(rop);
   if (index === 170) {
@@ -20290,7 +20411,8 @@ function executeRotatedBlit(rCtx, logDx, logDy, logDw, logDh, rop, source, sx, s
       sy,
       sw,
       sh,
-      dibOrigin
+      dibOrigin,
+      stretch
     });
     if (!decoded) {
       return;
@@ -20458,7 +20580,8 @@ function handleBlt(rCtx, offset, dataOff, recSize, stretch) {
       srcRect.sy,
       srcRect.sw,
       srcRect.sh,
-      "top-left"
+      "top-left",
+      stretch
     );
     return true;
   }
@@ -20470,7 +20593,8 @@ function handleBlt(rCtx, offset, dataOff, recSize, stretch) {
     dh: gmh(rCtx, cyDest),
     source,
     ...srcRect,
-    dibOrigin: "top-left"
+    dibOrigin: "top-left",
+    stretch
   });
   return true;
 }
@@ -20497,7 +20621,7 @@ function handleStretchDibits(rCtx, offset, dataOff, recSize) {
   const sw = view.getInt32(dataOff + 32, true);
   const sh = view.getInt32(dataOff + 36, true);
   if (hasWorldRotation(rCtx)) {
-    executeRotatedBlit(rCtx, xDest, yDest, cxDest, cyDest, rop, source, sx, sy, sw, sh, "bottom-left");
+    executeRotatedBlit(rCtx, xDest, yDest, cxDest, cyDest, rop, source, sx, sy, sw, sh, "bottom-left", true);
     return true;
   }
   executeBlit(rCtx, {
@@ -20511,7 +20635,8 @@ function handleStretchDibits(rCtx, offset, dataOff, recSize) {
     sy,
     sw,
     sh,
-    dibOrigin: "bottom-left"
+    dibOrigin: "bottom-left",
+    stretch: true
   });
   return true;
 }
@@ -23027,20 +23152,9 @@ function handleEmfGdiMiscRecord(rCtx, recType, dataOff, recSize) {
       return true;
     }
     case EMR_SETCOLORADJUSTMENT: {
-      if (recSize >= 32) {
-        state.colorAdjustment = {
-          flags: view.getUint16(dataOff + 2, true),
-          illuminant: view.getUint16(dataOff + 4, true),
-          redGamma: view.getUint16(dataOff + 6, true),
-          greenGamma: view.getUint16(dataOff + 8, true),
-          blueGamma: view.getUint16(dataOff + 10, true),
-          referenceBlack: view.getUint16(dataOff + 12, true),
-          referenceWhite: view.getUint16(dataOff + 14, true),
-          contrast: view.getInt16(dataOff + 16, true),
-          brightness: view.getInt16(dataOff + 18, true),
-          colorfulness: view.getInt16(dataOff + 20, true),
-          redGreenTint: view.getInt16(dataOff + 22, true)
-        };
+      const ca = recSize >= 8 + COLOR_ADJUSTMENT_SIZE ? readColorAdjustment(view, dataOff) : null;
+      if (ca) {
+        state.colorAdjustment = ca;
       }
       return true;
     }
@@ -23938,6 +24052,50 @@ function applyImageEffect(rgba, width, height, effect) {
       return applyTint(rgba, effect.hue, effect.amount);
   }
 }
+function applyImageEffectToRect(rgba, width, height, effect, src) {
+  if (width <= 0 || height <= 0 || rgba.length !== width * height * 4) {
+    return null;
+  }
+  let x0 = 0;
+  let y0 = 0;
+  let x1 = width;
+  let y1 = height;
+  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) {
+      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;
+  let region = rgba;
+  if (w !== width || h !== height || x0 !== 0 || y0 !== 0) {
+    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);
+    }
+  }
+  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
+    }))
+  } : effect;
+  const out = applyImageEffect(region, w, h, local);
+  return out ? { rgba: out, x: ox, y: oy, width: w, height: h, pad } : null;
+}
 
 // src/emf-plus-draw-image.ts
 function surfaceSize4(ctx) {
@@ -24074,7 +24232,7 @@ function drawNestedMetafile(rCtx, img, cached, source) {
   rCtx.deferredImages.push(...deferred);
   return true;
 }
-function effectedBitmap(img, bitmap, effect) {
+function effectedDraw(img, bitmap, effect, draw, source) {
   let src = bitmap;
   if (!src && img.data) {
     const bmp = decodeBmpFile(img.data.slice(0));
@@ -24085,21 +24243,61 @@ function effectedBitmap(img, bitmap, effect) {
   if (!src) {
     return null;
   }
-  const rgba = applyImageEffect(src.rgba, src.width, src.height, effect);
-  return rgba ? { kind: "bitmap", width: src.width, height: src.height, rgba } : null;
+  const rect = source && source.unit === UNIT_PIXEL && source.srcW > 0 && source.srcH > 0 && [source.srcX, source.srcY, source.srcW, source.srcH].every(Number.isFinite) ? source : null;
+  const region = applyImageEffectToRect(
+    src.rgba,
+    src.width,
+    src.height,
+    effect,
+    rect && { x: rect.srcX, y: rect.srcY, w: rect.srcW, h: rect.srcH }
+  );
+  if (!region) {
+    return null;
+  }
+  const out = { kind: "bitmap", width: region.width, height: region.height, rgba: region.rgba };
+  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 shift = [1, 0, 0, 1, region.x, region.y];
+  const toWorld = mulMatrix(rect.toWorld(rect.srcX, rect.srcY, rect.srcW, rect.srcH), shift);
+  return {
+    bitmap: out,
+    draw: {
+      ...draw,
+      // The Canvas fallback scales the whole effected bitmap.
+      transform: mulMatrix(draw.transform, toWorld),
+      dx: 0,
+      dy: 0,
+      dw: region.width,
+      dh: region.height,
+      resample: draw.resample && {
+        ...draw.resample,
+        srcX,
+        srcY,
+        srcW,
+        srcH,
+        toDevice: mulMatrix(draw.resample.toDevice, shift)
+      }
+    }
+  };
 }
 function drawEmfPlusImageNow(rCtx, img, draw, source, effect = null) {
   const cached = img.cacheKey !== void 0 ? rCtx.imageCache?.get(img.cacheKey) : void 0;
   if (img.type === 2) {
     return drawNestedMetafile(rCtx, img, cached, source);
   }
-  let bitmap = cached && cached.kind === "bitmap" ? cached : null;
-  const effected = effect ? effectedBitmap(img, bitmap, effect) : null;
+  const bitmap = cached && cached.kind === "bitmap" ? cached : null;
+  const effected = effect ? effectedDraw(img, bitmap, effect, draw, source) : null;
   if (effected) {
-    bitmap = effected;
+    return isSvgContext(rCtx.ctx) ? paintBitmapSvg(rCtx.ctx, img, effected.bitmap, effected.draw, true) : paintBitmapRaster(rCtx.ctx, effected.bitmap, effected.draw);
   }
   if (isSvgContext(rCtx.ctx)) {
-    return paintBitmapSvg(rCtx.ctx, img, bitmap, draw, effected !== null);
+    return paintBitmapSvg(rCtx.ctx, img, bitmap, draw);
   }
   return bitmap ? paintBitmapRaster(rCtx.ctx, bitmap, draw) : false;
 }
@@ -24391,28 +24589,32 @@ function strokePlusGeometry(rCtx, pen, buildPath, points, closedFigure = false)
       if (mode !== "canvas" && size && strokeGdiplus(rCtx, pen, nib, sampler, buildPath, device, size, mode, closedFigure)) {
         return;
       }
-      const miter = Math.max(1, ctx.miterLimit || 10);
-      const margin = pen.width * scale * miter / 2 + 2;
-      const box = size ? deviceBounds(points, device, size, margin) : null;
+      const outline = hasCustomCap(pen) ? penOutlineWorld(rCtx, pen, nib, buildPath, closedFigure) : null;
+      let box = null;
+      if (size && outline) {
+        box = deviceBounds(outline.flat(), device, size, 2);
+      } else if (size) {
+        const miter = Math.max(1, ctx.miterLimit || 10);
+        const margin = pen.width * scale * miter / 2 + 2;
+        box = deviceBounds(points, device, size, margin);
+      }
       if (size && !box) {
         return;
       }
-      if (box && paintBrushThroughMask(
-        rCtx,
-        sampler,
-        box,
-        (c) => {
-          applyPlusPenStyle(c, pen, widthScale);
-          stroke(c);
-          c.beginPath();
-          buildPath(c);
-          if (nib) {
-            c.transform(nib[0], nib[1], nib[2], nib[3], 0, 0);
-          }
-        },
-        mode,
-        (c, x, y) => c.isPointInStroke(x, y) && (!inset || c.isPointInPath(x, y))
-      )) {
+      const drawMask = outline ? (c) => {
+        traceOutline(c, outline);
+        c.fill("nonzero");
+      } : (c) => {
+        applyPlusPenStyle(c, pen, widthScale);
+        stroke(c);
+        c.beginPath();
+        buildPath(c);
+        if (nib) {
+          c.transform(nib[0], nib[1], nib[2], nib[3], 0, 0);
+        }
+      };
+      const hitTest = outline ? (c, x, y) => c.isPointInPath(x, y, "nonzero") : (c, x, y) => c.isPointInStroke(x, y) && (!inset || c.isPointInPath(x, y));
+      if (box && paintBrushThroughMask(rCtx, sampler, box, drawMask, mode, hitTest)) {
         return;
       }
     }
@@ -24577,18 +24779,18 @@ function customCapOutline(figures, width, devicePen, pen) {
   outline.push(...geo.polygons);
   return outline;
 }
-function fillPenOutline(rCtx, pen, nib, paint, buildPath, closedFigure) {
+function penOutlineWorld(rCtx, pen, nib, buildPath, closedFigure) {
   const device = plusWorldMatrix(rCtx);
   const frame2 = penFrame(device, nib);
   const deviceInv = invertAffine(device);
   if (!frame2 || !deviceInv || !(frame2.unit > 0)) {
-    return false;
+    return null;
   }
   let figures;
   try {
     figures = recordDeviceFigures(buildPath, frame2.record);
   } catch {
-    return false;
+    return null;
   }
   if (closedFigure) {
     figures = figures.map((f) => ({ ...f, closed: true }));
@@ -24596,25 +24798,33 @@ function fillPenOutline(rCtx, pen, nib, paint, buildPath, closedFigure) {
   const width = (pen.width || 1) * frame2.unit;
   const devicePen = framePen(pen, frame2.unit);
   const outline = hasCustomCap(pen) ? customCapOutline(figures, width, devicePen, pen) : widenFigures(figures, devicePen);
-  const toWorld = mulMatrix(deviceInv, frame2.toDevice);
+  const m = mulMatrix(deviceInv, frame2.toDevice);
+  return outline.map((poly) => poly.map((p) => ({ x: m[0] * p.x + m[2] * p.y + m[4], y: m[1] * p.x + m[3] * p.y + m[5] })));
+}
+function traceOutline(c, outline) {
+  c.beginPath();
+  for (const poly of outline) {
+    poly.forEach((p, i) => {
+      if (i === 0) {
+        c.moveTo(p.x, p.y);
+      } else {
+        c.lineTo(p.x, p.y);
+      }
+    });
+    c.closePath();
+  }
+}
+function fillPenOutline(rCtx, pen, nib, paint, buildPath, closedFigure) {
+  const outline = penOutlineWorld(rCtx, pen, nib, buildPath, closedFigure);
+  if (!outline) {
+    return false;
+  }
   const { ctx } = rCtx;
   ctx.save();
   try {
     ctx.fillStyle = paint;
     applyPlusWorldTransform(rCtx);
-    ctx.beginPath();
-    for (const poly of outline) {
-      poly.forEach((p, i) => {
-        const x = toWorld[0] * p.x + toWorld[2] * p.y + toWorld[4];
-        const y = toWorld[1] * p.x + toWorld[3] * p.y + toWorld[5];
-        if (i === 0) {
-          ctx.moveTo(x, y);
-        } else {
-          ctx.lineTo(x, y);
-        }
-      });
-      ctx.closePath();
-    }
+    traceOutline(ctx, outline);
     ctx.fill("nonzero");
   } finally {
     ctx.restore();

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "emf-converter",
-	"version": "4.2.0",
+	"version": "4.3.0",
 	"description": "Convert EMF/WMF metafile binaries to PNG data URLs or SVG (markup, data URL, React/JSX)",
 	"keywords": [
 		"canvas",
@@ -45,6 +45,7 @@
 		"test": "vitest run",
 		"test:watch": "vitest",
 		"pack": "bun run build && bun pm pack",
+		"docs:typecheck": "vue-tsc --noEmit -p docs/tsconfig.json",
 		"docs:dev": "vitepress dev docs",
 		"docs:build": "vitepress build docs",
 		"docs:preview": "vitepress preview docs"
@@ -59,7 +60,8 @@
 		"tsup": "^8.5.1",
 		"typescript": "^6.0.3",
 		"vitepress": "^1.6.4",
-		"vitest": "^5.0.0"
+		"vitest": "^5.0.0",
+		"vue-tsc": "^3.3.11"
 	},
 	"peerDependencies": {
 		"@napi-rs/canvas": "^1.0.9"