emf-converter 4.0.0 → 4.2.0

package/dist/index.js

@@ -24,9 +24,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")}`;
   }
@@ -386,8 +386,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) {
@@ -493,6 +493,23 @@ function totalGlyphAdvance(dx) {
   }
   return sum;
 }
+function applyTextJustification(advances, characters, extra, count) {
+  const result = advances.slice();
+  if (extra === 0 || count <= 0) {
+    return result;
+  }
+  let seen = 0;
+  for (let i = 0; i < result.length && i < characters.length; i++) {
+    if (characters[i] !== 32) {
+      continue;
+    }
+    const before = Math.round(seen * extra / count);
+    seen++;
+    const after = Math.round(seen * extra / count);
+    result[i] += after - before;
+  }
+  return result;
+}
 function alignmentStartOffset(totalWidth, align) {
   if (align === "center") {
     return -totalWidth / 2;
@@ -629,8 +646,11 @@ var EMR_PAINTRGN = 74;
 var EMR_MASKBLT = 78;
 var EMR_PLGBLT = 79;
 var EMR_SETDIBITSTODEVICE = 80;
+var EMR_EXTTEXTOUTA = 83;
 var EMR_POLYPOLYLINE16 = 90;
 var EMR_POLYDRAW16 = 92;
+var EMR_POLYTEXTOUTA = 96;
+var EMR_POLYTEXTOUTW = 97;
 var EMR_CREATECOLORSPACE = 99;
 var EMR_SETCOLORSPACE = 100;
 var EMR_DELETECOLORSPACE = 101;
@@ -639,6 +659,7 @@ var EMR_GLSBOUNDEDRECORD = 103;
 var EMR_PIXELFORMAT = 104;
 var EMR_DRAWESCAPE = 105;
 var EMR_EXTESCAPE = 106;
+var EMR_SMALLTEXTOUT = 108;
 var EMR_FORCEUFIMAPPING = 109;
 var EMR_NAMEDESCAPE = 110;
 var EMR_COLORCORRECTPALETTE = 111;
@@ -709,6 +730,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;
@@ -13102,7 +13124,7 @@ function parseEmfPlusPenObject(view, dataOff, recDataSize, textureCache, cacheKe
     o += 4;
     return v;
   };
-  const pen = { kind: "plus-pen", color: "rgba(0,0,0,1)", width: penWidth || 1, dashStyle: 0 };
+  const pen = { kind: "plus-pen", color: "rgba(0,0,0,1)", width: penWidth, dashStyle: 0 };
   if (penFlags & PEN_TRANSFORM) {
     if (o + 24 <= end) {
       pen.transform = [0, 4, 8, 12, 16, 20].map((k) => view.getFloat32(o + k, true));
@@ -13719,7 +13741,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;
 }
@@ -13727,24 +13750,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;
 }
@@ -13757,13 +13787,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;
@@ -14938,19 +14969,7 @@ var SvgContext = class {
     }
   }
   // ---- text ---------------------------------------------------------------
-  measurer() {
-    if (this.measureCtx === void 0) {
-      const temp = createTempCanvas(1, 1);
-      this.measureCtx = temp && !isSoftwareRaster(temp.canvas) ? temp.ctx : null;
-    }
-    return this.measureCtx;
-  }
   measureText(text) {
-    const real = this.shadow ?? this.measurer();
-    if (real) {
-      real.font = this.state.font;
-      return real.measureText(text);
-    }
     const size = parseFont(this.state.font).size;
     return { width: estimateTextWidth(text, size) };
   }
@@ -15650,8 +15669,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;
@@ -17950,7 +17969,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;
@@ -17966,7 +17985,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;
       }
@@ -20348,8 +20367,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,
@@ -20584,10 +20603,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));
@@ -20955,10 +20974,109 @@ function handleEmfGdiBlendBlitRecord(rCtx, recType, offset, dataOff, recSize) {
   }
 }
 
