emf-converter 1.5.0 → 2.0.0

package/dist/index.js

@@ -1,5 +1,57 @@
 'use strict';
 
+// 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;
@@ -21,10 +73,21 @@ 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;
@@ -257,28 +320,61 @@ function createTempCanvas(width, height) {
   }
   return null;
 }
-function rop2ToGco(rop2) {
+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:
-      return "xor";
+    case R2_MASKPENNOT:
+      return { gco: "difference", colorTransform: "none", exact: false };
+    case R2_NOTXORPEN:
+      return { gco: "difference", colorTransform: "invert", exact: false };
     case R2_MASKPEN:
-      return "multiply";
+      return { gco: "darken", colorTransform: "none", exact: false };
+    case R2_MASKNOTPEN:
+    case R2_NOTMERGEPEN:
+      return { gco: "darken", colorTransform: "invert", exact: false };
     case R2_MERGEPEN:
-      return "lighten";
-    case R2_NOT:
-      return "difference";
+    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 "source-over";
+      return color;
   }
 }
 function applyPen(ctx, state) {
-  ctx.globalCompositeOperation = rop2ToGco(state.rop2);
+  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:
@@ -299,12 +395,13 @@ function applyPen(ctx, state) {
   }
 }
 function applyBrush(ctx, state) {
-  ctx.globalCompositeOperation = rop2ToGco(state.rop2);
+  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) {
@@ -538,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;
@@ -784,6 +868,218 @@ function handleEmfGdiShapeRecord(rCtx, recType, dataOff, recSize) {
   }
 }
 
+// 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);
+  }
+}
+
 // src/emf-dib-rle-decoder.ts
 function decodeRleBitmap(view, bitsOffset, bitsSize, width, height, _topDown, isRle4, colorTable, out, setPixel) {
   let x = 0;
@@ -1106,14 +1402,9 @@ function handleExtTextOutW(rCtx, offset, dataOff, recSize) {
       if (text.length > 0) {
         applyFont(ctx, state);
         ctx.fillStyle = state.textColor;
-        let alignBaseline = "alphabetic";
+        const vAlign = state.textAlign & 24;
+        const alignBaseline = vAlign === 24 ? "alphabetic" : vAlign === 8 ? "bottom" : "top";
         let alignHoriz = "left";
-        if (state.textAlign & 8) {
-          alignBaseline = "bottom";
-        }
-        if (state.textAlign & 24) {
-          alignBaseline = "alphabetic";
-        }
         if (state.textAlign & 6) {
           alignHoriz = "center";
         }
@@ -1141,17 +1432,29 @@ function handleExtTextOutW(rCtx, offset, dataOff, recSize) {
   }
   return true;
 }
+var ROP_PATCOPY = 15728673;
+var BS_NULL = 1;
 function handleBitBlt(rCtx, offset, dataOff, recSize) {
-  const { ctx, view } = rCtx;
+  const { ctx, view, state } = rCtx;
   if (recSize >= 96) {
     const dstX = view.getInt32(dataOff + 16, true);
     const dstY = view.getInt32(dataOff + 20, true);
     const dstW = view.getInt32(dataOff + 24, true);
     const dstH = view.getInt32(dataOff + 28, true);
+    const rop = view.getUint32(dataOff + 32, true);
     const offBmiSrc = view.getUint32(dataOff + 76, true);
     const cbBmiSrc = view.getUint32(dataOff + 80, true);
     const offBitsSrc = view.getUint32(dataOff + 84, true);
     const cbBitsSrc = view.getUint32(dataOff + 88, true);
+    if (offBmiSrc === 0 && rop === ROP_PATCOPY) {
+      const prevFill = ctx.fillStyle;
+      if (state.brushStyle !== BS_NULL) {
+        ctx.fillStyle = state.brushColor;
+        ctx.fillRect(gmx(rCtx, dstX), gmy(rCtx, dstY), gmw(rCtx, dstW), gmh(rCtx, dstH));
+      }
+      ctx.fillStyle = prevFill;
+      return true;
+    }
     if (offBmiSrc > 0 && cbBmiSrc > 0 && offBitsSrc > 0 && cbBitsSrc > 0) {
       const imageData = decodeDibToImageData(
         view,
@@ -1211,86 +1514,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;
 }
@@ -1613,14 +1964,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;
@@ -1916,7 +2265,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
   };
 }
 
@@ -1936,8 +2287,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: {
@@ -1948,16 +2310,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;
@@ -2076,6 +2445,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;
@@ -2129,12 +2539,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)";
@@ -2198,88 +2640,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;
@@ -2381,30 +2818,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;
     }
@@ -2413,22 +2844,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;
     }
@@ -2501,7 +2936,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++) {
@@ -2551,7 +2986,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);
@@ -2597,7 +3032,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;
@@ -2678,7 +3113,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;
@@ -2701,6 +3136,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;
@@ -2810,7 +3500,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 = [
@@ -2870,9 +3561,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 };
@@ -2968,19 +3659,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;
     }
