emf-converter 4.1.0 → 4.2.1

package/dist/index.mjs

@@ -22,9 +22,9 @@ function lerpArgbToRgba(argbA, argbB, t) {
   return `rgba(${r},${g},${b},${a.toFixed(3)})`;
 }
 function invertCssColor(color) {
-  const hex4 = /^#([0-9a-f]{6})$/i.exec(color);
-  if (hex4) {
-    const v = parseInt(hex4[1], 16);
+  const hex5 = /^#([0-9a-f]{6})$/i.exec(color);
+  if (hex5) {
+    const v = parseInt(hex5[1], 16);
     const inv2 = 16777215 ^ v;
     return `#${inv2.toString(16).padStart(6, "0")}`;
   }
@@ -384,8 +384,8 @@ function cssHexToRgb(color) {
   if (!m) {
     return 0;
   }
-  const hex4 = m[1].length === 3 ? m[1].replace(/./g, (c) => c + c) : m[1];
-  return parseInt(hex4, 16);
+  const hex5 = m[1].length === 3 ? m[1].replace(/./g, (c) => c + c) : m[1];
+  return parseInt(hex5, 16);
 }
 function decodeMonoBits(view, bmiOffset, bitsOffset) {
   if (bmiOffset + 16 > view.byteLength) {
@@ -728,6 +728,7 @@ var EMFPLUS_SETRENDERINGORIGIN = 16413;
 var EMFPLUS_SETTEXTCONTRAST = 16416;
 var EMFPLUS_SETCOMPOSITINGMODE = 16419;
 var EMFPLUS_STROKEFILLPATH = 16439;
+var EMFPLUS_SERIALIZABLEOBJECT = 16440;
 var EMFPLUS_SETTSGRAPHICS = 16441;
 var EMFPLUS_SETTSCLIP = 16442;
 var EMFPLUS_OBJECTTYPE_BRUSH = 1;
@@ -13738,7 +13739,8 @@ function gmx(r, x) {
   const wt = r.state.worldTransform;
   const px = wt[0] * x + wt[4];
   if (r.useMappingMode) {
-    return (px - r.windowOrg.x) / (r.windowExt.cx || 1) * (r.viewportExt.cx || 1) + r.viewportOrg.x;
+    const dx = (px - r.windowOrg.x) / (r.windowExt.cx || 1) * (r.viewportExt.cx || 1) + r.viewportOrg.x;
+    return r.deviceToCanvas ? (dx - r.bounds.left) * r.sx : dx;
   }
   return (px - r.bounds.left) * r.sx;
 }
@@ -13746,24 +13748,31 @@ function gmy(r, y) {
   const wt = r.state.worldTransform;
   const py = wt[3] * y + wt[5];
   if (r.useMappingMode) {
-    return (py - r.windowOrg.y) / (r.windowExt.cy || 1) * (r.viewportExt.cy || 1) + r.viewportOrg.y;
+    const dy = (py - r.windowOrg.y) / (r.windowExt.cy || 1) * (r.viewportExt.cy || 1) + r.viewportOrg.y;
+    return r.deviceToCanvas ? (dy - r.bounds.top) * r.sy : dy;
   }
   return (py - r.bounds.top) * r.sy;
 }
 function gmw(r, w) {
   const pw = r.state.worldTransform[0] * w;
   if (r.useMappingMode) {
-    return pw / (r.windowExt.cx || 1) * (r.viewportExt.cx || 1);
+    return pw / (r.windowExt.cx || 1) * (r.viewportExt.cx || 1) * (r.deviceToCanvas ? r.sx : 1);
   }
   return pw * r.sx;
 }
 function gmh(r, h) {
   const ph = r.state.worldTransform[3] * h;
   if (r.useMappingMode) {
-    return ph / (r.windowExt.cy || 1) * (r.viewportExt.cy || 1);
+    return ph / (r.windowExt.cy || 1) * (r.viewportExt.cy || 1) * (r.deviceToCanvas ? r.sy : 1);
   }
   return ph * r.sy;
 }
+function gdiDevicePixelX(r) {
+  return !r.useMappingMode || r.deviceToCanvas ? r.sx : 1;
+}
+function gdiDevicePixelY(r) {
+  return !r.useMappingMode || r.deviceToCanvas ? r.sy : 1;
+}
 function activateGdiMappingMode(r) {
   r.useMappingMode = true;
 }
@@ -13776,13 +13785,14 @@ function gdiDeviceMatrix(r) {
   if (r.useMappingMode) {
     const kx = (r.viewportExt.cx || 1) / (r.windowExt.cx || 1);
     const ky = (r.viewportExt.cy || 1) / (r.windowExt.cy || 1);
+    const [cx, cy, ox, oy] = r.deviceToCanvas ? [r.sx, r.sy, r.bounds.left, r.bounds.top] : [1, 1, 0, 0];
     return [
-      wt[0] * kx,
-      wt[1] * ky,
-      wt[2] * kx,
-      wt[3] * ky,
-      (wt[4] - r.windowOrg.x) * kx + r.viewportOrg.x,
-      (wt[5] - r.windowOrg.y) * ky + r.viewportOrg.y
+      wt[0] * kx * cx,
+      wt[1] * ky * cy,
+      wt[2] * kx * cx,
+      wt[3] * ky * cy,
+      ((wt[4] - r.windowOrg.x) * kx + r.viewportOrg.x - ox) * cx,
+      ((wt[5] - r.windowOrg.y) * ky + r.viewportOrg.y - oy) * cy
     ];
   }
   const sx = r.sx || 1;
@@ -15657,8 +15667,8 @@ function paintWithRop2PerPixel(ctx, rop2, color, draw, pad = 2, fillRule) {
       sc.restore();
     }
     const pointTest = fillRule !== void 0 && typeof sc.isPointInPath === "function";
-    const hex4 = /^#([0-9a-f]{6})$/i.exec(color.trim());
-    const fixedP = hex4 ? parseInt(hex4[1], 16) : -1;
+    const hex5 = /^#([0-9a-f]{6})$/i.exec(color.trim());
+    const fixedP = hex5 ? parseInt(hex5[1], 16) : -1;
     const paint = canvasGetImageData(sc, 0, 0, box.w, box.h);
     const pd = paint.data;
     const dd = index === 240 ? null : canvasGetImageData(ctx, box.x, box.y, box.w, box.h).data;
@@ -17957,7 +17967,7 @@ function writeTextureColor(inv2, width, height, rgba, wrap, halfPixel2, dx, dy,
   const iv = Math.floor(cv + 1e-9);
   const fu = Math.max(0, cu - iu);
   const fv = Math.max(0, cv - iv);
-  const clamp = wrap === "clamp";
+  const clamp2 = wrap === "clamp";
   const mirrorX = wrap === "tile-flip-x" || wrap === "tile-flip-xy";
   const mirrorY = wrap === "tile-flip-y" || wrap === "tile-flip-xy";
   let r = 0;
@@ -17973,7 +17983,7 @@ function writeTextureColor(inv2, width, height, rgba, wrap, halfPixel2, dx, dy,
     }
     let x;
     let y;
-    if (clamp) {
+    if (clamp2) {
       if (tu < 0 || tv < 0 || tu >= width || tv >= height) {
         continue;
       }
@@ -19165,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);
@@ -20355,8 +20365,8 @@ function paintParallelogram(rCtx, a, b, q, sw, sh, pixel) {
   });
 }
 function alignMirroredDest(rCtx, req) {
-  const pxX = rCtx.useMappingMode ? 1 : rCtx.sx;
-  const pxY = rCtx.useMappingMode ? 1 : rCtx.sy;
+  const pxX = gdiDevicePixelX(rCtx);
+  const pxY = gdiDevicePixelY(rCtx);
   return {
     ...req,
     dx: req.dw < 0 ? req.dx + pxX : req.dx,
@@ -20591,10 +20601,10 @@ function axisMap(rCtx, xDest, yDest, cxDest, cyDest, sx, sy, sw, sh) {
   const dw = gmw(rCtx, cxDest);
   const dh = gmh(rCtx, cyDest);
   if (dw < 0) {
-    dx += rCtx.useMappingMode ? 1 : rCtx.sx;
+    dx += gdiDevicePixelX(rCtx);
   }
   if (dh < 0) {
-    dy += rCtx.useMappingMode ? 1 : rCtx.sy;
+    dy += gdiDevicePixelY(rCtx);
   }
   const W = Math.round(Math.abs(dw));
   const H = Math.round(Math.abs(dh));
@@ -23523,6 +23533,456 @@ function handleEmfGdiStateRecord(rCtx, recType, _offset, dataOff, recSize) {
   }
 }
 
+// src/emf-plus-image-effects.ts
+var EFFECT_GUIDS = {
+  "633C80A4-1843-482B-9EF2-BE2834C5FDD4": "blur",
+  "D3A1DBE1-8EC4-4C17-9F4C-EA97AD1C343D": "brightnessContrast",
+  "537E597D-251E-48DA-9664-29CA496B70F8": "colorBalance",
+  "DD6A0022-58E4-4A67-9D9B-D48EB881A53D": "colorCurve",
+  "A7CE72A9-0F7F-40D7-B3CC-D0C02D5C3212": "colorLookupTable",
+  "718F2615-7933-40E3-A511-5F68FE14DD74": "colorMatrix",
+  "8B2DD6C3-EB07-4D87-A5F0-7108E26A9C5F": "hueSaturationLightness",
+  "99C354EC-2A31-4F3A-8C34-17A803B33A25": "levels",
+  "74D29D05-69A4-4266-9549-3CC52836B632": "redEyeCorrection",
+  "63CBF3EE-C526-402C-8F71-62C540BF5142": "sharpen",
+  "1077AF00-2848-4441-9489-44AD4C2D7A2C": "tint"
+};
+var DRAWIMAGE_EFFECT_FLAG = 8192;
+var CurveAdjustment = {
+  Exposure: 0,
+  Density: 1,
+  Contrast: 2,
+  Highlight: 3,
+  Shadow: 4,
+  Midtone: 5,
+  WhiteSaturation: 6,
+  BlackSaturation: 7
+};
+var CurveChannel = { All: 0, Red: 1, Green: 2, Blue: 3 };
+var hex4 = (v, digits) => v.toString(16).toUpperCase().padStart(digits, "0");
+function readGuid(view, off) {
+  const tail = [];
+  for (let i = 0; i < 8; i++) {
+    tail.push(hex4(view.getUint8(off + 8 + i), 2));
+  }
+  return [
+    hex4(view.getUint32(off, true), 8),
+    hex4(view.getUint16(off + 4, true), 4),
+    hex4(view.getUint16(off + 6, true), 4),
+    tail.slice(0, 2).join(""),
+    tail.slice(2).join("")
+  ].join("-");
+}
+var clamp = (v, lo, hi) => v < lo ? lo : v > hi ? hi : v;
+function parseSerializableObject(view, dataOff, dataSize) {
+  if (dataSize < 20) {
+    return null;
+  }
+  const kind = EFFECT_GUIDS[readGuid(view, dataOff)];
+  const size = view.getUint32(dataOff + 16, true);
+  if (!kind || 20 + size > dataSize) {
+    return null;
+  }
+  const p = dataOff + 20;
+  const i32 = (k, lo, hi) => clamp(view.getInt32(p + 4 * k, true), lo, hi);
+  const f323 = (k, lo, hi) => {
+    const v = view.getFloat32(p + 4 * k, true);
+    return Number.isFinite(v) ? clamp(v, lo, hi) : 0;
+  };
+  const need = (n) => size >= n;
+  switch (kind) {
+    case "blur":
+      return need(8) ? { kind, radius: f323(0, 0, 255), expandEdge: view.getUint32(p + 4, true) !== 0 } : null;
+    case "brightnessContrast":
+      return need(8) ? { kind, brightness: i32(0, -255, 255), contrast: i32(1, -100, 100) } : null;
+    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) ? {
+        kind,
+        adjustment: view.getInt32(p, true),
+        channel: view.getInt32(p + 4, true),
+        intensity: i32(2, -255, 255)
+      } : null;
+    case "colorLookupTable": {
+      if (!need(1024)) {
+        return null;
+      }
+      const lut = (k) => new Uint8Array(view.buffer.slice(view.byteOffset + p + 256 * k, view.byteOffset + p + 256 * (k + 1)));
+      return { kind, b: lut(0), g: lut(1), r: lut(2), a: lut(3) };
+    }
+    case "colorMatrix": {
+      if (!need(100)) {
+        return null;
+      }
+      const matrix = [];
+      for (let k = 0; k < 25; k++) {
+        const v = view.getFloat32(p + 4 * k, true);
+        matrix.push(Number.isFinite(v) ? v : 0);
+      }
+      return { kind, matrix };
+    }
+    case "hueSaturationLightness":
+      return need(12) ? { kind, hue: i32(0, -180, 180), saturation: i32(1, -100, 100), lightness: i32(2, -100, 100) } : null;
+    case "levels":
+      return need(12) ? { kind, highlight: i32(0, 0, 100), midtone: i32(1, -100, 100), shadow: i32(2, 0, 100) } : null;
+    case "redEyeCorrection": {
+      if (!need(4)) {
+        return null;
+      }
+      const count = view.getInt32(p, true);
+      if (count < 0 || 4 + 16 * count > size) {
+        return null;
+      }
+      const areas = [];
+      for (let k = 0; k < count; k++) {
+        const o = p + 4 + 16 * k;
+        areas.push({
+          left: view.getInt32(o, true),
+          top: view.getInt32(o + 4, true),
+          right: view.getInt32(o + 8, true),
+          bottom: view.getInt32(o + 12, true)
+        });
+      }
+      return { kind, areas };
+    }
+    case "sharpen":
+      return need(8) ? { kind, radius: f323(0, 0, 255), amount: f323(1, 0, 100) } : null;
+    case "tint":
+      return need(8) ? { kind, hue: i32(0, -180, 180), amount: i32(1, -100, 100) } : null;
+  }
+}
+function buildLut(f) {
+  const lut = new Uint8Array(256);
+  for (let v = 0; v < 256; v++) {
+    lut[v] = clamp(Math.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 curveAdjustmentLut(adjustment, intensity) {
+  const t = intensity;
+  switch (adjustment) {
+    case CurveAdjustment.Exposure:
+      return buildLut((v) => v * (1 + t / 255));
+    case CurveAdjustment.Density:
+      return buildLut((v) => v * (1 - t / 255));
+    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);
+      });
+    }
+    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);
+    }
+    case CurveAdjustment.BlackSaturation: {
+      const b = Math.min(254, clamp(t, 0, 255));
+      return buildLut((v) => (v - b) * 255 / (255 - b));
+    }
+    default:
+      return null;
+  }
+}
+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));
+}
+function applyLuts(src, r, g, b, a = null) {
+  const out = new Uint8ClampedArray(src);
+  for (let i = 0; i < out.length; i += 4) {
+    if (r) out[i] = r[src[i]];
+    if (g) out[i + 1] = g[src[i + 1]];
+    if (b) out[i + 2] = b[src[i + 2]];
+    if (a) out[i + 3] = a[src[i + 3]];
+  }
+  return out;
+}
+function applyColorMatrix(src, m) {
+  const out = new Uint8ClampedArray(src.length);
+  for (let i = 0; i < src.length; i += 4) {
+    const r = src[i] / 255;
+    const g = src[i + 1] / 255;
+    const b = src[i + 2] / 255;
+    const a = src[i + 3] / 255;
+    for (let j = 0; j < 4; j++) {
+      const v = r * m[j] + g * m[5 + j] + b * m[10 + j] + a * m[15 + j] + m[20 + j];
+      out[i + j] = Math.round(clamp(v, 0, 1) * 255);
+    }
+  }
+  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;
+  const x = c * (1 - Math.abs(hp % 2 - 1));
+  const m = l - c / 2;
+  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];
+}
+function applyHueSaturationLightness(src, hue, saturation, lightness) {
+  const out = new Uint8ClampedArray(src);
+  const push = (v, t) => t >= 0 ? v + (1 - v) * (t / 100) : v * (1 + t / 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, lightness));
+    out[i] = Math.round(r * 255);
+    out[i + 1] = Math.round(g * 255);
+    out[i + 2] = Math.round(b * 255);
+  }
+  return out;
+}
+var LUMA = [0.299, 0.587, 0.114];
+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 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]);
+  }
+  return out;
+}
+function applyRedEyeCorrection(src, width, height, areas) {
+  const out = new Uint8ClampedArray(src);
+  for (const a of areas) {
+    const x0 = clamp(a.left, 0, width);
+    const x1 = clamp(a.right, 0, width);
+    const y0 = clamp(a.top, 0, height);
+    const y1 = clamp(a.bottom, 0, height);
+    for (let y = y0; y < y1; y++) {
+      for (let x = x0; x < x1; x++) {
+        const i = (y * width + x) * 4;
+        const r = out[i];
+        const g = out[i + 1];
+        const b = out[i + 2];
+        if (r > g && r > b) {
+          out[i] = Math.round((g + b) / 2);
+        }
+      }
+    }
+  }
+  return out;
+}
+function boxRadiiForSigma(sigma) {
+  const target = sigma * sigma;
+  let k = 0;
+  while ((k + 1) * (k + 2) <= target) {
+    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);
+      }
+    }
+  }
+  return out;
+}
+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];
+  }
+  for (const r of boxRadiiForSigma(radius / 2)) {
+    buf = boxPass(buf, w, h, r, true);
+    buf = boxPass(buf, w, h, r, false);
+  }
+  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 buf;
+}
+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 out;
+}
+function applySharpen(src, w, h, radius, amount) {
+  const blurred = blurFloat(src, w, h, radius);
+  const k = amount / 100;
+  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]));
+    }
+  }
+  return out;
+}
+function applyImageEffect(rgba, width, height, effect) {
+  if (width <= 0 || height <= 0 || rgba.length !== width * height * 4) {
+    return null;
+  }
+  switch (effect.kind) {
+    case "blur":
+      return applyBlur(rgba, width, height, effect.radius);
+    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);
+      return applyLuts(rgba, lut, lut, lut);
+    }
+    case "colorBalance":
+      return applyLuts(
+        rgba,
+        buildLut(balanceCurve(effect.cyanRed)),
+        buildLut(balanceCurve(effect.magentaGreen)),
+        buildLut(balanceCurve(effect.yellowBlue))
+      );
+    case "colorCurve": {
+      const lut = curveAdjustmentLut(effect.adjustment, effect.intensity);
+      const ch = effect.channel;
+      if (!lut || ch < CurveChannel.All || ch > CurveChannel.Blue) {
+        return null;
+      }
+      const pick = (c) => ch === CurveChannel.All || ch === c ? lut : null;
+      return applyLuts(rgba, pick(CurveChannel.Red), pick(CurveChannel.Green), pick(CurveChannel.Blue));
+    }
+    case "colorLookupTable":
+      return applyLuts(rgba, effect.r, effect.g, effect.b, effect.a);
+    case "colorMatrix":
+      return applyColorMatrix(rgba, effect.matrix);
+    case "hueSaturationLightness":
+      return applyHueSaturationLightness(rgba, effect.hue, effect.saturation, effect.lightness);
+    case "levels": {
+      const lut = levelsLut(effect.highlight, effect.midtone, effect.shadow);
+      return applyLuts(rgba, lut, lut, lut);
+    }
+    case "redEyeCorrection":
+      return applyRedEyeCorrection(rgba, width, height, effect.areas);
+    case "tint":
+      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) {
   const canvas = ctx.canvas;
@@ -23585,8 +24045,8 @@ function svgImagePayload(img, bitmap) {
   }
   return decodeBmpFile(bytes.buffer);
 }