+// src/emf-ansi.ts
+var CP1252_HIGH2 = [
+  8364,
+  129,
+  8218,
+  402,
+  8222,
+  8230,
+  8224,
+  8225,
+  710,
+  8240,
+  352,
+  8249,
+  338,
+  141,
+  381,
+  143,
+  144,
+  8216,
+  8217,
+  8220,
+  8221,
+  8226,
+  8211,
+  8212,
+  732,
+  8482,
+  353,
+  8250,
+  339,
+  157,
+  382,
+  376
+];
+function ansiToCode(b, charSet) {
+  return charSet === 2 ? b : b >= 128 && b <= 159 ? CP1252_HIGH2[b - 128] : b;
+}
+var CHARSET_ENCODING = {
+  0: "windows-1252",
+  1: "windows-1252",
+  128: "shift_jis",
+  129: "euc-kr",
+  130: "johab",
+  134: "gbk",
+  136: "big5",
+  161: "windows-1253",
+  162: "windows-1254",
+  163: "windows-1258",
+  177: "windows-1255",
+  178: "windows-1256",
+  186: "windows-1257",
+  204: "windows-1251",
+  222: "windows-874",
+  238: "windows-1250",
+  255: "ibm437"
+};
+function decodeAnsiRecord(bytes, charSet) {
+  if (charSet === 2) {
+    return { codes: [...bytes], byteLengths: bytes.map(() => 1) };
+  }
+  const label = CHARSET_ENCODING[charSet] ?? "windows-1252";
+  try {
+    const decoder = new TextDecoder(label, { fatal: true });
+    const replacementDecoder = new TextDecoder(label);
+    const source = new Uint8Array(bytes);
+    const codes = [];
+    const byteLengths = [];
+    let i = 0;
+    while (i < bytes.length) {
+      let decoded = null;
+      let consumed = 1;
+      for (let n = 1; n <= Math.min(4, bytes.length - i); n++) {
+        try {
+          const candidate = decoder.decode(source.subarray(i, i + n));
+          if (candidate.length > 0) {
+            decoded = candidate;
+            consumed = n;
+            break;
+          }
+        } catch {
+        }
+      }
+      if (decoded === null) {
+        decoded = replacementDecoder.decode(source.subarray(i, i + 1));
+      }
+      for (let j = 0; j < decoded.length; j++) {
+        codes.push(decoded.charCodeAt(j));
+        byteLengths.push(j === decoded.length - 1 ? consumed : 0);
+      }
+      i += consumed;
+    }
+    return { codes, byteLengths };
+  } catch {
+    return { codes: bytes.map((b) => ansiToCode(b, charSet)), byteLengths: bytes.map(() => 1) };
+  }
+}
+
 // src/gdi-text-render.ts
 var ETO_OPAQUE = 2;
 var ETO_CLIPPED = 4;
 var ETO_GLYPH_INDEX = 16;
+var ETO_IGNORELANGUAGE = 4096;
 var ETO_PDY = 8192;
 var GRAY_INV_GAMMA = 0.43;
 var GRAY_BLACK_ON_WHITE = [255, 255, 240, 233, 225, 217, 208, 199, 189, 178, 167, 154, 140, 124, 104, 77, 0];
@@ -21039,15 +21157,24 @@ function fillDeviceQuad(ctx, pts, color, clip) {
   ctx.fill();
   ctx.restore();
 }
