emf-converter 1.4.3 → 1.6.0

package/dist/index.js

@@ -1,6 +1,229 @@
 'use strict';
 
-// src/emf-logging.ts
+// src/emf-color-helpers.ts
+function colorRefToHex(r, g, b) {
+  const toHex = (v) => v.toString(16).padStart(2, "0");
+  return `#${toHex(r & 255)}${toHex(g & 255)}${toHex(b & 255)}`;
+}
+function readColorRef(view, offset) {
+  const r = view.getUint8(offset);
+  const g = view.getUint8(offset + 1);
+  const b = view.getUint8(offset + 2);
+  return colorRefToHex(r, g, b);
+}
+function argbToRgba(argb) {
+  const a = (argb >>> 24 & 255) / 255;
+  const r = argb >>> 16 & 255;
+  const g = argb >>> 8 & 255;
+  const b = argb & 255;
+  return `rgba(${r},${g},${b},${a.toFixed(3)})`;
+}
+function lerpArgbToRgba(argbA, argbB, t) {
+  const tc = Math.min(1, Math.max(0, t));
+  const mix = (a2, b2) => Math.round(a2 + (b2 - a2) * tc);
+  const aA = argbA >>> 24 & 255;
+  const aB = argbB >>> 24 & 255;
+  const r = mix(argbA >>> 16 & 255, argbB >>> 16 & 255);
+  const g = mix(argbA >>> 8 & 255, argbB >>> 8 & 255);
+  const b = mix(argbA & 255, argbB & 255);
+  const a = mix(aA, aB) / 255;
+  return `rgba(${r},${g},${b},${a.toFixed(3)})`;
+}
+function invertCssColor(color) {
+  const hex = /^#([0-9a-f]{6})$/i.exec(color);
+  if (hex) {
+    const v = parseInt(hex[1], 16);
+    const inv = 16777215 ^ v;
+    return `#${inv.toString(16).padStart(6, "0")}`;
+  }
+  const shortHex = /^#([0-9a-f]{3})$/i.exec(color);
+  if (shortHex) {
+    const [r, g, b] = shortHex[1].split("").map((c) => parseInt(c + c, 16));
+    const toHex = (v) => (255 - v).toString(16).padStart(2, "0");
+    return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+  }
+  const rgba = /^rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*([\d.]+)\s*)?\)$/i.exec(color);
+  if (rgba) {
+    const r = 255 - Math.min(255, parseInt(rgba[1], 10));
+    const g = 255 - Math.min(255, parseInt(rgba[2], 10));
+    const b = 255 - Math.min(255, parseInt(rgba[3], 10));
+    return rgba[4] !== void 0 ? `rgba(${r},${g},${b},${rgba[4]})` : `rgb(${r},${g},${b})`;
+  }
+  return color;
+}
+
+// src/emf-constants.ts
+var EMR_HEADER = 1;
+var EMR_POLYBEZIER = 2;
+var EMR_POLYGON = 3;
+var EMR_POLYLINE = 4;
+var EMR_POLYBEZIERTO = 5;
+var EMR_POLYLINETO = 6;
+var EMR_POLYPOLYLINE = 7;
+var EMR_POLYPOLYGON = 8;
+var EMR_SETWINDOWEXTEX = 9;
+var EMR_SETWINDOWORGEX = 10;
+var EMR_SETVIEWPORTEXTEX = 11;
+var EMR_SETVIEWPORTORGEX = 12;
+var EMR_SETBRUSHORGEX = 13;
+var EMR_EOF = 14;
+var EMR_SETPIXELV = 15;
+var EMR_SETMAPMODE = 17;
+var EMR_SETBKMODE = 18;
+var EMR_SETPOLYFILLMODE = 19;
+var EMR_SETROP2 = 20;
+var EMR_SETSTRETCHBLTMODE = 21;
+var R2_BLACK = 1;
+var R2_NOTMERGEPEN = 2;
+var R2_MASKNOTPEN = 3;
+var R2_NOTCOPYPEN = 4;
+var R2_MASKPENNOT = 5;
+var R2_NOT = 6;
+var R2_XORPEN = 7;
+var R2_NOTMASKPEN = 8;
+var R2_MASKPEN = 9;
+var R2_NOTXORPEN = 10;
+var R2_NOP = 11;
+var R2_MERGENOTPEN = 12;
+var R2_MERGEPENNOT = 14;
+var R2_MERGEPEN = 15;
+var R2_WHITE = 16;
+var MAX_CANVAS_DIMENSION = 8192;
+var MAX_RECORDS_DEFAULT = 2e5;
+var MAX_RECORDS_EMFPLUS_DEFAULT = 5e5;
+var EMR_SETTEXTALIGN = 22;
+var EMR_SETTEXTCOLOR = 24;
+var EMR_SETBKCOLOR = 25;
+var EMR_OFFSETCLIPRGN = 26;
+var EMR_MOVETOEX = 27;
+var EMR_SETMETARGN = 28;
+var EMR_EXCLUDECLIPRECT = 29;
+var EMR_INTERSECTCLIPRECT = 30;
+var EMR_SCALEVIEWPORTEXTEX = 31;
+var EMR_SCALEWINDOWEXTEX = 32;
+var EMR_SAVEDC = 33;
+var EMR_RESTOREDC = 34;
+var EMR_SETWORLDTRANSFORM = 35;
+var EMR_MODIFYWORLDTRANSFORM = 36;
+var EMR_SELECTOBJECT = 37;
+var EMR_CREATEPEN = 38;
+var EMR_CREATEBRUSHINDIRECT = 39;
+var EMR_DELETEOBJECT = 40;
+var EMR_ELLIPSE = 42;
+var EMR_RECTANGLE = 43;
+var EMR_ROUNDRECT = 44;
+var EMR_ARC = 45;
+var EMR_CHORD = 46;
+var EMR_PIE = 47;
+var EMR_LINETO = 54;
+var EMR_ARCTO = 55;
+var EMR_SETMITERLIMIT = 58;
+var EMR_BEGINPATH = 59;
+var EMR_ENDPATH = 60;
+var EMR_CLOSEFIGURE = 61;
+var EMR_FILLPATH = 62;
+var EMR_STROKEANDFILLPATH = 63;
+var EMR_STROKEPATH = 64;
+var EMR_SELECTCLIPPATH = 67;
+var EMR_COMMENT = 70;
+var EMR_EXTSELECTCLIPRGN = 75;
+var EMR_BITBLT = 76;
+var EMR_STRETCHDIBITS = 81;
+var EMR_EXTCREATEFONTINDIRECTW = 82;
+var EMR_EXTTEXTOUTW = 84;
+var EMR_POLYBEZIER16 = 85;
+var EMR_POLYGON16 = 86;
+var EMR_POLYLINE16 = 87;
+var EMR_POLYBEZIERTO16 = 88;
+var EMR_POLYLINETO16 = 89;
+var EMR_POLYPOLYGON16 = 91;
+var EMR_EXTCREATEPEN = 95;
+var EMR_SETICMMODE = 98;
+var EMR_SETLAYOUT = 115;
+var STOCK_OBJECT_BASE = 2147483648;
+var EMFPLUS_SIGNATURE = 726027589;
+var EMR_COMMENT_PUBLIC_SIGNATURE = 1128875079;
+var EMFPLUS_HEADER = 16385;
+var EMFPLUS_ENDOFFILE = 16386;
+var EMFPLUS_GETDC = 16388;
+var EMFPLUS_OBJECT = 16392;
+var EMFPLUS_FILLRECTS = 16394;
+var EMFPLUS_DRAWRECTS = 16395;
+var EMFPLUS_FILLPOLYGON = 16396;
+var EMFPLUS_DRAWLINES = 16397;
+var EMFPLUS_FILLELLIPSE = 16398;
+var EMFPLUS_DRAWELLIPSE = 16399;
+var EMFPLUS_FILLPIE = 16400;
+var EMFPLUS_DRAWPIE = 16401;
+var EMFPLUS_DRAWARC = 16402;
+var EMFPLUS_FILLPATH = 16404;
+var EMFPLUS_DRAWPATH = 16405;
+var EMFPLUS_DRAWIMAGE = 16410;
+var EMFPLUS_DRAWIMAGEPOINTS = 16411;
+var EMFPLUS_DRAWSTRING = 16412;
+var EMFPLUS_SETANTIALIASMODE = 16414;
+var EMFPLUS_SETTEXTRENDERINGHINT = 16415;
+var EMFPLUS_SETINTERPOLATIONMODE = 16417;
+var EMFPLUS_SETPIXELOFFSETMODE = 16418;
+var EMFPLUS_SETCOMPOSITINGQUALITY = 16420;
+var EMFPLUS_SAVE = 16421;
+var EMFPLUS_RESTORE = 16422;
+var EMFPLUS_BEGINCONTAINERNOPARAMS = 16424;
+var EMFPLUS_ENDCONTAINER = 16425;
+var EMFPLUS_SETWORLDTRANSFORM = 16426;
+var EMFPLUS_RESETWORLDTRANSFORM = 16427;
+var EMFPLUS_MULTIPLYWORLDTRANSFORM = 16428;
+var EMFPLUS_TRANSLATEWORLDTRANSFORM = 16429;
+var EMFPLUS_SCALEWORLDTRANSFORM = 16430;
+var EMFPLUS_ROTATEWORLDTRANSFORM = 16431;
+var EMFPLUS_SETPAGETRANSFORM = 16432;
+var EMFPLUS_RESETCLIP = 16433;
+var EMFPLUS_SETCLIPRECT = 16434;
+var EMFPLUS_SETCLIPPATH = 16435;
+var EMFPLUS_SETCLIPREGION = 16436;
+var EMFPLUS_DRAWDRIVERSTRING = 16438;
+var EMFPLUS_OFFSETCLIP = 16437;
+var EMFPLUS_OBJECTTYPE_BRUSH = 1;
+var EMFPLUS_OBJECTTYPE_PEN = 2;
+var EMFPLUS_OBJECTTYPE_PATH = 3;
+var EMFPLUS_OBJECTTYPE_IMAGEATTRIBUTES = 4;
+var EMFPLUS_OBJECTTYPE_IMAGE = 5;
+var EMFPLUS_OBJECTTYPE_FONT = 6;
+var EMFPLUS_OBJECTTYPE_STRINGFORMAT = 7;
+var EMFPLUS_OBJECTTYPE_REGION = 8;
+var EMFPLUS_BRUSHTYPE_SOLID = 0;
+var EMFPLUS_BRUSHTYPE_HATCHFILL = 1;
+var EMFPLUS_BRUSHTYPE_PATHGRADIENT = 3;
+var EMFPLUS_BRUSHTYPE_LINEARGRADIENT = 4;
+var META_EOF = 0;
+var META_SETBKCOLOR = 513;
+var META_SETBKMODE = 258;
+var META_SETROP2 = 260;
+var META_SETPOLYFILLMODE = 262;
+var META_SETTEXTCOLOR = 521;
+var META_SETTEXTALIGN = 302;
+var META_SETWINDOWORG = 523;
+var META_SETWINDOWEXT = 524;
+var META_MOVETO = 532;
+var META_LINETO = 531;
+var META_RECTANGLE = 1051;
+var META_ROUNDRECT = 1564;
+var META_ELLIPSE = 1048;
+var META_ARC = 2071;
+var META_PIE = 2074;
+var META_CHORD = 2096;
+var META_POLYGON = 804;
+var META_POLYLINE = 805;
+var META_SELECTOBJECT = 301;
+var META_DELETEOBJECT = 496;
+var META_CREATEPENINDIRECT = 762;
+var META_CREATEBRUSHINDIRECT = 764;
+var META_CREATEFONTINDIRECT = 763;
+var META_TEXTOUT = 1313;
+var META_EXTTEXTOUT = 2610;
+var META_SAVEDC = 30;
+var META_RESTOREDC = 295;
+var META_POLYPOLYGON = 1336;
 var emfLog = (...args) => {
 };
 var emfWarn = (...args) => {
@@ -8,7 +231,7 @@ var emfWarn = (...args) => {
 
 // src/emf-canvas-helpers.ts
 var DEFAULT_DPI_SCALE = 1;
-function createCanvas(width, height, maxWidth, maxHeight, dpiScale = DEFAULT_DPI_SCALE) {
+function createCanvas(width, height, maxWidth, maxHeight, dpiScale = DEFAULT_DPI_SCALE, maxCanvasDimension = MAX_CANVAS_DIMENSION) {
   const effectiveScale = Math.max(1, Math.min(dpiScale, 4));
   let w = Math.round(width * effectiveScale);
   let h = Math.round(height * effectiveScale);
@@ -28,8 +251,9 @@ function createCanvas(width, height, maxWidth, maxHeight, dpiScale = DEFAULT_DPI
     scaleX *= factor;
     scaleY *= factor;
   }
-  const clampedW = Math.max(1, Math.min(w, 8192));
-  const clampedH = Math.max(1, Math.min(h, 8192));
+  const dimCap = Math.max(1, Math.floor(maxCanvasDimension));
+  const clampedW = Math.max(1, Math.min(w, dimCap));
+  const clampedH = Math.max(1, Math.min(h, dimCap));
   if (clampedW !== w || clampedH !== h) {
     console.warn(
       `[emf-converter] Canvas size clamped from ${w}\xD7${h} to ${clampedW}\xD7${clampedH}. Output may lose detail.`
@@ -74,8 +298,8 @@ function createTempCanvas(width, height) {
   if (width <= 0 || height <= 0) {
     return null;
   }
-  width = Math.max(1, Math.min(Math.floor(width), 8192));
-  height = Math.max(1, Math.min(Math.floor(height), 8192));
+  width = Math.max(1, Math.min(Math.floor(width), MAX_CANVAS_DIMENSION));
+  height = Math.max(1, Math.min(Math.floor(height), MAX_CANVAS_DIMENSION));
   if (typeof OffscreenCanvas !== "undefined") {
     const canvas = new OffscreenCanvas(width, height);
     const ctx = canvas.getContext("2d");
@@ -96,13 +320,61 @@ function createTempCanvas(width, height) {
   }
   return null;
 }
+function rop2Paint(rop2) {
+  switch (rop2) {
+    case R2_BLACK:
+      return { gco: "source-over", colorTransform: "black", exact: true };
+    case R2_WHITE:
+      return { gco: "source-over", colorTransform: "white", exact: true };
+    case R2_NOP:
+      return { gco: "source-over", colorTransform: "skip", exact: true };
+    case R2_NOTCOPYPEN:
+      return { gco: "source-over", colorTransform: "invert", exact: true };
+    case R2_NOT:
+      return { gco: "difference", colorTransform: "white", exact: true };
+    case R2_XORPEN:
+    case R2_MASKPENNOT:
+      return { gco: "difference", colorTransform: "none", exact: false };
+    case R2_NOTXORPEN:
+      return { gco: "difference", colorTransform: "invert", exact: false };
+    case R2_MASKPEN:
+      return { gco: "darken", colorTransform: "none", exact: false };
+    case R2_MASKNOTPEN:
+    case R2_NOTMERGEPEN:
+      return { gco: "darken", colorTransform: "invert", exact: false };
+    case R2_MERGEPEN:
+    case R2_MERGEPENNOT:
+      return { gco: "lighten", colorTransform: "none", exact: false };
+    case R2_MERGENOTPEN:
+    case R2_NOTMASKPEN:
+      return { gco: "lighten", colorTransform: "invert", exact: false };
+    default:
+      return { gco: "source-over", colorTransform: "none", exact: true };
+  }
+}
+function rop2TransformColor(color, transform) {
+  switch (transform) {
+    case "invert":
+      return invertCssColor(color);
+    case "black":
+      return "#000000";
+    case "white":
+      return "#ffffff";
+    case "skip":
+      return "rgba(0,0,0,0)";
+    default:
+      return color;
+  }
+}
 function applyPen(ctx, state) {
+  const paint = rop2Paint(state.rop2);
+  ctx.globalCompositeOperation = paint.gco;
   if (state.penStyle === 5) {
     ctx.strokeStyle = "rgba(0,0,0,0)";
     ctx.lineWidth = 0;
     return;
   }
-  ctx.strokeStyle = state.penColor;
+  ctx.strokeStyle = rop2TransformColor(state.penColor, paint.colorTransform);
   ctx.lineWidth = Math.max(state.penWidth, 1);
   switch (state.penStyle) {
     case 1:
@@ -123,17 +395,57 @@ function applyPen(ctx, state) {
   }
 }
 function applyBrush(ctx, state) {
+  const paint = rop2Paint(state.rop2);
+  ctx.globalCompositeOperation = paint.gco;
   if (state.brushStyle === 1) {
     ctx.fillStyle = "rgba(0,0,0,0)";
     return;
   }
-  ctx.fillStyle = state.brushColor;
+  ctx.fillStyle = rop2TransformColor(state.brushColor, paint.colorTransform);
+}
+function cssFontWeight(weight) {
+  if (!weight || weight === 400) {
+    return "";
+  }
+  const rounded = Math.round(weight / 100) * 100;
+  if (rounded === 700) {
+    return "bold";
+  }
+  if (rounded >= 100 && rounded <= 900) {
+    return String(rounded);
+  }
+  return weight >= 700 ? "bold" : "";
+}
+function mapFontFamily(face, map) {
+  const resolved = map?.[face.toLowerCase().trim()] ?? face;
+  if (/[\s,]/.test(resolved) && !/^["']/.test(resolved)) {
+    return `"${resolved}"`;
+  }
+  return resolved;
 }
 function applyFont(ctx, state) {
   const italic = state.fontItalic ? "italic " : "";
-  const weight = state.fontWeight >= 700 ? "bold " : "";
+  const weight = cssFontWeight(state.fontWeight);
+  const weightPart = weight ? `${weight} ` : "";
+  const size = Math.max(Math.abs(state.fontHeight), 8);
+  const family = mapFontFamily(state.fontFamily, state.fontFamilyMap);
+  ctx.font = `${italic}${weightPart}${size}px ${family}`;
+}
+function drawTextDecorations(ctx, state, x, y, width) {
+  if (!state.fontUnderline && !state.fontStrikeOut) {
+    return;
+  }
   const size = Math.max(Math.abs(state.fontHeight), 8);
-  ctx.font = `${italic}${weight}${size}px ${state.fontFamily}`;
+  const thickness = Math.max(1, Math.round(size / 14));
+  const prevFill = ctx.fillStyle;
+  ctx.fillStyle = state.textColor;
+  if (state.fontUnderline) {
+    ctx.fillRect(x, y + Math.round(size * 0.12), width, thickness);
+  }
+  if (state.fontStrikeOut) {
+    ctx.fillRect(x, y - Math.round(size * 0.3), width, thickness);
+  }
+  ctx.fillStyle = prevFill;
 }
 function readUtf16LE(view, offset, charCount) {
   if (charCount <= 0) {
@@ -192,6 +504,8 @@ function getStockObject(index) {
         height: 12,
         weight: 400,
         italic: false,
+        underline: false,
+        strikeOut: false,
         family: "monospace"
       };
     case 12:
@@ -203,6 +517,8 @@ function getStockObject(index) {
         height: 12,
         weight: 400,
         italic: false,
+        underline: false,
+        strikeOut: false,
         family: "sans-serif"
       };
     default:
@@ -235,161 +551,6 @@ async function exportCanvasToPngDataUrl(canvas) {
   return null;
 }
 
-// src/emf-constants.ts
-var EMR_HEADER = 1;
-var EMR_POLYBEZIER = 2;
-var EMR_POLYGON = 3;
-var EMR_POLYLINE = 4;
-var EMR_POLYBEZIERTO = 5;
-var EMR_POLYLINETO = 6;
-var EMR_POLYPOLYLINE = 7;
-var EMR_POLYPOLYGON = 8;
-var EMR_SETWINDOWEXTEX = 9;
-var EMR_SETWINDOWORGEX = 10;
-var EMR_SETVIEWPORTEXTEX = 11;
-var EMR_SETVIEWPORTORGEX = 12;
-var EMR_SETBRUSHORGEX = 13;
-var EMR_EOF = 14;
-var EMR_SETPIXELV = 15;
-var EMR_SETMAPMODE = 17;
-var EMR_SETBKMODE = 18;
-var EMR_SETPOLYFILLMODE = 19;
-var EMR_SETROP2 = 20;
-var EMR_SETSTRETCHBLTMODE = 21;
-var EMR_SETTEXTALIGN = 22;
-var EMR_SETTEXTCOLOR = 24;
-var EMR_SETBKCOLOR = 25;
-var EMR_OFFSETCLIPRGN = 26;
-var EMR_MOVETOEX = 27;
-var EMR_SETMETARGN = 28;
-var EMR_EXCLUDECLIPRECT = 29;
-var EMR_INTERSECTCLIPRECT = 30;
-var EMR_SCALEVIEWPORTEXTEX = 31;
-var EMR_SCALEWINDOWEXTEX = 32;
-var EMR_SAVEDC = 33;
-var EMR_RESTOREDC = 34;
-var EMR_SETWORLDTRANSFORM = 35;
-var EMR_MODIFYWORLDTRANSFORM = 36;
-var EMR_SELECTOBJECT = 37;
-var EMR_CREATEPEN = 38;
-var EMR_CREATEBRUSHINDIRECT = 39;
-var EMR_DELETEOBJECT = 40;
-var EMR_ELLIPSE = 42;
-var EMR_RECTANGLE = 43;
-var EMR_ROUNDRECT = 44;
-var EMR_ARC = 45;
-var EMR_CHORD = 46;
-var EMR_PIE = 47;
-var EMR_LINETO = 54;
-var EMR_ARCTO = 55;
-var EMR_SETMITERLIMIT = 58;
-var EMR_BEGINPATH = 59;
-var EMR_ENDPATH = 60;
-var EMR_CLOSEFIGURE = 61;
-var EMR_FILLPATH = 62;
-var EMR_STROKEANDFILLPATH = 63;
-var EMR_STROKEPATH = 64;
-var EMR_SELECTCLIPPATH = 67;
-var EMR_COMMENT = 70;
-var EMR_EXTSELECTCLIPRGN = 75;
-var EMR_BITBLT = 76;
-var EMR_STRETCHDIBITS = 81;
-var EMR_EXTCREATEFONTINDIRECTW = 82;
-var EMR_EXTTEXTOUTW = 84;
-var EMR_POLYBEZIER16 = 85;
-var EMR_POLYGON16 = 86;
-var EMR_POLYLINE16 = 87;
-var EMR_POLYBEZIERTO16 = 88;
-var EMR_POLYLINETO16 = 89;
-var EMR_POLYPOLYGON16 = 91;
-var EMR_EXTCREATEPEN = 95;
-var EMR_SETICMMODE = 98;
-var EMR_SETLAYOUT = 115;
-var STOCK_OBJECT_BASE = 2147483648;
-var EMFPLUS_SIGNATURE = 726027589;
-var EMR_COMMENT_PUBLIC_SIGNATURE = 1128875079;
-var EMFPLUS_HEADER = 16385;
-var EMFPLUS_ENDOFFILE = 16386;
-var EMFPLUS_GETDC = 16388;
-var EMFPLUS_OBJECT = 16392;
-var EMFPLUS_FILLRECTS = 16394;
-var EMFPLUS_DRAWRECTS = 16395;
-var EMFPLUS_FILLPOLYGON = 16396;
-var EMFPLUS_DRAWLINES = 16397;
-var EMFPLUS_FILLELLIPSE = 16398;
-var EMFPLUS_DRAWELLIPSE = 16399;
-var EMFPLUS_FILLPIE = 16400;
-var EMFPLUS_DRAWPIE = 16401;
-var EMFPLUS_DRAWARC = 16402;
-var EMFPLUS_FILLPATH = 16404;
-var EMFPLUS_DRAWPATH = 16405;
-var EMFPLUS_DRAWIMAGE = 16410;
-var EMFPLUS_DRAWIMAGEPOINTS = 16411;
-var EMFPLUS_DRAWSTRING = 16412;
-var EMFPLUS_SETANTIALIASMODE = 16414;
-var EMFPLUS_SETTEXTRENDERINGHINT = 16415;
-var EMFPLUS_SETINTERPOLATIONMODE = 16417;
-var EMFPLUS_SETPIXELOFFSETMODE = 16418;
-var EMFPLUS_SETCOMPOSITINGQUALITY = 16420;
-var EMFPLUS_SAVE = 16421;
-var EMFPLUS_RESTORE = 16422;
-var EMFPLUS_BEGINCONTAINERNOPARAMS = 16424;
-var EMFPLUS_ENDCONTAINER = 16425;
-var EMFPLUS_SETWORLDTRANSFORM = 16426;
-var EMFPLUS_RESETWORLDTRANSFORM = 16427;
-var EMFPLUS_MULTIPLYWORLDTRANSFORM = 16428;
-var EMFPLUS_TRANSLATEWORLDTRANSFORM = 16429;
-var EMFPLUS_SCALEWORLDTRANSFORM = 16430;
-var EMFPLUS_ROTATEWORLDTRANSFORM = 16431;
-var EMFPLUS_SETPAGETRANSFORM = 16432;
-var EMFPLUS_RESETCLIP = 16433;
-var EMFPLUS_SETCLIPRECT = 16434;
-var EMFPLUS_SETCLIPPATH = 16435;
-var EMFPLUS_SETCLIPREGION = 16436;
-var EMFPLUS_DRAWDRIVERSTRING = 16438;
-var EMFPLUS_OFFSETCLIP = 16437;
-var EMFPLUS_OBJECTTYPE_BRUSH = 1;
-var EMFPLUS_OBJECTTYPE_PEN = 2;
-var EMFPLUS_OBJECTTYPE_PATH = 3;
-var EMFPLUS_OBJECTTYPE_IMAGEATTRIBUTES = 4;
-var EMFPLUS_OBJECTTYPE_IMAGE = 5;
-var EMFPLUS_OBJECTTYPE_FONT = 6;
-var EMFPLUS_OBJECTTYPE_STRINGFORMAT = 7;
-var EMFPLUS_OBJECTTYPE_REGION = 8;
-var EMFPLUS_BRUSHTYPE_SOLID = 0;
-var EMFPLUS_BRUSHTYPE_HATCHFILL = 1;
-var EMFPLUS_BRUSHTYPE_PATHGRADIENT = 3;
-var EMFPLUS_BRUSHTYPE_LINEARGRADIENT = 4;
-var META_EOF = 0;
-var META_SETBKCOLOR = 513;
-var META_SETBKMODE = 258;
-var META_SETROP2 = 260;
-var META_SETPOLYFILLMODE = 262;
-var META_SETTEXTCOLOR = 521;
-var META_SETTEXTALIGN = 302;
-var META_SETWINDOWORG = 523;
-var META_SETWINDOWEXT = 524;
-var META_MOVETO = 532;
-var META_LINETO = 531;
-var META_RECTANGLE = 1051;
-var META_ROUNDRECT = 1564;
-var META_ELLIPSE = 1048;
-var META_ARC = 2071;
-var META_PIE = 2074;
-var META_CHORD = 2096;
-var META_POLYGON = 804;
-var META_POLYLINE = 805;
-var META_SELECTOBJECT = 301;
-var META_DELETEOBJECT = 496;
-var META_CREATEPENINDIRECT = 762;
-var META_CREATEBRUSHINDIRECT = 764;
-var META_CREATEFONTINDIRECT = 763;
-var META_TEXTOUT = 1313;
-var META_EXTTEXTOUT = 2610;
-var META_SAVEDC = 30;
-var META_RESTOREDC = 295;
-var META_POLYPOLYGON = 1336;
-
 // src/emf-header-parser.ts
 function parseEmfHeader(view) {
   emfLog("parseEmfHeader: byteLength =", view.byteLength);
@@ -474,49 +635,36 @@ function parseWmfHeader(view) {
   };
 }
 
-// src/emf-color-helpers.ts
-function colorRefToHex(r, g, b) {
-  const toHex = (v) => v.toString(16).padStart(2, "0");
-  return `#${toHex(r & 255)}${toHex(g & 255)}${toHex(b & 255)}`;
-}
-function readColorRef(view, offset) {
-  const r = view.getUint8(offset);
-  const g = view.getUint8(offset + 1);
-  const b = view.getUint8(offset + 2);
-  return colorRefToHex(r, g, b);
-}
-function argbToRgba(argb) {
-  const a = (argb >>> 24 & 255) / 255;
-  const r = argb >>> 16 & 255;
-  const g = argb >>> 8 & 255;
-  const b = argb & 255;
-  return `rgba(${r},${g},${b},${a.toFixed(3)})`;
-}
-
 // src/emf-gdi-coord.ts
 function gmx(r, x) {
+  const wt = r.state.worldTransform;
+  const px = wt[0] * x + wt[4];
   if (r.useMappingMode) {
-    return (x - r.windowOrg.x) / (r.windowExt.cx || 1) * (r.viewportExt.cx || 1) + r.viewportOrg.x;
+    return (px - r.windowOrg.x) / (r.windowExt.cx || 1) * (r.viewportExt.cx || 1) + r.viewportOrg.x;
   }
-  return (x - r.bounds.left) * r.sx;
+  return (px - r.bounds.left) * r.sx;
 }
 function gmy(r, y) {
+  const wt = r.state.worldTransform;
+  const py = wt[3] * y + wt[5];
   if (r.useMappingMode) {
-    return (y - r.windowOrg.y) / (r.windowExt.cy || 1) * (r.viewportExt.cy || 1) + r.viewportOrg.y;
+    return (py - r.windowOrg.y) / (r.windowExt.cy || 1) * (r.viewportExt.cy || 1) + r.viewportOrg.y;
   }
-  return (y - r.bounds.top) * r.sy;
+  return (py - r.bounds.top) * r.sy;
 }
 function gmw(r, w) {
+  const pw = r.state.worldTransform[0] * w;
   if (r.useMappingMode) {
-    return w / (r.windowExt.cx || 1) * (r.viewportExt.cx || 1);
+    return pw / (r.windowExt.cx || 1) * (r.viewportExt.cx || 1);
   }
-  return w * r.sx;
+  return pw * r.sx;
 }
 function gmh(r, h) {
+  const ph = r.state.worldTransform[3] * h;
   if (r.useMappingMode) {
-    return h / (r.windowExt.cy || 1) * (r.viewportExt.cy || 1);
+    return ph / (r.windowExt.cy || 1) * (r.viewportExt.cy || 1);
   }
-  return h * r.sy;
+  return ph * r.sy;
 }
 function activateGdiMappingMode(r) {
   r.useMappingMode = true;
@@ -696,27 +844,239 @@ function handleArcFamily(rCtx, recType, dataOff, recSize) {
   }
   return true;
 }
-function handleEmfGdiShapeRecord(rCtx, recType, dataOff, recSize) {
-  switch (recType) {
-    case EMR_SETPIXELV:
-      return handleSetPixelV(rCtx, dataOff, recSize);
-    case EMR_MOVETOEX:
-      return handleMoveToEx(rCtx, dataOff, recSize);
-    case EMR_LINETO:
-      return handleLineTo(rCtx, dataOff, recSize);
-    case EMR_RECTANGLE:
-      return handleRectangle(rCtx, dataOff, recSize);
-    case EMR_ROUNDRECT:
-      return handleRoundRect(rCtx, dataOff, recSize);
-    case EMR_ELLIPSE:
-      return handleEllipse(rCtx, dataOff, recSize);
-    case EMR_ARC:
-    case EMR_ARCTO:
-    case EMR_CHORD:
-    case EMR_PIE:
-      return handleArcFamily(rCtx, recType, dataOff, recSize);
-    default:
-      return false;
+function handleEmfGdiShapeRecord(rCtx, recType, dataOff, recSize) {
+  switch (recType) {
+    case EMR_SETPIXELV:
+      return handleSetPixelV(rCtx, dataOff, recSize);
+    case EMR_MOVETOEX:
+      return handleMoveToEx(rCtx, dataOff, recSize);
+    case EMR_LINETO:
+      return handleLineTo(rCtx, dataOff, recSize);
+    case EMR_RECTANGLE:
+      return handleRectangle(rCtx, dataOff, recSize);
+    case EMR_ROUNDRECT:
+      return handleRoundRect(rCtx, dataOff, recSize);
+    case EMR_ELLIPSE:
+      return handleEllipse(rCtx, dataOff, recSize);
+    case EMR_ARC:
+    case EMR_ARCTO:
+    case EMR_CHORD:
+    case EMR_PIE:
+      return handleArcFamily(rCtx, recType, dataOff, recSize);
+    default:
+      return false;
+  }
+}
+
+// src/emf-clip-region.ts
+var CLIP_HUGE = 1 << 24;
+function rectClipShape(x, y, w, h) {
+  return { cmds: [{ op: "rect", x, y, w, h }], fillRule: "nonzero", simple: true };
+}
+function rectsClipShape(rects) {
+  return {
+    cmds: rects.map((r) => ({ op: "rect", x: r.x, y: r.y, w: r.w, h: r.h })),
+    fillRule: "nonzero",
+    simple: true
+  };
+}
+function emptyClipShape() {
+  return { cmds: [{ op: "rect", x: 0, y: 0, w: 0, h: 0 }], fillRule: "nonzero", simple: true };
+}
+function translateClipShape(shape, dx, dy) {
+  return {
+    ...shape,
+    cmds: shape.cmds.map((c) => {
+      switch (c.op) {
+        case "rect":
+          return { ...c, x: c.x + dx, y: c.y + dy };
+        case "moveTo":
+        case "lineTo":
+          return { ...c, x: c.x + dx, y: c.y + dy };
+        case "bezierCurveTo":
+          return {
+            ...c,
+            cp1x: c.cp1x + dx,
+            cp1y: c.cp1y + dy,
+            cp2x: c.cp2x + dx,
+            cp2y: c.cp2y + dy,
+            x: c.x + dx,
+            y: c.y + dy
+          };
+        case "closePath":
+          return c;
+      }
+    })
+  };
+}
+function translateClipRegion(region, dx, dy) {
+  if (!region) {
+    return null;
+  }
+  return region.map((s) => translateClipShape(s, dx, dy));
+}
+function isComposable(shape) {
+  return shape.simple && shape.fillRule === "nonzero";
+}
+function invertClipShape(shape) {
+  return {
+    cmds: [
+      { op: "rect", x: -CLIP_HUGE, y: -CLIP_HUGE, w: 2 * CLIP_HUGE, h: 2 * CLIP_HUGE },
+      ...shape.cmds
+    ],
+    fillRule: "evenodd",
+    simple: false
+  };
+}
+function combineClip(current, shape, op) {
+  switch (op) {
+    case "replace":
+      return { region: [shape], exact: true };
+    case "intersect":
+      return { region: current ? [...current, shape] : [shape], exact: true };
+    case "exclude": {
+      if (!isComposable(shape)) {
+        return { region: current ? [...current, shape] : [shape], exact: false };
+      }
+      const inv = invertClipShape(shape);
+      return { region: current ? [...current, inv] : [inv], exact: true };
+    }
+    case "union": {
+      if (!current) {
+        return { region: null, exact: true };
+      }
+      if (current.length === 1 && isComposable(current[0]) && isComposable(shape)) {
+        return {
+          region: [
+            { cmds: [...current[0].cmds, ...shape.cmds], fillRule: "nonzero", simple: false }
+          ],
+          exact: false
+        };
+      }
+      return { region: current, exact: false };
+    }
+    case "xor": {
+      if (!current) {
+        if (isComposable(shape)) {
+          return { region: [invertClipShape(shape)], exact: true };
+        }
+        return { region: [shape], exact: false };
+      }
+      if (current.length === 1 && isComposable(current[0]) && isComposable(shape)) {
+        return {
+          region: [
+            { cmds: [...current[0].cmds, ...shape.cmds], fillRule: "evenodd", simple: false }
+          ],
+          exact: true
+        };
+      }
+      if (isComposable(shape)) {
+        return { region: [...current, invertClipShape(shape)], exact: false };
+      }
+      return { region: [...current, shape], exact: false };
+    }
+    case "complement": {
+      if (!current) {
+        return { region: [emptyClipShape()], exact: true };
+      }
+      if (current.length === 1 && isComposable(current[0])) {
+        return { region: [shape, invertClipShape(current[0])], exact: true };
+      }
+      return { region: [shape], exact: false };
+    }
+  }
+}
+function combineClipRegions(current, incoming, op) {
+  if (op === "replace") {
+    return { region: incoming, exact: true };
+  }
+  if (incoming && incoming.length === 1) {
+    return combineClip(current, incoming[0], op);
+  }
+  if (!incoming) {
+    switch (op) {
+      case "intersect":
+        return { region: current, exact: true };
+      case "union":
+        return { region: null, exact: true };
+      case "exclude":
+        return { region: [emptyClipShape()], exact: true };
+      case "xor":
+      case "complement": {
+        if (!current) {
+          return { region: [emptyClipShape()], exact: true };
+        }
+        if (current.length === 1) {
+          return combineClip(null, current[0], "exclude");
+        }
+        return { region: current, exact: false };
+      }
+    }
+  }
+  switch (op) {
+    case "intersect":
+      return { region: current ? [...current, ...incoming] : incoming, exact: true };
+    case "union":
+      return { region: current, exact: false };
+    case "xor":
+      return { region: current ?? incoming, exact: false };
+    case "exclude":
+      return { region: current, exact: false };
+    case "complement": {
+      if (!current) {
+        return { region: [emptyClipShape()], exact: true };
+      }
+      if (current.length === 1) {
+        return combineClip(incoming, current[0], "exclude");
+      }
+      return { region: incoming, exact: false };
+    }
+  }
+}
+function replayClipCmds(ctx, cmds) {
+  for (const c of cmds) {
+    switch (c.op) {
+      case "rect":
+        ctx.rect(c.x, c.y, c.w, c.h);
+        break;
+      case "moveTo":
+        ctx.moveTo(c.x, c.y);
+        break;
+      case "lineTo":
+        ctx.lineTo(c.x, c.y);
+        break;
+      case "bezierCurveTo":
+        ctx.bezierCurveTo(c.cp1x, c.cp1y, c.cp2x, c.cp2y, c.x, c.y);
+        break;
+      case "closePath":
+        ctx.closePath();
+        break;
+    }
+  }
+}
+function applyClipShapes(ctx, shapes) {
+  for (const s of shapes) {
+    ctx.beginPath();
+    replayClipCmds(ctx, s.cmds);
+    try {
+      ctx.clip(s.fillRule);
+    } catch {
+    }
+  }
+}
+function reapplyClipRegion(holder, region, identityTransform = false) {
+  const { ctx } = holder;
+  while (holder.clipSaveDepth > 0) {
+    ctx.restore();
+    holder.clipSaveDepth--;
+  }
+  if (region) {
+    ctx.save();
+    holder.clipSaveDepth = 1;
+    if (identityTransform) {
+      ctx.setTransform(1, 0, 0, 1, 0, 0);
+    }
+    applyClipShapes(ctx, region);
   }
 }
 
@@ -1066,6 +1426,12 @@ function handleExtTextOutW(rCtx, offset, dataOff, recSize) {
           ctx.fillStyle = state.textColor;
         }
         ctx.fillText(text, gmx(rCtx, refX), gmy(rCtx, refY));
+        if (state.fontUnderline || state.fontStrikeOut) {
+          const w = ctx.measureText(text).width;
+          const baseX = gmx(rCtx, refX);
+          const startX = alignHoriz === "center" ? baseX - w / 2 : alignHoriz === "right" ? baseX - w : baseX;
+          drawTextDecorations(ctx, state, startX, gmy(rCtx, refY), w);
+        }
       }
     }
   }
@@ -1141,86 +1507,134 @@ function handleStretchDibits(rCtx, offset, dataOff, recSize) {
   }
   return true;
 }
+function gdiCombineClip(rCtx, shape, op) {
+  const { ctx } = rCtx;
+  if (rCtx.clipUntracked && op !== "replace") {
+    switch (op) {
+      case "intersect":
+      case "complement": {
+        ctx.save();
+        rCtx.clipSaveDepth++;
+        applyClipShapes(ctx, [shape]);
+        return;
+      }
+      case "exclude":
+      case "xor": {
+        const inv = combineClip(null, shape, "exclude");
+        ctx.save();
+        rCtx.clipSaveDepth++;
+        applyClipShapes(ctx, inv.region ?? [shape]);
+        return;
+      }
+      case "union":
+        return;
+    }
+  }
+  const res = combineClip(op === "replace" ? null : rCtx.clipRegion ?? null, shape, op);
+  if (!res.exact) ;
+  rCtx.clipRegion = res.region;
+  rCtx.clipUntracked = false;
+  reapplyClipRegion(rCtx, res.region);
+}
+function readClipRectShape(rCtx, dataOff) {
+  const { view } = rCtx;
+  const left = view.getInt32(dataOff, true);
+  const top = view.getInt32(dataOff + 4, true);
+  const right = view.getInt32(dataOff + 8, true);
+  const bottom = view.getInt32(dataOff + 12, true);
+  return rectClipShape(
+    gmx(rCtx, left),
+    gmy(rCtx, top),
+    gmw(rCtx, right - left),
+    gmh(rCtx, bottom - top)
+  );
+}
 function handleIntersectClipRect(rCtx, dataOff, recSize) {
-  const { ctx, view } = rCtx;
   if (recSize >= 24) {
-    const left = view.getInt32(dataOff, true);
-    const top = view.getInt32(dataOff + 4, true);
-    const right = view.getInt32(dataOff + 8, true);
-    const bottom = view.getInt32(dataOff + 12, true);
-    ctx.save();
-    rCtx.clipSaveDepth++;
-    ctx.beginPath();
-    ctx.rect(gmx(rCtx, left), gmy(rCtx, top), gmw(rCtx, right - left), gmh(rCtx, bottom - top));
-    try {
-      ctx.clip();
-    } catch {
-    }
+    gdiCombineClip(rCtx, readClipRectShape(rCtx, dataOff), "intersect");
   }
   return true;
 }
+function handleExcludeClipRect(rCtx, dataOff, recSize) {
+  if (recSize >= 24) {
+    gdiCombineClip(rCtx, readClipRectShape(rCtx, dataOff), "exclude");
+  }
+  return true;
+}
+var RGN_MODE_OPS = {
+  1: "intersect",
+  // RGN_AND
+  2: "union",
+  // RGN_OR
+  3: "xor",
+  // RGN_XOR
+  4: "exclude",
+  // RGN_DIFF
+  5: "replace"
+  // RGN_COPY
+};
 function handleExtSelectClipRgn(rCtx, dataOff, recSize) {
-  const { ctx, view } = rCtx;
+  const { view } = rCtx;
   if (recSize < 16) {
     return true;
   }
   const cbRgnData = view.getUint32(dataOff, true);
   const iMode = view.getUint32(dataOff + 4, true);
-  if (iMode === 5) {
-    if (cbRgnData === 0) {
-      while (rCtx.clipSaveDepth > 0) {
-        ctx.restore();
-        rCtx.clipSaveDepth--;
-      }
-      return true;
-    }
-    const rgnStart = dataOff + 8;
-    if (cbRgnData < 32) {
-      return true;
-    }
-    const nCount = view.getUint32(rgnStart + 8, true);
-    if (nCount === 0) {
-      return true;
-    }
-    while (rCtx.clipSaveDepth > 0) {
-      ctx.restore();
-      rCtx.clipSaveDepth--;
-    }
-    ctx.save();
-    rCtx.clipSaveDepth++;
-    ctx.beginPath();
-    const rectsStart = rgnStart + 32;
-    for (let i = 0; i < nCount; i++) {
-      const rOff = rectsStart + i * 16;
-      if (rOff + 16 > dataOff + 8 + cbRgnData) {
-        break;
-      }
-      const left = view.getInt32(rOff, true);
-      const top = view.getInt32(rOff + 4, true);
-      const right = view.getInt32(rOff + 8, true);
-      const bottom = view.getInt32(rOff + 12, true);
-      ctx.rect(gmx(rCtx, left), gmy(rCtx, top), gmw(rCtx, right - left), gmh(rCtx, bottom - top));
-    }
-    try {
-      ctx.clip();
-    } catch {
+  const op = RGN_MODE_OPS[iMode];
+  if (!op) {
+    return true;
+  }
+  if (cbRgnData === 0) {
+    if (op === "replace") {
+      rCtx.clipRegion = null;
+      rCtx.clipUntracked = false;
+      reapplyClipRegion(rCtx, null);
     }
+    return true;
   }
-  return true;
-}
-function handleExcludeClipRect(rCtx, dataOff, recSize) {
-  if (recSize >= 24) {
-    rCtx.view.getInt32(dataOff, true);
-    rCtx.view.getInt32(dataOff + 4, true);
-    rCtx.view.getInt32(dataOff + 8, true);
-    rCtx.view.getInt32(dataOff + 12, true);
+  const rgnStart = dataOff + 8;
+  if (cbRgnData < 32) {
+    return true;
+  }
+  const nCount = view.getUint32(rgnStart + 8, true);
+  if (nCount === 0) {
+    return true;
+  }
+  const rects = [];
+  const rectsStart = rgnStart + 32;
+  for (let i = 0; i < nCount; i++) {
+    const rOff = rectsStart + i * 16;
+    if (rOff + 16 > dataOff + 8 + cbRgnData) {
+      break;
+    }
+    const left = view.getInt32(rOff, true);
+    const top = view.getInt32(rOff + 4, true);
+    const right = view.getInt32(rOff + 8, true);
+    const bottom = view.getInt32(rOff + 12, true);
+    rects.push({
+      x: gmx(rCtx, left),
+      y: gmy(rCtx, top),
+      w: gmw(rCtx, right - left),
+      h: gmh(rCtx, bottom - top)
+    });
+  }
+  if (rects.length === 0) {
+    return true;
   }
+  gdiCombineClip(rCtx, rectsClipShape(rects), op);
   return true;
 }
 function handleOffsetClipRgn(rCtx, dataOff, recSize) {
   if (recSize >= 16) {
-    rCtx.view.getInt32(dataOff, true);
-    rCtx.view.getInt32(dataOff + 4, true);
+    const dx = rCtx.view.getInt32(dataOff, true);
+    const dy = rCtx.view.getInt32(dataOff + 4, true);
+    if (rCtx.clipUntracked) {
+      return true;
+    }
+    if (rCtx.clipRegion) {
+      rCtx.clipRegion = translateClipRegion(rCtx.clipRegion, gmw(rCtx, dx), gmh(rCtx, dy));
+      reapplyClipRegion(rCtx, rCtx.clipRegion);
+    }
   }
   return true;
 }
@@ -1543,14 +1957,12 @@ function handleEmfGdiPolyPathRecord(rCtx, recType, offset, dataOff, recSize) {
             ctx.restore();
             rCtx.clipSaveDepth--;
           }
-          ctx.save();
-          rCtx.clipSaveDepth++;
-          ctx.clip();
-        } else {
-          ctx.save();
-          rCtx.clipSaveDepth++;
-          ctx.clip();
         }
+        ctx.save();
+        rCtx.clipSaveDepth++;
+        ctx.clip(state.polyFillMode === 2 ? "nonzero" : "evenodd");
+        rCtx.clipRegion = null;
+        rCtx.clipUntracked = true;
       } catch {
       }
       return true;
@@ -1613,12 +2025,16 @@ function handleEmfObjectRecord(rCtx, recType, dataOff, recSize) {
         const height = view.getInt32(dataOff + 4, true);
         const weight = view.getInt32(dataOff + 20, true);
         const italic = view.getUint8(dataOff + 24);
+        const underline = view.getUint8(dataOff + 25);
+        const strikeOut = view.getUint8(dataOff + 26);
         const family = readUtf16LE(view, dataOff + 28, 32) || "sans-serif";
         rCtx.objectTable.set(ihFont, {
           kind: "font",
           height: Math.abs(height),
           weight,
           italic: italic !== 0,
+          underline: underline !== 0,
+          strikeOut: strikeOut !== 0,
           family
         });
       }
@@ -1643,6 +2059,8 @@ function handleEmfObjectRecord(rCtx, recType, dataOff, recSize) {
               state.fontHeight = obj.height;
               state.fontWeight = obj.weight;
               state.fontItalic = obj.italic;
+              state.fontUnderline = obj.underline;
+              state.fontStrikeOut = obj.strikeOut;
               state.fontFamily = obj.family;
               break;
           }
@@ -1819,6 +2237,9 @@ function defaultState() {
     fontWeight: 400,
     fontItalic: false,
     fontFamily: "sans-serif",
+    fontUnderline: false,
+    fontStrikeOut: false,
+    rop2: 13,
     curX: 0,
     curY: 0,
     polyFillMode: 1,
@@ -1837,7 +2258,9 @@ function createEmfPlusState() {
     objectTable: /* @__PURE__ */ new Map(),
     worldTransform: [1, 0, 0, 1, 0, 0],
     saveStack: [],
-    saveIdMap: /* @__PURE__ */ new Map()
+    saveIdMap: /* @__PURE__ */ new Map(),
+    clipRegion: null,
+    clipSaveDepth: 0
   };
 }
 
@@ -1857,8 +2280,19 @@ function handleEmfGdiStateRecord(rCtx, recType, _offset, dataOff, recSize) {
         ctx.restore();
         rCtx.clipSaveDepth--;
       }
+      rCtx.clipStack ?? (rCtx.clipStack = []);
+      rCtx.clipStack.push({
+        region: rCtx.clipRegion ?? null,
+        untracked: rCtx.clipUntracked ?? false
+      });
       rCtx.stateStack.push(cloneState(state));
       ctx.save();
+      if (rCtx.clipUntracked) {
+        rCtx.clipUntracked = false;
+        rCtx.clipRegion = null;
+      } else if (rCtx.clipRegion) {
+        reapplyClipRegion(rCtx, rCtx.clipRegion);
+      }
       return true;
     }
     case EMR_RESTOREDC: {
@@ -1869,16 +2303,23 @@ function handleEmfGdiStateRecord(rCtx, recType, _offset, dataOff, recSize) {
         }
         let rel = view.getInt32(dataOff, true);
         if (rel < 0) {
-          rel = rCtx.stateStack.length + rel;
+          rel = rCtx.stateStack.length + rel + 1;
         }
         while (rCtx.stateStack.length > rel && rCtx.stateStack.length > 0) {
           rCtx.stateStack.pop();
+          rCtx.clipStack?.pop();
           ctx.restore();
         }
         const restored = rCtx.stateStack.pop();
         if (restored) {
+          const clipSnapshot = rCtx.clipStack?.pop();
           Object.assign(state, restored);
           ctx.restore();
+          rCtx.clipRegion = clipSnapshot?.region ?? null;
+          rCtx.clipUntracked = false;
+          if (rCtx.clipRegion) {
+            reapplyClipRegion(rCtx, rCtx.clipRegion);
+          }
         }
       }
       return true;
@@ -1908,7 +2349,12 @@ function handleEmfGdiStateRecord(rCtx, recType, _offset, dataOff, recSize) {
       }
       return true;
     }
-    case EMR_SETROP2:
+    case EMR_SETROP2: {
+      if (recSize >= 12) {
+        state.rop2 = view.getUint32(dataOff, true);
+      }
+      return true;
+    }
     case EMR_SETSTRETCHBLTMODE:
     case EMR_SETMITERLIMIT:
     case EMR_SETTEXTALIGN: {
@@ -1992,6 +2438,47 @@ function parseEmfPlusPath(data, off, maxLen) {
   const types = new Uint8Array(data.buffer, data.byteOffset + alignedPOff, pointCount);
   return { kind: "plus-path", points, types: new Uint8Array(types) };
 }
+function emfPlusPathToClipCmds(path, m) {
+  const tx = (x, y) => m[0] * x + m[2] * y + m[4];
+  const ty = (x, y) => m[1] * x + m[3] * y + m[5];
+  const cmds = [];
+  const pts = path.points;
+  const types = path.types;
+  let i = 0;
+  while (i < pts.length) {
+    const t = types[i] & 15;
+    const close = (types[i] & 128) !== 0;
+    if (t === 0) {
+      cmds.push({ op: "moveTo", x: tx(pts[i].x, pts[i].y), y: ty(pts[i].x, pts[i].y) });
+      i++;
+    } else if (t === 3) {
+      if (i + 2 < pts.length) {
+        cmds.push({
+          op: "bezierCurveTo",
+          cp1x: tx(pts[i].x, pts[i].y),
+          cp1y: ty(pts[i].x, pts[i].y),
+          cp2x: tx(pts[i + 1].x, pts[i + 1].y),
+          cp2y: ty(pts[i + 1].x, pts[i + 1].y),
+          x: tx(pts[i + 2].x, pts[i + 2].y),
+          y: ty(pts[i + 2].x, pts[i + 2].y)
+        });
+        if ((types[i + 2] & 128) !== 0) {
+          cmds.push({ op: "closePath" });
+        }
+        i += 3;
+        continue;
+      }
+      break;
+    } else {
+      cmds.push({ op: "lineTo", x: tx(pts[i].x, pts[i].y), y: ty(pts[i].x, pts[i].y) });
+      i++;
+    }
+    if (close) {
+      cmds.push({ op: "closePath" });
+    }
+  }
+  return cmds;
+}
 function replayEmfPlusPath(ctx, path) {
   ctx.beginPath();
   const pts = path.points;
@@ -2045,12 +2532,44 @@ function multiplyMatrix(m1, m2) {
     m1[4] * m2[1] + m1[5] * m2[3] + m2[5]
   ];
 }
-function resolveBrushColor(rCtx, flags, brushIdOrColor) {
+function createBrushGradient(rCtx, grad) {
+  const ctx = rCtx.ctx;
+  try {
+    let g = null;
+    if (grad.type === "linear" && typeof ctx.createLinearGradient === "function") {
+      if (grad.x1 === grad.x2 && grad.y1 === grad.y2) {
+        return null;
+      }
+      g = ctx.createLinearGradient(grad.x1, grad.y1, grad.x2, grad.y2);
+    } else if (grad.type === "radial" && typeof ctx.createRadialGradient === "function") {
+      if (!(grad.r > 0)) {
+        return null;
+      }
+      g = ctx.createRadialGradient(grad.cx, grad.cy, 0, grad.cx, grad.cy, grad.r);
+    }
+    if (!g) {
+      return null;
+    }
+    for (const stop of grad.stops) {
+      g.addColorStop(stop.offset, stop.color);
+    }
+    return g;
+  } catch {
+    return null;
+  }
+}
+function resolveBrushPaint(rCtx, flags, brushIdOrColor) {
   if (flags & 32768) {
     return argbToRgba(brushIdOrColor);
   }
   const obj = rCtx.objectTable.get(brushIdOrColor & 255);
   if (obj && obj.kind === "plus-brush") {
+    if (obj.gradient) {
+      const g = createBrushGradient(rCtx, obj.gradient);
+      if (g) {
+        return g;
+      }
+    }
     return obj.color;
   }
   return "rgba(0,0,0,1)";
@@ -2114,88 +2633,83 @@ function popState(rCtx, stackId) {
     rCtx.saveIdMap = newMap;
   }
 }
-function ensureClipSave(rCtx) {
-  if (rCtx.clipSaveDepth === 0) {
-    rCtx.ctx.save();
-    rCtx.clipSaveDepth = 1;
-  }
+function plusDeviceMatrix(rCtx) {
+  const wt = rCtx.worldTransform;
+  const s = getPageUnitMultiplier(rCtx.pageUnit, rCtx.pageScale) * rCtx.dpiScale;
+  return [wt[0] * s, wt[1] * s, wt[2] * s, wt[3] * s, wt[4] * s, wt[5] * s];
 }
-function resetClipState(rCtx) {
-  if (rCtx.clipSaveDepth > 0) {
-    rCtx.ctx.restore();
-    rCtx.clipSaveDepth = 0;
-  }
+function transformedRectShape(x, y, w, h, m) {
+  const tx = (px, py) => m[0] * px + m[2] * py + m[4];
+  const ty = (px, py) => m[1] * px + m[3] * py + m[5];
+  const cmds = [
+    { op: "moveTo", x: tx(x, y), y: ty(x, y) },
+    { op: "lineTo", x: tx(x + w, y), y: ty(x + w, y) },
+    { op: "lineTo", x: tx(x + w, y + h), y: ty(x + w, y + h) },
+    { op: "lineTo", x: tx(x, y + h), y: ty(x, y + h) },
+    { op: "closePath" }
+  ];
+  return { cmds, fillRule: "nonzero", simple: true };
 }
-function applyClipCombineMode(rCtx, combineMode, opName, clipFn) {
-  switch (combineMode) {
-    case 0:
-      resetClipState(rCtx);
-      ensureClipSave(rCtx);
-      clipFn();
-      return true;
-    case 1:
-      ensureClipSave(rCtx);
-      clipFn();
-      return true;
-    case 2:
-      ensureClipSave(rCtx);
-      clipFn();
-      return true;
-    case 3:
-      return false;
-    case 4:
-      return false;
-    case 5:
-      return false;
-    default:
-      ensureClipSave(rCtx);
-      clipFn();
-      return true;
-  }
+function pathClipShape(path, m) {
+  return { cmds: emfPlusPathToClipCmds(path.path, m), fillRule: "nonzero", simple: true };
 }
-var MAX_REGION_TRACE_DEPTH = 64;
-function traceRegionNodePath(ctx, node, depth = 0) {
-  if (depth > MAX_REGION_TRACE_DEPTH) {
-    ctx.rect(0, 0, 0, 0);
-    return;
+var REGION_NODE_OPS = {
+  0: "intersect",
+  // legacy/lenient: treat 0 as And
+  1: "intersect",
+  // RegionNodeDataTypeAnd
+  2: "union",
+  // RegionNodeDataTypeOr
+  3: "xor",
+  // RegionNodeDataTypeXor
+  4: "exclude",
+  // RegionNodeDataTypeExclude
+  5: "complement"
+  // RegionNodeDataTypeComplement
+};
+var MAX_REGION_FLATTEN_DEPTH = 64;
+function flattenRegionNode(node, m, depth = 0) {
+  if (depth > MAX_REGION_FLATTEN_DEPTH) {
+    return { region: [emptyClipShape()], exact: false };
   }
   switch (node.type) {
     case "rect":
-      ctx.rect(node.x, node.y, node.width, node.height);
-      break;
+      return { region: [transformedRectShape(node.x, node.y, node.width, node.height, m)], exact: true };
     case "path":
-      replayEmfPlusPath(ctx, node.path);
-      break;
+      return { region: [pathClipShape(node, m)], exact: true };
     case "infinite":
-      ctx.rect(-1e6, -1e6, 2e6, 2e6);
-      break;
+      return { region: null, exact: true };
     case "empty":
-      ctx.rect(0, 0, 0, 0);
-      break;
-    case "combine":
-      traceRegionNodePath(ctx, node.left, depth + 1);
-      if (node.combineMode !== 0) {
-        emfWarn(
-          `traceRegionNodePath: combine mode ${node.combineMode} not fully supported, using left subtree only`
-        );
-      } else {
-        try {
-          ctx.clip();
-        } catch {
-        }
-        ctx.beginPath();
-        traceRegionNodePath(ctx, node.right, depth + 1);
-      }
-      break;
+      return { region: [emptyClipShape()], exact: true };
+    case "combine": {
+      const left = flattenRegionNode(node.left, m, depth + 1);
+      const right = flattenRegionNode(node.right, m, depth + 1);
+      const op = REGION_NODE_OPS[node.combineMode] ?? "intersect";
+      const combined = combineClipRegions(left.region, right.region, op);
+      return { region: combined.region, exact: combined.exact && left.exact && right.exact };
+    }
   }
 }
-function applyRegionNodeClip(ctx, rootNode, combineMode) {
-  ctx.beginPath();
-  traceRegionNodePath(ctx, rootNode);
-  try {
-    ctx.clip();
-  } catch {
-  }
+var PLUS_COMBINE_OPS = {
+  0: "replace",
+  1: "intersect",
+  2: "union",
+  3: "xor",
+  4: "exclude",
+  5: "complement"
+};
+function reapplyPlusClip(rCtx) {
+  reapplyClipRegion(rCtx, rCtx.clipRegion ?? null, true);
+}
+function applyPlusClipRegion(rCtx, incoming, combineMode, opName) {
+  const op = PLUS_COMBINE_OPS[combineMode];
+  const res = combineClipRegions(rCtx.clipRegion ?? null, incoming, op ?? "intersect");
+  if (!res.exact) ;
+  rCtx.clipRegion = res.region;
+  reapplyPlusClip(rCtx);
+}
+function applyPlusClipShape(rCtx, shape, combineMode, opName) {
+  applyPlusClipRegion(rCtx, [shape], combineMode);
 }
 function handleEmfPlusStateRecord(rCtx, recType, recFlags, dataOff, recDataSize) {
   const { view } = rCtx;
@@ -2297,30 +2811,24 @@ function handleEmfPlusStateRecord(rCtx, recType, recFlags, dataOff, recDataSize)
         const cy = view.getFloat32(dataOff + 4, true);
         const cw = view.getFloat32(dataOff + 8, true);
         const ch = view.getFloat32(dataOff + 12, true);
-        applyClipCombineMode(rCtx, combineMode, "SetClipRect", () => {
-          applyPlusWorldTransform(rCtx);
-          rCtx.ctx.beginPath();
-          rCtx.ctx.rect(cx, cy, cw, ch);
-          try {
-            rCtx.ctx.clip();
-          } catch {
-          }
-        });
+        const shape = transformedRectShape(cx, cy, cw, ch, plusDeviceMatrix(rCtx));
+        applyPlusClipShape(rCtx, shape, combineMode);
       }
       return true;
     }
     case EMFPLUS_RESETCLIP: {
-      resetClipState(rCtx);
-      ensureClipSave(rCtx);
+      rCtx.clipRegion = null;
+      reapplyPlusClip(rCtx);
       return true;
     }
     case EMFPLUS_SETCLIPREGION: {
       const regionId = recFlags & 255;
+      const combineMode = recFlags >> 8 & 15;
       const regionObj = rCtx.objectTable.get(regionId);
       if (regionObj && regionObj.kind === "plus-region" && regionObj.nodes.length > 0) {
-        applyPlusWorldTransform(rCtx);
-        const rootNode = regionObj.nodes[0];
-        applyRegionNodeClip(rCtx.ctx, rootNode);
+        const flattened = flattenRegionNode(regionObj.nodes[0], plusDeviceMatrix(rCtx));
+        if (!flattened.exact) ;
+        applyPlusClipRegion(rCtx, flattened.region, combineMode);
       }
       return true;
     }
@@ -2329,22 +2837,26 @@ function handleEmfPlusStateRecord(rCtx, recType, recFlags, dataOff, recDataSize)
       const combineMode = recFlags >> 8 & 15;
       const pathObj = rCtx.objectTable.get(pathId);
       if (pathObj && pathObj.kind === "plus-path") {
-        applyClipCombineMode(rCtx, combineMode, "SetClipPath", () => {
-          applyPlusWorldTransform(rCtx);
-          rCtx.ctx.beginPath();
-          replayEmfPlusPath(rCtx.ctx, pathObj);
-          try {
-            rCtx.ctx.clip();
-          } catch {
-          }
-        });
+        const shape = {
+          cmds: emfPlusPathToClipCmds(pathObj, plusDeviceMatrix(rCtx)),
+          fillRule: "nonzero",
+          simple: true
+        };
+        applyPlusClipShape(rCtx, shape, combineMode);
       }
       return true;
     }
     case EMFPLUS_OFFSETCLIP: {
       if (recDataSize >= 8) {
-        view.getFloat32(dataOff, true);
-        view.getFloat32(dataOff + 4, true);
+        const dx = view.getFloat32(dataOff, true);
+        const dy = view.getFloat32(dataOff + 4, true);
+        if (rCtx.clipRegion) {
+          const m = plusDeviceMatrix(rCtx);
+          const ddx = m[0] * dx + m[2] * dy;
+          const ddy = m[1] * dx + m[3] * dy;
+          rCtx.clipRegion = translateClipRegion(rCtx.clipRegion, ddx, ddy);
+          reapplyPlusClip(rCtx);
+        }
       }
       return true;
     }
@@ -2417,7 +2929,7 @@ function handleEmfPlusDrawRecord(rCtx, recType, recFlags, dataOff, recDataSize)
         const count = view.getUint32(dataOff + 4, true);
         const compressed = (recFlags & 16384) !== 0;
         const rectSize = compressed ? 8 : 16;
-        ctx.fillStyle = resolveBrushColor(rCtx, recFlags, brushVal);
+        ctx.fillStyle = resolveBrushPaint(rCtx, recFlags, brushVal);
         applyPlusWorldTransform(rCtx);
         let rOff = dataOff + 8;
         for (let i = 0; i < count && rOff + rectSize <= dataOff + recDataSize; i++) {
@@ -2467,7 +2979,7 @@ function handleEmfPlusDrawRecord(rCtx, recType, recFlags, dataOff, recDataSize)
           w = view.getFloat32(dataOff + 12, true);
           h = view.getFloat32(dataOff + 16, true);
         }
-        ctx.fillStyle = resolveBrushColor(rCtx, recFlags, brushVal);
+        ctx.fillStyle = resolveBrushPaint(rCtx, recFlags, brushVal);
         applyPlusWorldTransform(rCtx);
         ctx.beginPath();
         ctx.ellipse(x + w / 2, y + h / 2, Math.abs(w) / 2, Math.abs(h) / 2, 0, 0, Math.PI * 2);
@@ -2513,7 +3025,7 @@ function handleEmfPlusDrawRecord(rCtx, recType, recFlags, dataOff, recDataSize)
       let aOff = dataOff;
       if (isFill) {
         const brushVal = view.getUint32(aOff, true);
-        ctx.fillStyle = resolveBrushColor(rCtx, recFlags, brushVal);
+        ctx.fillStyle = resolveBrushPaint(rCtx, recFlags, brushVal);
         aOff += 4;
       }
       const startAngle = view.getFloat32(aOff, true) * Math.PI / 180;
@@ -2594,7 +3106,7 @@ function handleEmfPlusDrawRecord(rCtx, recType, recFlags, dataOff, recDataSize)
         const count = view.getUint32(dataOff + 4, true);
         const compressed = (recFlags & 16384) !== 0;
         const ptSize = compressed ? 4 : 8;
-        ctx.fillStyle = resolveBrushColor(rCtx, recFlags, brushVal);
+        ctx.fillStyle = resolveBrushPaint(rCtx, recFlags, brushVal);
         applyPlusWorldTransform(rCtx);
         ctx.beginPath();
         let pOff = dataOff + 8;
@@ -2617,6 +3129,261 @@ function handleEmfPlusDrawRecord(rCtx, recType, recFlags, dataOff, recDataSize)
   }
 }
 
+// src/emf-plus-brush-parser.ts
+var BRUSH_DATA_PATH = 1;
+var BRUSH_DATA_TRANSFORM = 2;
+var BRUSH_DATA_PRESET_COLORS = 4;
+var BRUSH_DATA_BLEND_FACTORS_H = 8;
+var MAX_GRADIENT_ELEMENTS = 4096;
+function looksLikeGraphicsVersion(v) {
+  return v >>> 12 === 900097;
+}
+function readTransform(view, off) {
+  return [
+    view.getFloat32(off, true),
+    view.getFloat32(off + 4, true),
+    view.getFloat32(off + 8, true),
+    view.getFloat32(off + 12, true),
+    view.getFloat32(off + 16, true),
+    view.getFloat32(off + 20, true)
+  ];
+}
+function applyMatrix(m, x, y) {
+  return { x: m[0] * x + m[2] * y + m[4], y: m[1] * x + m[3] * y + m[5] };
+}
+function clamp01(v) {
+  return Number.isFinite(v) ? Math.min(1, Math.max(0, v)) : 0;
+}
+function normaliseStops(stops) {
+  return stops.map((s) => ({ offset: clamp01(s.offset), color: s.color })).sort((a, b) => a.offset - b.offset);
+}
+function readPresetColors(view, off, end) {
+  if (off + 4 > end) {
+    return null;
+  }
+  const count = view.getUint32(off, true);
+  if (count === 0 || count > MAX_GRADIENT_ELEMENTS) {
+    return null;
+  }
+  const posOff = off + 4;
+  const colOff = posOff + count * 4;
+  const next = colOff + count * 4;
+  if (next > end) {
+    return null;
+  }
+  const stops = [];
+  for (let i = 0; i < count; i++) {
+    stops.push({
+      offset: view.getFloat32(posOff + i * 4, true),
+      color: argbToRgba(view.getUint32(colOff + i * 4, true))
+    });
+  }
+  return { stops, next };
+}
+function readBlendFactors(view, off, end) {
+  if (off + 4 > end) {
+    return null;
+  }
+  const count = view.getUint32(off, true);
+  if (count === 0 || count > MAX_GRADIENT_ELEMENTS) {
+    return null;
+  }
+  const posOff = off + 4;
+  const facOff = posOff + count * 4;
+  const next = facOff + count * 4;
+  if (next > end) {
+    return null;
+  }
+  const entries = [];
+  for (let i = 0; i < count; i++) {
+    entries.push({
+      pos: view.getFloat32(posOff + i * 4, true),
+      factor: view.getFloat32(facOff + i * 4, true)
+    });
+  }
+  return { entries, next };
+}
+function parseLinearGradient(view, b, end) {
+  if (b + 40 > end) {
+    return null;
+  }
+  const flags = view.getUint32(b, true);
+  const rx = view.getFloat32(b + 8, true);
+  const ry = view.getFloat32(b + 12, true);
+  const rw = view.getFloat32(b + 16, true);
+  const rh = view.getFloat32(b + 20, true);
+  const startArgb = view.getUint32(b + 24, true);
+  const endArgb = view.getUint32(b + 28, true);
+  let o = b + 40;
+  let transform = null;
+  if (flags & BRUSH_DATA_TRANSFORM && o + 24 <= end) {
+    transform = readTransform(view, o);
+    o += 24;
+  }
+  let stops = [
+    { offset: 0, color: argbToRgba(startArgb) },
+    { offset: 1, color: argbToRgba(endArgb) }
+  ];
+  if (flags & BRUSH_DATA_PRESET_COLORS) {
+    const preset = readPresetColors(view, o, end);
+    if (preset) {
+      stops = preset.stops;
+    }
+  } else if (flags & BRUSH_DATA_BLEND_FACTORS_H) {
+    const blend = readBlendFactors(view, o, end);
+    if (blend) {
+      stops = blend.entries.map((e) => ({
+        offset: e.pos,
+        color: lerpArgbToRgba(startArgb, endArgb, e.factor)
+      }));
+    }
+  }
+  let p1 = { x: rx, y: ry + rh / 2 };
+  let p2 = { x: rx + rw, y: ry + rh / 2 };
+  if (transform) {
+    p1 = applyMatrix(transform, p1.x, p1.y);
+    p2 = applyMatrix(transform, p2.x, p2.y);
+  }
+  emfLog(
+    `parseEmfPlusBrushObject: linear gradient (${p1.x.toFixed(1)},${p1.y.toFixed(1)})\u2192(${p2.x.toFixed(1)},${p2.y.toFixed(1)}), ${stops.length} stop(s)`
+  );
+  return {
+    kind: "plus-brush",
+    color: argbToRgba(startArgb),
+    gradient: {
+      type: "linear",
+      x1: p1.x,
+      y1: p1.y,
+      x2: p2.x,
+      y2: p2.y,
+      stops: normaliseStops(stops)
+    }
+  };
+}
+function parsePathGradient(view, b, end) {
+  if (b + 24 > end) {
+    return null;
+  }
+  const flags = view.getUint32(b, true);
+  const centerArgb = view.getUint32(b + 8, true);
+  let cx = view.getFloat32(b + 12, true);
+  let cy = view.getFloat32(b + 16, true);
+  const surroundCount = view.getUint32(b + 20, true);
+  if (surroundCount > MAX_GRADIENT_ELEMENTS) {
+    return { kind: "plus-brush", color: argbToRgba(centerArgb) };
+  }
+  const surround = [];
+  let o = b + 24;
+  for (let i = 0; i < surroundCount && o + 4 <= end; i++) {
+    surround.push(view.getUint32(o, true));
+    o += 4;
+  }
+  let boundaryPts = [];
+  if (flags & BRUSH_DATA_PATH) {
+    if (o + 4 <= end) {
+      const pathSize = view.getInt32(o, true);
+      o += 4;
+      if (pathSize > 0 && o + pathSize <= end) {
+        const path = parseEmfPlusPath(view, o, pathSize);
+        if (path) {
+          boundaryPts = path.points;
+        }
+        o += pathSize;
+      }
+    }
+  } else if (o + 4 <= end) {
+    const ptCount = view.getUint32(o, true);
+    o += 4;
+    if (ptCount > 0 && ptCount <= MAX_GRADIENT_ELEMENTS && o + ptCount * 8 <= end) {
+      for (let i = 0; i < ptCount; i++) {
+        boundaryPts.push({
+          x: view.getFloat32(o + i * 8, true),
+          y: view.getFloat32(o + i * 8 + 4, true)
+        });
+      }
+      o += ptCount * 8;
+    }
+  }
+  let transform = null;
+  if (flags & BRUSH_DATA_TRANSFORM && o + 24 <= end) {
+    transform = readTransform(view, o);
+    o += 24;
+  }
+  if (transform) {
+    ({ x: cx, y: cy } = applyMatrix(transform, cx, cy));
+    boundaryPts = boundaryPts.map((p) => applyMatrix(transform, p.x, p.y));
+  }
+  const surroundArgb = surround.length > 0 ? surround[0] : centerArgb;
+  let stops = [
+    { offset: 0, color: argbToRgba(centerArgb) },
+    { offset: 1, color: argbToRgba(surroundArgb) }
+  ];
+  if (flags & BRUSH_DATA_PRESET_COLORS) {
+    const preset = readPresetColors(view, o, end);
+    if (preset) {
+      stops = preset.stops.map((s) => ({ offset: 1 - s.offset, color: s.color }));
+    }
+  } else if (flags & BRUSH_DATA_BLEND_FACTORS_H) {
+    const blend = readBlendFactors(view, o, end);
+    if (blend) {
+      stops = blend.entries.map((e) => ({
+        offset: 1 - e.pos,
+        color: lerpArgbToRgba(surroundArgb, centerArgb, e.factor)
+      }));
+    }
+  }
+  let r = 0;
+  for (const p of boundaryPts) {
+    const d = Math.hypot(p.x - cx, p.y - cy);
+    if (d > r) {
+      r = d;
+    }
+  }
+  if (!(r > 0)) {
+    return { kind: "plus-brush", color: argbToRgba(centerArgb) };
+  }
+  emfLog(
+    `parseEmfPlusBrushObject: path gradient centre=(${cx.toFixed(1)},${cy.toFixed(1)}), r=${r.toFixed(1)}, ${stops.length} stop(s)`
+  );
+  return {
+    kind: "plus-brush",
+    color: argbToRgba(centerArgb),
+    gradient: { type: "radial", cx, cy, r, stops: normaliseStops(stops) }
+  };
+}
+function parseEmfPlusBrushObject(view, dataOff, recDataSize) {
+  if (recDataSize < 8) {
+    return null;
+  }
+  const end = dataOff + recDataSize;
+  const hasVersion = looksLikeGraphicsVersion(view.getUint32(dataOff, true));
+  const typeOff = dataOff + (hasVersion ? 4 : 0);
+  if (typeOff + 8 > end) {
+    return null;
+  }
+  const brushType = view.getUint32(typeOff, true);
+  const b = typeOff + 4;
+  switch (brushType) {
+    case EMFPLUS_BRUSHTYPE_SOLID:
+      return { kind: "plus-brush", color: argbToRgba(view.getUint32(b, true)) };
+    case EMFPLUS_BRUSHTYPE_HATCHFILL:
+      if (b + 8 <= end) {
+        return { kind: "plus-brush", color: argbToRgba(view.getUint32(b + 4, true)) };
+      }
+      return { kind: "plus-brush", color: "rgba(0,0,0,1)" };
+    case EMFPLUS_BRUSHTYPE_LINEARGRADIENT: {
+      const brush = parseLinearGradient(view, b, end);
+      return brush ?? { kind: "plus-brush", color: "rgba(0,0,0,1)" };
+    }
+    case EMFPLUS_BRUSHTYPE_PATHGRADIENT: {
+      const brush = parsePathGradient(view, b, end);
+      return brush ?? { kind: "plus-brush", color: "rgba(0,0,0,1)" };
+    }
+    default:
+      return { kind: "plus-brush", color: "rgba(0,0,0,1)" };
+  }
+}
+
 // src/emf-plus-bitmap-decoder.ts
 var PIXELFORMAT_24BPP_RGB = 137224;
 var PIXELFORMAT_32BPP_RGB = 139273;
@@ -2726,7 +3493,8 @@ function parseEmfPlusPenObject(view, dataOff, recDataSize) {
   if (recDataSize < 20) {
     return null;
   }
-  const penFlags = view.getUint32(dataOff + 4, true);
+  const hasVersion = looksLikeGraphicsVersion(view.getUint32(dataOff, true));
+  const penFlags = view.getUint32(dataOff + (hasVersion ? 8 : 4), true);
   const penWidth = view.getFloat32(dataOff + 16, true);
   let brushOff = dataOff + 20;
   const flagSizes = [
@@ -2786,9 +3554,9 @@ function parseEmfPlusPenObject(view, dataOff, recDataSize) {
   }
   let penColor = "rgba(0,0,0,1)";
   if (brushOff + 8 <= dataOff + recDataSize) {
-    const penBrushType = view.getUint32(brushOff, true);
-    if (penBrushType === EMFPLUS_BRUSHTYPE_SOLID && brushOff + 8 <= dataOff + recDataSize) {
-      penColor = argbToRgba(view.getUint32(brushOff + 4, true));
+    const brush = parseEmfPlusBrushObject(view, brushOff, dataOff + recDataSize - brushOff);
+    if (brush) {
+      penColor = brush.color;
     }
   }
   return { kind: "plus-pen", color: penColor, width: penWidth || 1, dashStyle };
@@ -2884,19 +3652,9 @@ function handleEmfPlusObjectRecord(rCtx, recFlags, dataOff, recDataSize) {
     // Brush
     // ---------------------------------------------------------------
     case EMFPLUS_OBJECTTYPE_BRUSH: {
-      if (recDataSize >= 8) {
-        const brushType = view.getUint32(dataOff, true);
-        let color = "rgba(0,0,0,1)";
-        if (brushType === EMFPLUS_BRUSHTYPE_SOLID && recDataSize >= 8) {
-          color = argbToRgba(view.getUint32(dataOff + 4, true));
-        } else if (brushType === EMFPLUS_BRUSHTYPE_LINEARGRADIENT && recDataSize >= 48) {
-          color = argbToRgba(view.getUint32(dataOff + 40, true));
-        } else if (brushType === EMFPLUS_BRUSHTYPE_PATHGRADIENT && recDataSize >= 12) {
-          color = argbToRgba(view.getUint32(dataOff + 8, true));
-        } else if (brushType === EMFPLUS_BRUSHTYPE_HATCHFILL && recDataSize >= 12) {
-          color = argbToRgba(view.getUint32(dataOff + 8, true));
-        }
-        objectTable.set(objectId, { kind: "plus-brush", color });
+      const brush = parseEmfPlusBrushObject(view, dataOff, recDataSize);
+      if (brush) {
+        objectTable.set(objectId, brush);
       }
       break;
     }
@@ -2992,7 +3750,7 @@ function parseRegionNode(view, off, endOff, depth = 0) {
   }
   const nodeType = view.getUint32(off, true);
   let cursor = off + 4;
-  if (nodeType <= 4) {
+  if (nodeType <= 5) {
     const leftResult = parseRegionNode(view, cursor, endOff, depth + 1);
     if (!leftResult) {
       return null;
@@ -3081,7 +3839,7 @@ function handleEmfPlusTextImageRecord(rCtx, recType, recFlags, dataOff, recDataS
         const pathId = recFlags & 255;
         const pathObj = objectTable.get(pathId);
         if (pathObj && pathObj.kind === "plus-path") {
-          ctx.fillStyle = resolveBrushColor(rCtx, recFlags, brushVal);
+          ctx.fillStyle = resolveBrushPaint(rCtx, recFlags, brushVal);
           applyPlusWorldTransform(rCtx);
           replayEmfPlusPath(ctx, pathObj);
           ctx.fill();
@@ -3124,8 +3882,9 @@ function handleEmfPlusTextImageRecord(rCtx, recType, recFlags, dataOff, recDataS
           if (text.length > 0 && font && font.kind === "plus-font") {
             const bold = font.flags & 1 ? "bold " : "";
             const italic = font.flags & 2 ? "italic " : "";
-            ctx.font = `${italic}${bold}${font.emSize}px ${font.family}`;
-            ctx.fillStyle = resolveBrushColor(rCtx, recFlags, brushVal);
+            const family = mapFontFamily(font.family, rCtx.fontFamilyMap);
+            ctx.font = `${italic}${bold}${font.emSize}px ${family}`;
+            ctx.fillStyle = resolveBrushPaint(rCtx, recFlags, brushVal);
             ctx.textBaseline = "top";
             const sf = objectTable.get(formatId);
             if (sf && sf.kind === "plus-stringformat") {
@@ -3163,8 +3922,9 @@ function handleEmfPlusTextImageRecord(rCtx, recType, recFlags, dataOff, recDataS
           if (text.length > 0) {
             const bold = font.flags & 1 ? "bold " : "";
             const italic = font.flags & 2 ? "italic " : "";
-            ctx.font = `${italic}${bold}${font.emSize}px ${font.family}`;
-            ctx.fillStyle = resolveBrushColor(rCtx, recFlags, brushVal);
+            const family = mapFontFamily(font.family, rCtx.fontFamilyMap);
+            ctx.font = `${italic}${bold}${font.emSize}px ${family}`;
+            ctx.fillStyle = resolveBrushPaint(rCtx, recFlags, brushVal);
             ctx.textBaseline = "alphabetic";
             ctx.textAlign = "left";
             applyPlusWorldTransform(rCtx);
@@ -3329,7 +4089,7 @@ var EMFPLUS_REC_NAMES = {
   16424: "BeginContainerNoParams",
   16425: "EndContainer"
 };
-function replayEmfPlusRecords(view, offset, length, ctx, _canvasW, _canvasH, state, dpiScale = 1) {
+function replayEmfPlusRecords(view, offset, length, ctx, _canvasW, _canvasH, state, dpiScale = 1, maxRecords = MAX_RECORDS_EMFPLUS_DEFAULT, fontFamilyMap) {
   const s = state ?? createEmfPlusState();
   const rCtx = {
     ctx,
@@ -3341,7 +4101,8 @@ function replayEmfPlusRecords(view, offset, length, ctx, _canvasW, _canvasH, sta
     saveIdMap: s.saveIdMap,
     totalImageObjects: 0,
     totalDrawImageCalls: 0,
-    clipSaveDepth: 0,
+    clipSaveDepth: s.clipSaveDepth,
+    clipRegion: s.clipRegion,
     pageUnit: 2,
     pageScale: 1,
     continuationBuffer: null,
@@ -3349,10 +4110,10 @@ function replayEmfPlusRecords(view, offset, length, ctx, _canvasW, _canvasH, sta
     continuationObjectType: 0,
     continuationTotalSize: 0,
     continuationOffset: 0,
-    dpiScale
+    dpiScale,
+    fontFamilyMap
   };
   const end = offset + length;
-  const maxRecords = 5e5;
   let recordCount = 0;
   const emfPlusRecordTypes = /* @__PURE__ */ new Map();
   emfLog(`replayEmfPlusRecords: offset=0x${offset.toString(16)}, length=${length}`);
@@ -3475,6 +4236,8 @@ function replayEmfPlusRecords(view, offset, length, ctx, _canvasW, _canvasH, sta
   if (state) {
     state.worldTransform = rCtx.worldTransform;
     state.saveIdMap = rCtx.saveIdMap;
+    state.clipRegion = rCtx.clipRegion ?? null;
+    state.clipSaveDepth = rCtx.clipSaveDepth;
   }
   ctx.setTransform(1, 0, 0, 1, 0, 0);
   return rCtx.deferredImages;
@@ -3512,12 +4275,14 @@ var GDI_NAMES = {
   88: "EMR_POLYBEZIERTO16",
   91: "EMR_POLYPOLYGON16"
 };
-function replayEmfRecords(view, ctx, bounds, canvasW, canvasH, dpiScale = 1) {
+function replayEmfRecords(view, ctx, bounds, canvasW, canvasH, dpiScale = 1, replayOptions = {}) {
   emfLog(
     `replayEmfRecords: bounds=(${bounds.left},${bounds.top})\u2192(${bounds.right},${bounds.bottom}), canvas=${canvasW}\xD7${canvasH}`
   );
   const allDeferredImages = [];
   const emfPlusState = createEmfPlusState();
+  const maxRecords = replayOptions.maxRecords ?? MAX_RECORDS_DEFAULT;
+  const maxRecordsEmfPlus = replayOptions.maxRecordsEmfPlus ?? MAX_RECORDS_EMFPLUS_DEFAULT;
   const logicalW = bounds.right - bounds.left || 1;
   const logicalH = bounds.bottom - bounds.top || 1;
   const sx = canvasW / logicalW;
@@ -3529,7 +4294,7 @@ function replayEmfRecords(view, ctx, bounds, canvasW, canvasH, dpiScale = 1) {
     ctx,
     view,
     objectTable: /* @__PURE__ */ new Map(),
-    state: defaultState(),
+    state: { ...defaultState(), fontFamilyMap: replayOptions.fontFamilyMap },
     stateStack: [],
     inPath: false,
     windowOrg: { x: bounds.left, y: bounds.top },
@@ -3546,7 +4311,6 @@ function replayEmfRecords(view, ctx, bounds, canvasW, canvasH, dpiScale = 1) {
   };
   let offset = 0;
   const maxOffset = view.byteLength;
-  const maxRecords = 2e5;
   let recordCount = 0;
   let emfPlusCommentCount = 0;
   const gdiRecordTypes = /* @__PURE__ */ new Map();
@@ -3576,7 +4340,9 @@ function replayEmfRecords(view, ctx, bounds, canvasW, canvasH, dpiScale = 1) {
             canvasW,
             canvasH,
             emfPlusState,
-            dpiScale
+            dpiScale,
+            maxRecordsEmfPlus,
+            replayOptions.fontFamilyMap
           );
           emfLog(
             `replayEmfRecords: EMF+ comment #${emfPlusCommentCount} returned ${deferred.length} deferred images`
@@ -3886,7 +4652,7 @@ function createWmfCoord(windowOrg, windowExt, canvasW, canvasH) {
     mh: (h) => h / (windowExt.cy || 1) * canvasH
   };
 }
-function replayWmfRecords(view, ctx, header, canvasW, canvasH) {
+function replayWmfRecords(view, ctx, header, canvasW, canvasH, replayOptions = {}) {
   const logicalW = header.boundsRight - header.boundsLeft || 1;
   const logicalH = header.boundsBottom - header.boundsTop || 1;
   const windowOrg = { x: header.boundsLeft, y: header.boundsTop };
@@ -3900,12 +4666,12 @@ function replayWmfRecords(view, ctx, header, canvasW, canvasH) {
     }
     return slot;
   };
-  const state = defaultState();
+  const state = { ...defaultState(), fontFamilyMap: replayOptions.fontFamilyMap };
   const stateStack = [];
   const wCtx = { view, ctx, state, coord };
   let offset = header.headerSize;
   const maxOffset = view.byteLength;
-  const maxRecords = 2e5;
+  const maxRecords = replayOptions.maxRecords ?? MAX_RECORDS_DEFAULT;
   let recordCount = 0;
   while (offset + 6 <= maxOffset && recordCount < maxRecords) {
     const recSizeWords = view.getUint32(offset, true);
@@ -3962,6 +4728,9 @@ function replayWmfRecords(view, ctx, header, canvasW, canvasH) {
         }
         break;
       case META_SETROP2:
+        if (recSize >= 8) {
+          state.rop2 = view.getUint16(dataOff, true);
+        }
         break;
       case META_SETPOLYFILLMODE:
         if (recSize >= 8) {
@@ -4010,6 +4779,8 @@ function replayWmfRecords(view, ctx, header, canvasW, canvasH) {
             height: Math.abs(view.getInt16(dataOff, true)),
             weight: view.getInt16(dataOff + 8, true),
             italic: view.getUint8(dataOff + 10) !== 0,
+            underline: view.getUint8(dataOff + 11) !== 0,
+            strikeOut: view.getUint8(dataOff + 12) !== 0,
             family: family || "sans-serif"
           });
         }
@@ -4032,6 +4803,8 @@ function replayWmfRecords(view, ctx, header, canvasW, canvasH) {
                 state.fontHeight = obj.height;
                 state.fontWeight = obj.weight;
                 state.fontItalic = obj.italic;
+                state.fontUnderline = obj.underline;
+                state.fontStrikeOut = obj.strikeOut;
                 state.fontFamily = obj.family;
                 break;
             }
@@ -4149,6 +4922,11 @@ async function convertEmfToDataUrl(buffer, maxWidth, maxHeight, optionsOrDpiScal
   const dpiScale = opts.dpiScale ?? DEFAULT_DPI_SCALE;
   const effectiveMaxWidth = maxWidth ?? opts.maxWidth;
   const effectiveMaxHeight = maxHeight ?? opts.maxHeight;
+  const replayOptions = {
+    maxRecords: opts.maxRecords,
+    maxRecordsEmfPlus: opts.maxRecords,
+    fontFamilyMap: opts.fontFamilyMap
+  };
   try {
     emfLog("=== convertEmfToDataUrl START ===");
     emfLog(
@@ -4174,7 +4952,14 @@ async function convertEmfToDataUrl(buffer, maxWidth, maxHeight, optionsOrDpiScal
     const logicalW = renderBounds.right - renderBounds.left;
     const logicalH = renderBounds.bottom - renderBounds.top;
     emfLog(`convertEmfToDataUrl: logicalSize=${logicalW}\xD7${logicalH}`);
-    const setup = createCanvas(logicalW, logicalH, effectiveMaxWidth, effectiveMaxHeight, dpiScale);
+    const setup = createCanvas(
+      logicalW,
+      logicalH,
+      effectiveMaxWidth,
+      effectiveMaxHeight,
+      dpiScale,
+      opts.maxCanvasDimension
+    );
     if (!setup) {
       emfLog("convertEmfToDataUrl: createCanvas returned null \u2014 returning null");
       return null;
@@ -4191,7 +4976,8 @@ async function convertEmfToDataUrl(buffer, maxWidth, maxHeight, optionsOrDpiScal
       renderBounds,
       canvas.width,
       canvas.height,
-      dpiScale
+      dpiScale,
+      replayOptions
     );
     emfLog(
       `convertEmfToDataUrl: replayEmfRecords returned ${deferredImages.length} deferred images`
@@ -4221,6 +5007,10 @@ async function convertWmfToDataUrl(buffer, maxWidth, maxHeight, optionsOrDpiScal
   const dpiScale = opts.dpiScale ?? DEFAULT_DPI_SCALE;
   const effectiveMaxWidth = maxWidth ?? opts.maxWidth;
   const effectiveMaxHeight = maxHeight ?? opts.maxHeight;
+  const replayOptions = {
+    maxRecords: opts.maxRecords,
+    fontFamilyMap: opts.fontFamilyMap
+  };
   try {
     emfLog(
       "=== convertWmfToDataUrl START ===",
@@ -4239,13 +5029,20 @@ async function convertWmfToDataUrl(buffer, maxWidth, maxHeight, optionsOrDpiScal
       emfLog("convertWmfToDataUrl: invalid dimensions \u2014 returning null");
       return null;
     }
-    const setup = createCanvas(logicalW, logicalH, effectiveMaxWidth, effectiveMaxHeight, dpiScale);
+    const setup = createCanvas(
+      logicalW,
+      logicalH,
+      effectiveMaxWidth,
+      effectiveMaxHeight,
+      dpiScale,
+      opts.maxCanvasDimension
+    );
     if (!setup) {
       return null;
     }
     const { canvas, ctx } = setup;
     ctx.save();
-    replayWmfRecords(view, ctx, header, canvas.width, canvas.height);
+    replayWmfRecords(view, ctx, header, canvas.width, canvas.height, replayOptions);
     ctx.restore();
     const result = await exportCanvasToPngDataUrl(canvas);
     emfLog(`convertWmfToDataUrl: result=${result ? `dataUrl len=${result.length}` : "null"}`);