@@ -3076,7 +3757,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;
@@ -3165,7 +3846,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();
@@ -3210,7 +3891,7 @@ function handleEmfPlusTextImageRecord(rCtx, recType, recFlags, dataOff, recDataS
             const italic = font.flags & 2 ? "italic " : "";
             const family = mapFontFamily(font.family, rCtx.fontFamilyMap);
             ctx.font = `${italic}${bold}${font.emSize}px ${family}`;
-            ctx.fillStyle = resolveBrushColor(rCtx, recFlags, brushVal);
+            ctx.fillStyle = resolveBrushPaint(rCtx, recFlags, brushVal);
             ctx.textBaseline = "top";
             const sf = objectTable.get(formatId);
             if (sf && sf.kind === "plus-stringformat") {
@@ -3250,7 +3931,7 @@ function handleEmfPlusTextImageRecord(rCtx, recType, recFlags, dataOff, recDataS
             const italic = font.flags & 2 ? "italic " : "";
             const family = mapFontFamily(font.family, rCtx.fontFamilyMap);
             ctx.font = `${italic}${bold}${font.emSize}px ${family}`;
-            ctx.fillStyle = resolveBrushColor(rCtx, recFlags, brushVal);
+            ctx.fillStyle = resolveBrushPaint(rCtx, recFlags, brushVal);
             ctx.textBaseline = "alphabetic";
             ctx.textAlign = "left";
             applyPlusWorldTransform(rCtx);
@@ -3427,7 +4108,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,
@@ -3561,6 +4243,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;
@@ -4180,19 +4864,7 @@ async function processDeferredImages(ctx, deferredImages, recursionDepth = 0) {
           continue;
         }
         emfLog(`  Deferred image [${idx}]: recursively converting embedded metafile...`);
-        const metafileDataUrl = await convertEmfToDataUrl(
-          plainBuffer,
-          void 0,
-          void 0,
-          void 0,
-          recursionDepth + 1
-        ) ?? await convertWmfToDataUrl(
-          plainBuffer,
-          void 0,
-          void 0,
-          void 0,
-          recursionDepth + 1
-        );
+        const metafileDataUrl = await convertEmfToDataUrl(plainBuffer, void 0, recursionDepth + 1) ?? await convertWmfToDataUrl(plainBuffer, void 0, recursionDepth + 1);
         if (metafileDataUrl) {
           emfLog(
             `  Deferred image [${idx}]: metafile converted, dataUrl length=${metafileDataUrl.length}`
@@ -4237,14 +4909,14 @@ async function processDeferredImages(ctx, deferredImages, recursionDepth = 0) {
   }
   ctx.setTransform(1, 0, 0, 1, 0, 0);
 }
-async function convertEmfToDataUrl(buffer, maxWidth, maxHeight, optionsOrDpiScale, recursionDepth = 0) {
+async function convertEmfToDataUrl(buffer, options, recursionDepth = 0) {
   if (recursionDepth > MAX_METAFILE_RECURSION) {
     return null;
   }
-  const opts = typeof optionsOrDpiScale === "number" ? { dpiScale: optionsOrDpiScale } : optionsOrDpiScale ?? {};
+  const opts = options ?? {};
   const dpiScale = opts.dpiScale ?? DEFAULT_DPI_SCALE;
-  const effectiveMaxWidth = maxWidth ?? opts.maxWidth;
-  const effectiveMaxHeight = maxHeight ?? opts.maxHeight;
+  const effectiveMaxWidth = opts.maxWidth;
+  const effectiveMaxHeight = opts.maxHeight;
   const replayOptions = {
     maxRecords: opts.maxRecords,
     maxRecordsEmfPlus: opts.maxRecords,
@@ -4322,14 +4994,14 @@ async function convertEmfToDataUrl(buffer, maxWidth, maxHeight, optionsOrDpiScal
     return null;
   }
 }
-async function convertWmfToDataUrl(buffer, maxWidth, maxHeight, optionsOrDpiScale, recursionDepth = 0) {
+async function convertWmfToDataUrl(buffer, options, recursionDepth = 0) {
   if (recursionDepth > MAX_METAFILE_RECURSION) {
     return null;
   }
-  const opts = typeof optionsOrDpiScale === "number" ? { dpiScale: optionsOrDpiScale } : optionsOrDpiScale ?? {};
+  const opts = options ?? {};
   const dpiScale = opts.dpiScale ?? DEFAULT_DPI_SCALE;
-  const effectiveMaxWidth = maxWidth ?? opts.maxWidth;
-  const effectiveMaxHeight = maxHeight ?? opts.maxHeight;
+  const effectiveMaxWidth = opts.maxWidth;
+  const effectiveMaxHeight = opts.maxHeight;
   const replayOptions = {
     maxRecords: opts.maxRecords,
     fontFamilyMap: opts.fontFamilyMap