-function paintBitmapSvg(svg, img, bitmap, draw) {
-  const payload = svgImagePayload(img, bitmap);
+function paintBitmapSvg(svg, img, bitmap, draw, pixelsOnly = false) {
+  const payload = pixelsOnly && bitmap ? { kind: "rgba", data: bitmap.rgba, width: bitmap.width, height: bitmap.height } : svgImagePayload(img, bitmap);
   if (!payload) {
     return false;
   }
@@ -23658,12 +24118,70 @@ function drawNestedMetafile(rCtx, img, cached, source) {
   rCtx.deferredImages.push(...deferred);
   return true;
 }
-function drawEmfPlusImageNow(rCtx, img, draw, source) {
+function effectedDraw(img, bitmap, effect, draw, source) {
+  let src = bitmap;
+  if (!src && img.data) {
+    const bmp = decodeBmpFile(img.data.slice(0));
+    if (bmp && bmp.kind === "rgba") {
+      src = { rgba: bmp.data, width: bmp.width, height: bmp.height };
+    }
+  }
+  if (!src) {
+    return 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);
   }
   const bitmap = cached && cached.kind === "bitmap" ? cached : null;
+  const effected = effect ? effectedDraw(img, bitmap, effect, draw, source) : null;
+  if (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);
   }
@@ -23918,20 +24436,27 @@ function applyPlusPenStyle(ctx, pen, widthScale = 1) {
 }
 function strokePlusGeometry(rCtx, pen, buildPath, points, closedFigure = false) {
   const { ctx } = rCtx;
-  pen = applySimilarityPenTransform(pen);
+  const resolved = resolvePenTransform(pen);
+  pen = resolved.pen;
+  const nib = resolved.nib;
   const inset = !!pen && pen.alignment === 1 && closedFigure;
   const widthScale = inset ? 2 : 1;
   const stroke = (c) => {
-    if (inset) {
+    if (inset || nib) {
       c.save();
+    }
+    if (inset) {
       c.beginPath();
       buildPath(c);
       c.clip();
     }
     c.beginPath();
     buildPath(c);
+    if (nib) {
+      c.transform(nib[0], nib[1], nib[2], nib[3], 0, 0);
+    }
     c.stroke();
-    if (inset) {
+    if (inset || nib) {
       c.restore();
     }
   };
@@ -23946,97 +24471,138 @@ function strokePlusGeometry(rCtx, pen, buildPath, points, closedFigure = false)
     if (sampler) {
       const size = surfaceSize5(ctx);
       const device = plusWorldMatrix(rCtx);
-      const scale = Math.max(Math.hypot(device[0], device[1]), Math.hypot(device[2], device[3]));
-      if (mode !== "canvas" && size && strokeGdiplus(rCtx, pen, sampler, buildPath, device, size, mode, closedFigure)) {
+      const scale = maxStretch(nib ? mulMatrix(device, nib) : device);
+      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);
-        },
-        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;
       }
     }
-    if (hasCustomCap(pen) && !pen.transform && fillCustomCapStroke(rCtx, pen, buildPath, closedFigure)) {
+    const paint = pen.brush ? brushPaint2(rCtx, pen.brush) : pen.color;
+    if ((hasCustomCap(pen) || nib && typeof paint !== "string") && fillPenOutline(rCtx, pen, nib, paint, buildPath, closedFigure)) {
       return;
     }
-    ctx.strokeStyle = pen.brush ? brushPaint2(rCtx, pen.brush) : pen.color;
+    ctx.strokeStyle = paint;
   }
   applyPlusWorldTransform(rCtx);
   stroke(ctx);
 }
-function applySimilarityPenTransform(pen) {
+function resolvePenTransform(pen) {
   if (!pen?.transform) {
-    return pen;
-  }
-  if (isIdentity2(pen.transform)) {
-    return { ...pen, transform: null };
+    return { pen, nib: null };
   }
   const [a, b, c, d] = pen.transform;
   const sx = Math.hypot(a, b);
   const sy = Math.hypot(c, d);
   const dot = a * c + b * d;
-  if (!Number.isFinite(sx + sy + dot) || !(sx > 0) || Math.abs(sx - sy) > 1e-6 * sx || Math.abs(dot) > 1e-6 * sx * sy) {
-    return pen;
+  const det = a * d - b * c;
+  const plain = { ...pen, transform: null };
+  if (pen.width === 0 || isIdentity2(pen.transform) || !Number.isFinite(sx + sy + dot + det) || Math.abs(det) < 1e-12) {
+    return { pen: { ...plain, width: pen.width === 0 ? 1 : pen.width }, nib: null };
   }
-  return { ...pen, width: pen.width === 0 ? 1 : pen.width * sx, transform: null };
-}
-function strokeGdiplus(rCtx, pen, sampler, buildPath, device, size, mode, closedFigure) {
-  if (pen.transform && !isIdentity2(pen.transform)) {
-    return false;
+  if (Math.abs(sx - sy) <= 1e-6 * sx && Math.abs(dot) <= 1e-6 * sx * sy) {
+    return { pen: { ...plain, width: pen.width * sx }, nib: null };
   }
-  const sx = Math.hypot(device[0], device[1]);
-  const sy = Math.hypot(device[2], device[3]);
-  const dot = device[0] * device[2] + device[1] * device[3];
-  if (!(sx > 0) || Math.abs(sx - sy) > 1e-6 * sx || Math.abs(dot) > 1e-6 * sx * sy) {
-    return false;
-  }
-  let figures;
-  try {
-    figures = recordDeviceFigures(buildPath, device);
-  } catch {
-    return false;
+  return { pen: plain, nib: [a, b, c, d, 0, 0] };
+}
+function maxStretch(m) {
+  const s = m[0] * m[0] + m[1] * m[1] + m[2] * m[2] + m[3] * m[3];
+  const det = m[0] * m[3] - m[1] * m[2];
+  return Math.sqrt((s + Math.sqrt(Math.max(0, s * s - 4 * det * det))) / 2);
+}
+function penFrame(device, nib) {
+  if (!nib) {
+    return { record: device, unit: Math.hypot(device[0], device[1]), toDevice: IDENTITY5 };
   }
-  if (closedFigure) {
-    figures = figures.map((f) => ({ ...f, closed: true }));
+  const full = mulMatrix(device, nib);
+  const unit = maxStretch(full);
+  const inv2 = invertAffine(nib);
+  if (!inv2 || !(unit > 0) || !Number.isFinite(unit)) {
+    return null;
   }
-  const width = (pen.width || 1) * sx;
-  const dash = penDashArray(pen).map((v) => v * sx);
-  const devicePen = {
-    half: width / 2,
+  return {
+    record: [inv2[0] * unit, inv2[1] * unit, inv2[2] * unit, inv2[3] * unit, 0, 0],
+    unit,
+    toDevice: mulMatrix(full, [1 / unit, 0, 0, 1 / unit, 0, 0])
+  };
+}
+function framePen(pen, unit) {
+  const dash = penDashArray(pen).map((v) => v * unit);
+  return {
+    half: (pen.width || 1) * unit / 2,
     join: pen.lineJoin ?? 0,
     miterLimit: pen.miterLimit && pen.miterLimit >= 1 ? pen.miterLimit : 10,
     startCap: pen.startCap ?? 0,
     endCap: pen.endCap ?? 0,
     dashCap: pen.dashCap ?? 0,
     dash: dash.length > 0 ? dash : null,
-    dashOffset: (pen.dashOffset ?? 0) * (pen.width || 1) * sx,
+    dashOffset: (pen.dashOffset ?? 0) * (pen.width || 1) * unit,
     compound: pen.compound ?? null,
     inset: pen.alignment === 1
   };
+}
+function strokeGdiplus(rCtx, pen, nib, sampler, buildPath, device, size, mode, closedFigure) {
+  if (!nib) {
+    const sx = Math.hypot(device[0], device[1]);
+    const sy = Math.hypot(device[2], device[3]);
+    const dot = device[0] * device[2] + device[1] * device[3];
+    if (!(sx > 0) || Math.abs(sx - sy) > 1e-6 * sx || Math.abs(dot) > 1e-6 * sx * sy) {
+      return false;
+    }
+  }
+  const frame2 = penFrame(device, nib);
+  if (!frame2) {
+    return false;
+  }
+  let figures;
+  try {
+    figures = recordDeviceFigures(buildPath, frame2.record);
+  } catch {
+    return false;
+  }
+  if (closedFigure) {
+    figures = figures.map((f) => ({ ...f, closed: true }));
+  }
+  const width = (pen.width || 1) * frame2.unit;
+  const devicePen = framePen(pen, frame2.unit);
   const antialias = mode === "gdiplus-aa";
+  const toFix = (poly) => {
+    const m = frame2.toDevice;
+    return poly.flatMap((p) => [toPlusFix(m[0] * p.x + m[2] * p.y + m[4]), toPlusFix(m[1] * p.x + m[3] * p.y + m[5])]);
+  };
   let fix;
   if (hasCustomCap(pen)) {
-    fix = customCapOutline(figures, width, devicePen, pen).map((poly) => poly.flatMap((p) => [toPlusFix(p.x), toPlusFix(p.y)]));
+    fix = customCapOutline(figures, width, devicePen, pen).map(toFix);
   } else if (width <= NOMINAL_PEN_MAX && !devicePen.dash && !(((pen.startCap ?? 0) | (pen.endCap ?? 0) | (pen.dashCap ?? 0)) & 240)) {
     return strokeNominal(rCtx, pen, sampler, buildPath, device, size, antialias, closedFigure);
   } else {
-    fix = widenFigures(figures, devicePen).map((poly) => poly.flatMap((p) => [toPlusFix(p.x), toPlusFix(p.y)]));
+    fix = widenFigures(figures, devicePen).map(toFix);
   }
   const box = figuresBox(fix, size);
   if (!box) {
@@ -24099,68 +24665,59 @@ function customCapOutline(figures, width, devicePen, pen) {
   outline.push(...geo.polygons);
   return outline;
 }
-function fillCustomCapStroke(rCtx, pen, buildPath, closedFigure) {
+function penOutlineWorld(rCtx, pen, nib, buildPath, closedFigure) {
   const device = plusWorldMatrix(rCtx);
-  const sx = Math.hypot(device[0], device[1]);
-  const det = device[0] * device[3] - device[1] * device[2];
-  if (!(sx > 0) || !Number.isFinite(det) || Math.abs(det) < 1e-12) {
-    return false;
+  const frame2 = penFrame(device, nib);
+  const deviceInv = invertAffine(device);
+  if (!frame2 || !deviceInv || !(frame2.unit > 0)) {
+    return null;
   }
   let figures;
   try {
-    figures = recordDeviceFigures(buildPath, device);
+    figures = recordDeviceFigures(buildPath, frame2.record);
   } catch {
-    return false;
+    return null;
   }
   if (closedFigure) {
     figures = figures.map((f) => ({ ...f, closed: true }));
   }
-  const width = (pen.width || 1) * sx;
-  const dash = penDashArray(pen).map((v) => v * sx);
-  const devicePen = {
-    half: width / 2,
-    join: pen.lineJoin ?? 0,
-    miterLimit: pen.miterLimit && pen.miterLimit >= 1 ? pen.miterLimit : 10,
-    startCap: pen.startCap ?? 0,
-    endCap: pen.endCap ?? 0,
-    dashCap: pen.dashCap ?? 0,
-    dash: dash.length > 0 ? dash : null,
-    dashOffset: (pen.dashOffset ?? 0) * (pen.width || 1) * sx,
-    compound: pen.compound ?? null,
-    inset: pen.alignment === 1
-  };
-  const inv2 = [
-    device[3] / det,
-    -device[1] / det,
-    -device[2] / det,
-    device[0] / det,
-    (device[2] * device[5] - device[3] * device[4]) / det,
-    (device[1] * device[4] - device[0] * device[5]) / det
-  ];
+  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 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 = pen.brush ? brushPaint2(rCtx, pen.brush) : pen.color;
+    ctx.fillStyle = paint;
     applyPlusWorldTransform(rCtx);
-    ctx.beginPath();
-    for (const poly of customCapOutline(figures, width, devicePen, pen)) {
-      poly.forEach((p, i) => {
-        const x = inv2[0] * p.x + inv2[2] * p.y + inv2[4];
-        const y = inv2[1] * p.x + inv2[3] * p.y + inv2[5];
-        if (i === 0) {
-          ctx.moveTo(x, y);
-        } else {
-          ctx.lineTo(x, y);
-        }
-      });
-      ctx.closePath();
-    }
+    traceOutline(ctx, outline);
     ctx.fill("nonzero");
   } finally {
     ctx.restore();
   }
   return true;
 }
+var IDENTITY5 = [1, 0, 0, 1, 0, 0];
 function isIdentity2(m) {
   return m[0] === 1 && m[1] === 0 && m[2] === 0 && m[3] === 1 && m[4] === 0 && m[5] === 0;
 }
@@ -24213,7 +24770,7 @@ function imageResampleSpec(rCtx, dataOff, isMetafile, toWorld) {
     ...imageAttributesWrap(rCtx, view.getUint32(dataOff, true))
   };
 }
-function drawOrDeferImage(rCtx, imgObj, dataOff, dx, dy, dw, dh, toWorld) {
+function drawOrDeferImage(rCtx, imgObj, dataOff, dx, dy, dw, dh, toWorld, effect = null) {
   if (!imgObj.data) {
     return;
   }
@@ -24237,7 +24794,7 @@ function drawOrDeferImage(rCtx, imgObj, dataOff, dx, dy, dw, dh, toWorld) {
     srcH: view.getFloat32(dataOff + 20, true),
     toWorld
   };
-  if (drawEmfPlusImageNow(rCtx, imgObj, draw, source)) {
+  if (drawEmfPlusImageNow(rCtx, imgObj, draw, source, effect)) {
     return;
   }
   if (isSvgContext(rCtx.ctx)) {
@@ -24601,6 +25158,10 @@ function handleEmfPlusTextImageRecord(rCtx, recType, recFlags, dataOff, recDataS
         const imgObj = objectTable.get(imgId);
         const count = view.getUint32(dataOff + 24, true);
         const ptOff = dataOff + 28;
+        const effect = (recFlags & DRAWIMAGE_EFFECT_FLAG) !== 0 ? rCtx.ext?.pendingEffect ?? null : null;
+        if (rCtx.ext) {
+          rCtx.ext.pendingEffect = null;
+        }
         if (count >= 3 && imgObj && imgObj.kind === "plus-image" && imgObj.data) {
           const pts = readPlusPoints(view, ptOff, dataOff + recDataSize, 3, recFlags);
           if (!pts) {
@@ -24624,7 +25185,7 @@ function handleEmfPlusTextImageRecord(rCtx, recType, recFlags, dataOff, recDataS
             const c = (p3x - p1x) / sh;
             const d = (p3y - p1y) / sh;
             return [a, b, c, d, p1x - a * sx - c * sy, p1y - b * sx - d * sy];
-          });
+          }, effect);
         } else {
           imgObj && imgObj.kind === "plus-image" && imgObj.data;
         }
@@ -25454,12 +26015,14 @@ function replayEmfPlusRecords(view, offset, length, ctx, canvasW, canvasH, state
     recordCount++;
     emfPlusRecordTypes.set(recType, (emfPlusRecordTypes.get(recType) ?? 0) + 1);
     const dataOff = offset + 12;
+    s.gdiPassthrough = recType === EMFPLUS_GETDC;
     if (rCtx.ext?.multiFormatSkip && recType !== EMFPLUS_ENDOFFILE) {
       offset += recSize;
       continue;
     }
     switch (recType) {
       case EMFPLUS_HEADER: {
+        s.dualMode = (recFlags & 1) !== 0;
         if (recDataSize >= 16) {
           view.getFloat32(dataOff + 8, true);
           view.getFloat32(dataOff + 12, true);
@@ -25478,6 +26041,12 @@ function replayEmfPlusRecords(view, offset, length, ctx, canvasW, canvasH, state
       case EMFPLUS_MULTIFORMATSECTION:
       case EMFPLUS_MULTIFORMATEND:
         break;
+      // An image effect for the next DrawImagePoints with flag E
+      // (`emf-plus-image-effects.ts`); an unknown or malformed effect
+      // replaces any earlier one with none.
+      case EMFPLUS_SERIALIZABLEOBJECT:
+        (rCtx.ext ?? (rCtx.ext = {})).pendingEffect = parseSerializableObject(view, dataOff, recDataSize);
+        break;
       case EMFPLUS_CLEAR: {
         if (recDataSize >= 4) {
           const argb = view.getUint32(dataOff, true);
@@ -25624,11 +26193,16 @@ function replayEmfRecords(view, ctx, bounds, canvasW, canvasH, dpiScale = 1, rep
     state: { ...defaultState(), fontFamilyMap: replayOptions.fontFamilyMap },
     stateStack: [],
     inPath: false,
-    windowOrg: { x: bounds.left, y: bounds.top },
+    // GDI's defaults: both origins at 0 and a 1:1 window/viewport ratio.
+    // The window/viewport mapping yields device units, placed on the
+    // canvas like every other device coordinate (bounds' top-left to the
+    // canvas origin, scaled by sx/sy); see `deviceToCanvas`.
+    windowOrg: { x: 0, y: 0 },
     windowExt: { cx: logicalW, cy: logicalH },
     viewportOrg: { x: 0, y: 0 },
-    viewportExt: { cx: canvasW, cy: canvasH },
+    viewportExt: { cx: logicalW, cy: logicalH },
     useMappingMode: false,
+    deviceToCanvas: true,
     clipSaveDepth: 0,
     bounds,
     canvasW,
@@ -25715,6 +26289,13 @@ function replayEmfRecords(view, ctx, bounds, canvasW, canvasH, dpiScale = 1, rep
       offset += recSize;
       continue;
     }
+    if (emfPlusState.dualMode && !emfPlusState.gdiPassthrough) {
+      if (recType !== EMR_SAVEDC && recType !== EMR_RESTOREDC) {
+        handleEmfGdiStateRecord(rCtx, recType, offset, dataOff, recSize);
+      }
+      offset += recSize;
+      continue;
+    }
     const handled = handleEmfGdiStateRecord(rCtx, recType, offset, dataOff, recSize) || handleEmfGdiDrawRecord(rCtx, recType, offset, dataOff, recSize) || handleEmfGdiPolyPathRecord(rCtx, recType, offset, dataOff, recSize);
     if (!handled) {
       console.warn(`[emf-converter] Unhandled EMR record type: ${recType}`);