+function isC1Control(code) {
+  return code >= 128 && code <= 159;
+}
+function suppressC1Glyph(run, index) {
+  return !run.glyphIndices && !(run.options & ETO_IGNORELANGUAGE) && isC1Control(run.codes[index]);
+}
 function layoutGdiRun(font, run) {
   const n = run.codes.length;
   const glyphs = run.codes.map((c) => run.glyphIndices ? c : font.glyphIndex(c));
-  const adv = [];
+  let adv = [];
   for (let i = 0; i < n; i++) {
     adv.push(
-      run.dx && i < run.dx.length ? run.dx[i] : run.matrix ? font.rotatedAdvance(glyphs[i]) : font.advance(glyphs[i])
+      suppressC1Glyph(run, i) && !run.dx ? 0 : run.dx && i < run.dx.length ? run.dx[i] : run.matrix ? font.rotatedAdvance(glyphs[i]) : font.advance(glyphs[i])
     );
   }
+  if (!run.dx && run.textJustification && !run.glyphIndices) {
+    adv = applyTextJustification(adv, run.codes, run.textJustification.extra, run.textJustification.count);
+  }
   const advY = [];
   for (let i = 0; i < n; i++) {
     advY.push(run.dy && i < run.dy.length ? run.dy[i] : 0);
@@ -21090,9 +21217,11 @@ function layoutGdiRun(font, run) {
     const subX = font.gridFit ? 0 : Math.round((origin.x - ox) * 64);
     const oy = Math.round(origin.y);
     origins.push({ x: ox + subX / 64, y: oy, along, down });
-    const g = font.glyph(glyphs[i], gm, subX);
-    if (g.bitmap) {
-      placed.push({ x: ox + g.bitmap.left, y: oy - g.bitmap.top, bitmap: g.bitmap });
+    if (!suppressC1Glyph(run, i)) {
+      const g = font.glyph(glyphs[i], gm, subX);
+      if (g.bitmap) {
+        placed.push({ x: ox + g.bitmap.left, y: oy - g.bitmap.top, bitmap: g.bitmap });
+      }
     }
     along += adv[i];
     down += advY[i];
@@ -21177,21 +21306,25 @@ function paintGdiTextRun(ctx, font, run, fontFamilyMap) {
 }
 function emitSvgRun(ctx, font, run, glyphs, origins, fontFamilyMap) {
   let text = "";
+  const visibleOrigins = [];
   for (let i = 0; i < origins.length; i++) {
     const code = run.glyphIndices ? font.charForGlyph(glyphs[i]) : run.codes[i];
+    if (!run.glyphIndices && !(run.options & ETO_IGNORELANGUAGE) && isC1Control(code)) continue;
     text += String.fromCharCode(code);
+    visibleOrigins.push(origins[i]);
   }
+  if (text.length === 0) return;
   const m = run.matrix;
   const ttf = font.ttf;
   const bold = font.syntheticBold || ttf.weightClass >= 600;
   const italic = font.syntheticItalic || (ttf.fsSelection & 1) !== 0 || (ttf.macStyle & 2) !== 0;
-  const first = origins[0];
+  const first = visibleOrigins[0];
   ctx.fillGlyphRun({
     text,
     // Upright runs: device positions. Rotated runs: offsets along/across
     // the baseline from the first glyph, under the frame matrix.
-    xs: origins.map((o) => m ? o.along - first.along : o.x),
-    ys: origins.map((o) => m ? o.down - first.down : o.y),
+    xs: visibleOrigins.map((o) => m ? o.along - first.along : o.x),
+    ys: visibleOrigins.map((o) => m ? o.down - first.down : o.y),
     matrix: m ? [m[0], m[1], m[2], m[3], first.x, first.y] : null,
     scaleX: font.ppemX !== font.ppem ? font.ppemX / font.ppem : 1,
     fontFamily: mapFontFamily(ttf.family, fontFamilyMap),
@@ -21362,6 +21495,7 @@ function drawGdiTextCall(ctx, fonts, state, call) {
     y: ref.y,
     dx: call.dx ? call.dx.map((v) => v * advanceScale) : null,
     dy: call.dy ? call.dy.map((v) => -v * fontScale) : null,
+    textJustification: call.textJustification ? { ...call.textJustification, extra: call.textJustification.extra * advanceScale } : void 0,
     textAlign: state.textAlign,
     textColor: state.textColor,
     bkColor: state.bkColor,
@@ -21498,11 +21632,11 @@ function readDxArray(view, offset, dataOff, nChars, viewEnd) {
   }
   const dx = [];
   for (let i = 0; i < nChars; i++) {
-    dx.push(view.getUint32(start + i * 4, true));
+    dx.push(view.getInt32(start + i * 4, true));
   }
   return dx;
 }
-function drawWithFontEngine(rCtx, offset, dataOff, nChars, offString) {
+function drawWithFontEngine(rCtx, offset, dataOff, nChars, offString, viewEnd) {
   const { ctx, view, state } = rCtx;
   const fonts = rCtx.fonts;
   if (!fonts) {
@@ -21514,7 +21648,7 @@ function drawWithFontEngine(rCtx, offset, dataOff, nChars, offString) {
     codes.push(view.getUint16(offset + offString + i * 2, true));
   }
   const pdy = (options & ETO_PDY) !== 0;
-  const raw = readDxArray(view, offset, dataOff, pdy ? nChars * 2 : nChars, view.byteLength);
+  const raw = readDxArray(view, offset, dataOff, pdy ? nChars * 2 : nChars, viewEnd);
   let dx = raw;
   let dy = null;
   if (raw && pdy) {
@@ -21539,7 +21673,8 @@ function drawWithFontEngine(rCtx, offset, dataOff, nChars, offString) {
     },
     dx,
     dy,
-    matrix: gdiDeviceMatrix(rCtx)
+    matrix: gdiDeviceMatrix(rCtx),
+    textJustification: state.textJustification
   });
   if (!adv) {
     return false;
@@ -21551,12 +21686,12 @@ function drawWithFontEngine(rCtx, offset, dataOff, nChars, offString) {
   return true;
 }
 function horizontalAlign(textAlign) {
+  if ((textAlign & 6) === 6) {
+    return "center";
+  }
   if (textAlign & 2) {
     return "right";
   }
-  if (textAlign & 6) {
-    return "center";
-  }
   return "left";
 }
 function verticalBaseline(textAlign) {
@@ -21598,11 +21733,11 @@ function handleExtTextOutW(rCtx, offset, dataOff, recSize) {
   const refY = view.getInt32(dataOff + 32, true);
   const nChars = view.getUint32(dataOff + 36, true);
   const offString = view.getUint32(dataOff + 40, true);
-  const viewEnd = view.byteLength;
-  if (nChars === 0 || offString === 0 || offset + offString + nChars * 2 > viewEnd) {
+  const viewEnd = Math.min(view.byteLength, offset + recSize);
+  if (nChars === 0 || offString === 0 || nChars > Math.floor((viewEnd - offset - offString) / 2)) {
     return true;
   }
-  if (drawWithFontEngine(rCtx, offset, dataOff, nChars, offString)) {
+  if (drawWithFontEngine(rCtx, offset, dataOff, nChars, offString, viewEnd)) {
     return true;
   }
   const text = readUtf16LE(view, offset + offString, nChars);
@@ -21617,8 +21752,16 @@ function handleExtTextOutW(rCtx, offset, dataOff, recSize) {
   const align = horizontalAlign(state.textAlign);
   ctx.textBaseline = verticalBaseline(state.textAlign);
   ctx.textAlign = align === "center" ? "center" : align === "right" ? "right" : "left";
-  const dxLogical = readDxArray(view, offset, dataOff, nChars, viewEnd);
-  const dxDevice = dxLogical ? dxLogical.map((v) => advanceScale !== null ? v * advanceScale : gmw(rCtx, v)) : null;
+  const pdy = (view.getUint32(dataOff + 44, true) & ETO_PDY) !== 0;
+  const dxRaw = readDxArray(view, offset, dataOff, pdy ? nChars * 2 : nChars, viewEnd);
+  const dxLogical = dxRaw && pdy ? dxRaw.filter((_, i) => i % 2 === 0) : dxRaw;
+  let dxDevice = dxLogical ? dxLogical.map((v) => advanceScale !== null ? v * advanceScale : gmw(rCtx, v)) : null;
+  if (!dxDevice && state.textJustification && !pdy) {
+    const units = text.split("");
+    const natural = units.map((ch) => ctx.measureText(ch).width);
+    const scale = advanceScale ?? gmw(rCtx, 1);
+    dxDevice = applyTextJustification(natural, units.map((ch) => ch.charCodeAt(0)), state.textJustification.extra * scale, state.textJustification.count);
+  }
   if (dxDevice) {
     ctx.textAlign = "left";
   }
@@ -21651,10 +21794,118 @@ function handleExtTextOutW(rCtx, offset, dataOff, recSize) {
   }
   return true;
 }
+function drawTextCall(rCtx, x, y, codes, options, rect, dx) {
+  const n = codes.length;
+  const offString = 76;
+  const offDx = offString + n * 2 + 3 & -4;
+  const dxCount = dx ? dx.length : 0;
+  const size = offDx + dxCount * 4;
+  const view = new DataView(new ArrayBuffer(size));
+  view.setUint32(44, n, true);
+  view.setUint32(48, offString, true);
+  view.setUint32(52, options, true);
+  view.setInt32(36, x, true);
+  view.setInt32(40, y, true);
+  view.setInt32(56, rect[0], true);
+  view.setInt32(60, rect[1], true);
+  view.setInt32(64, rect[2], true);
+  view.setInt32(68, rect[3], true);
+  view.setUint32(72, dx ? offDx : 0, true);
+  for (let i = 0; i < n; i++) view.setUint16(offString + i * 2, codes[i], true);
+  if (dx) for (let i = 0; i < dxCount; i++) view.setInt32(offDx + i * 4, dx[i], true);
+  const child = { ...rCtx, view };
+  handleExtTextOutW(child, 0, 8, size);
+}
+function readAnsiRecord(view, start, count, charSet) {
+  return decodeAnsiRecord(Array.from({ length: count }, (_, i) => view.getUint8(start + i)), charSet);
+}
+function collapseAnsiDx(dx, byteLengths, pdy) {
+  if (!dx) return null;
+  const result = [];
+  let at = 0;
+  for (const bytes of byteLengths) {
+    let x = 0, y = 0;
+    for (let i = 0; i < bytes; i++) {
+      x += dx[at + i * (pdy ? 2 : 1)] ?? 0;
+      if (pdy) y += dx[at + i * 2 + 1] ?? 0;
+    }
+    result.push(x);
+    if (pdy) result.push(y);
+    at += bytes * (pdy ? 2 : 1);
+  }
+  return result;
+}
+function handlePolyText(rCtx, offset, dataOff, recSize, wide) {
+  const { view, state } = rCtx;
+  const end = Math.min(view.byteLength, offset + recSize);
+  if (recSize < 40) return true;
+  const count = view.getUint32(dataOff + 28, true);
+  const arrayStart = dataOff + 32;
+  if (count > Math.floor((end - arrayStart) / 40)) return true;
+  const charSet = state.fontDetails?.charSet ?? 1;
+  for (let i = 0; i < count; i++) {
+    const e = arrayStart + i * 40;
+    const x = view.getInt32(e, true), y = view.getInt32(e + 4, true);
+    const n = view.getUint32(e + 8, true), offString = view.getUint32(e + 12, true);
+    const options = view.getUint32(e + 16, true);
+    const rect = [view.getInt32(e + 20, true), view.getInt32(e + 24, true), view.getInt32(e + 28, true), view.getInt32(e + 32, true)];
+    const offDx = view.getUint32(e + 36, true);
+    const unit = wide ? 2 : 1;
+    if (!offString || offString > end - offset || n > Math.floor((end - (offset + offString)) / unit)) continue;
+    const ansi = wide ? null : readAnsiRecord(view, offset + offString, n, charSet);
+    const codes = wide ? Array.from({ length: n }, (_, j) => view.getUint16(offset + offString + j * 2, true)) : ansi.codes;
+    let dx = null;
+    const pdy = (options & ETO_PDY) !== 0;
+    const dxCount = n * (pdy ? 2 : 1);
+    if (offDx && offDx <= end - offset && dxCount <= Math.floor((end - (offset + offDx)) / 4)) {
+      dx = Array.from({ length: dxCount }, (_, j) => view.getInt32(offset + offDx + j * 4, true));
+      if (!wide) dx = collapseAnsiDx(dx, ansi.byteLengths, pdy);
+    }
+    drawTextCall(rCtx, x, y, codes, options, rect, dx);
+  }
+  return true;
+}
+function handleSmallTextOut(rCtx, offset, dataOff, recSize) {
+  const { view } = rCtx;
+  const end = Math.min(view.byteLength, offset + recSize);
+  if (recSize < 36) return true;
+  const x = view.getInt32(dataOff, true), y = view.getInt32(dataOff + 4, true);
+  const n = view.getUint32(dataOff + 8, true), options = view.getUint32(dataOff + 12, true);
+  const small = (options & 512) !== 0, noRect = (options & 256) !== 0;
+  const base = dataOff + 28 + (noRect ? 0 : 16);
+  if (base > end || n > Math.floor((end - base) / (small ? 1 : 2))) return true;
+  const rect = noRect ? [0, 0, 0, 0] : [view.getInt32(dataOff + 28, true), view.getInt32(dataOff + 32, true), view.getInt32(dataOff + 36, true), view.getInt32(dataOff + 40, true)];
+  const codes = small ? Array.from({ length: n }, (_, i) => view.getUint8(base + i)) : Array.from({ length: n }, (_, i) => view.getUint16(base + i * 2, true));
+  drawTextCall(rCtx, x, y, codes, options, rect, null);
+  return true;
+}
 function handleEmfGdiDrawTextRecord(rCtx, recType, offset, dataOff, recSize) {
   if (recType === EMR_EXTTEXTOUTW) {
     return handleExtTextOutW(rCtx, offset, dataOff, recSize);
   }
+  if (recType === EMR_EXTTEXTOUTA || recType === EMR_POLYTEXTOUTA || recType === EMR_POLYTEXTOUTW || recType === EMR_SMALLTEXTOUT) {
+    if (recType === EMR_POLYTEXTOUTA || recType === EMR_POLYTEXTOUTW) return handlePolyText(rCtx, offset, dataOff, recSize, recType === EMR_POLYTEXTOUTW);
+    if (recType === EMR_SMALLTEXTOUT) return handleSmallTextOut(rCtx, offset, dataOff, recSize);
+    const { view, state } = rCtx;
+    const end = Math.min(view.byteLength, offset + recSize);
+    if (recSize < 76) return true;
+    const x = view.getInt32(dataOff + 28, true), y = view.getInt32(dataOff + 32, true);
+    const n = view.getUint32(dataOff + 36, true), strOff = view.getUint32(dataOff + 40, true), options = view.getUint32(dataOff + 44, true);
+    if (!strOff || strOff > end - offset) return true;
+    if (n > end - (offset + strOff)) return true;
+    const ansi = readAnsiRecord(view, offset + strOff, n, state.fontDetails?.charSet ?? 1);
+    const rect = [view.getInt32(dataOff + 48, true), view.getInt32(dataOff + 52, true), view.getInt32(dataOff + 56, true), view.getInt32(dataOff + 60, true)];
+    const offDx = view.getUint32(dataOff + 64, true);
+    let dx = null;
+    const pdy = (options & ETO_PDY) !== 0;
+    const dxCount = n * (pdy ? 2 : 1);
+    if (offDx && offDx <= end - offset && dxCount <= Math.floor((end - (offset + offDx)) / 4)) {
+      dx = Array.from({ length: dxCount }, (_, i) => view.getInt32(offset + offDx + i * 4, true));
+      dx = collapseAnsiDx(dx, ansi.byteLengths, pdy);
+    }
+    drawTextCall(rCtx, x, y, ansi.codes, options, rect, dx);
+    return true;
+  }
   return false;
 }
 
@@ -23284,6 +23535,412 @@ 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);
+  }
+}
+
 // src/emf-plus-draw-image.ts
 function surfaceSize4(ctx) {
   const canvas = ctx.canvas;
@@ -23346,8 +24003,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;
   }
@@ -23419,14 +24076,32 @@ function drawNestedMetafile(rCtx, img, cached, source) {
   rCtx.deferredImages.push(...deferred);
   return true;
 }
-function drawEmfPlusImageNow(rCtx, img, draw, source) {
+function effectedBitmap(img, bitmap, effect) {
+  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 rgba = applyImageEffect(src.rgba, src.width, src.height, effect);
+  return rgba ? { kind: "bitmap", width: src.width, height: src.height, rgba } : null;
+}
+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;
+  let bitmap = cached && cached.kind === "bitmap" ? cached : null;
+  const effected = effect ? effectedBitmap(img, bitmap, effect) : null;
+  if (effected) {
+    bitmap = effected;
+  }
   if (isSvgContext(rCtx.ctx)) {
-    return paintBitmapSvg(rCtx.ctx, img, bitmap, draw);
+    return paintBitmapSvg(rCtx.ctx, img, bitmap, draw, effected !== null);
   }
   return bitmap ? paintBitmapRaster(rCtx.ctx, bitmap, draw) : false;
 }
@@ -23667,7 +24342,7 @@ function penDashArray(pen) {
   return pattern.map((v) => v * w);
 }
 function applyPlusPenStyle(ctx, pen, widthScale = 1) {
-  ctx.lineWidth = pen.width * widthScale;
+  ctx.lineWidth = (pen.width || 1) * widthScale;
   const dashes = penDashArray(pen);
   ctx.lineCap = canvasLineCap(dashes.length > 0 ? pen.dashCap ?? 0 : pen.startCap ?? pen.endCap);
   ctx.lineJoin = canvasLineJoin(pen.lineJoin);
@@ -23679,19 +24354,27 @@ function applyPlusPenStyle(ctx, pen, widthScale = 1) {
 }
 function strokePlusGeometry(rCtx, pen, buildPath, points, closedFigure = false) {
   const { ctx } = rCtx;
+  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();
     }
   };
@@ -23706,8 +24389,8 @@ 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);
@@ -23725,6 +24408,9 @@ function strokePlusGeometry(rCtx, pen, buildPath, points, closedFigure = false)
           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))
@@ -23732,55 +24418,105 @@ function strokePlusGeometry(rCtx, pen, buildPath, points, closedFigure = false)
         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 strokeGdiplus(rCtx, pen, sampler, buildPath, device, size, mode, closedFigure) {
-  if (pen.transform && !isIdentity2(pen.transform)) {
-    return false;
+function resolvePenTransform(pen) {
+  if (!pen?.transform) {
+    return { pen, 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;
+  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;
+  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 };
   }
-  let figures;
-  try {
-    figures = recordDeviceFigures(buildPath, device);
-  } catch {
-    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 };
   }
-  if (closedFigure) {
-    figures = figures.map((f) => ({ ...f, closed: true }));
+  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 };
   }
-  const width = (pen.width || 1) * sx;
-  const dash = penDashArray(pen).map((v) => v * sx);
-  const devicePen = {
-    half: width / 2,
+  const full = mulMatrix(device, nib);
+  const unit = maxStretch(full);
+  const inv2 = invertAffine(nib);
+  if (!inv2 || !(unit > 0) || !Number.isFinite(unit)) {
+    return null;
+  }
+  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) {
@@ -23843,54 +24579,36 @@ function customCapOutline(figures, width, devicePen, pen) {
   outline.push(...geo.polygons);
   return outline;
 }
-function fillCustomCapStroke(rCtx, pen, buildPath, closedFigure) {
+function fillPenOutline(rCtx, pen, nib, paint, 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) {
+  const frame2 = penFrame(device, nib);
+  const deviceInv = invertAffine(device);
+  if (!frame2 || !deviceInv || !(frame2.unit > 0)) {
     return false;
   }
   let figures;
   try {
-    figures = recordDeviceFigures(buildPath, device);
+    figures = recordDeviceFigures(buildPath, frame2.record);
   } catch {
     return false;
   }
   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 toWorld = mulMatrix(deviceInv, frame2.toDevice);
   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)) {
+    for (const poly of outline) {
       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];
+        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 {
@@ -23905,6 +24623,7 @@ function fillCustomCapStroke(rCtx, pen, buildPath, closedFigure) {
   }
   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;
 }
@@ -23957,7 +24676,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;
   }
@@ -23981,7 +24700,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)) {
@@ -24153,6 +24872,7 @@ function drawPlusStringWithEngine(rCtx, font, text, layoutX, layoutY, paint, ali
       dx,
       dy: null,
       textAlign: 24,
+      options: 0,
       matrix: null});
     if (!cov) {
       return true;
@@ -24344,6 +25064,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) {
@@ -24367,7 +25091,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;
         }
@@ -25197,12 +25921,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);
@@ -25221,6 +25947,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);
@@ -25367,11 +26099,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,
@@ -25458,6 +26195,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}`);
@@ -26867,46 +27611,6 @@ function penIsNull(p) {
 }
 
 // src/wmf-text.ts
-var CP1252_HIGH2 = [
-  8364,
-  129,
-  8218,
-  402,
-  8222,
-  8230,
-  8224,
-  8225,
-  710,
-  8240,
-  352,
-  8249,
-  338,
-  141,
-  381,
-  143,
-  144,
-  8216,
-  8217,
-  8220,
-  8221,
-  8226,
-  8211,
-  8212,
-  732,
-  8482,
-  353,
-  8250,
-  339,
-  157,
-  382,
-  376
-];
-function ansiToCode(b, charSet) {
-  if (charSet === 2) {
-    return b;
-  }
-  return b >= 128 && b <= 159 ? CP1252_HIGH2[b - 128] : b;
-}
 function fontAdvances(p, codes) {
   const fonts = p.rCtx.fonts;
   if (!fonts) {