emf-converter 3.0.2 → 3.1.0

package/dist/index.mjs

@@ -50,6 +50,47 @@ function invertCssColor(color) {
   return color;
 }
 
+// src/emf-gdi-text-layout.ts
+function cumulativeGlyphOffsets(dx) {
+  const offsets = [];
+  let acc = 0;
+  for (let i = 0; i < dx.length; i++) {
+    offsets.push(acc);
+    acc += dx[i];
+  }
+  return offsets;
+}
+function totalGlyphAdvance(dx) {
+  let sum = 0;
+  for (const d of dx) {
+    sum += d;
+  }
+  return sum;
+}
+function alignmentStartOffset(totalWidth, align) {
+  if (align === "center") {
+    return -totalWidth / 2;
+  }
+  if (align === "right") {
+    return -totalWidth;
+  }
+  return 0;
+}
+var DEG_TO_RAD = Math.PI / 180;
+function escapementToCanvasRadians(tenthsOfDegree) {
+  return -(tenthsOfDegree / 10) * DEG_TO_RAD;
+}
+var CELL_TO_CHAR_HEIGHT_RATIO = 1.15;
+function resolveFontPixelHeight(lfHeight) {
+  if (lfHeight === 0) {
+    return 0;
+  }
+  if (lfHeight < 0) {
+    return -lfHeight;
+  }
+  return lfHeight / CELL_TO_CHAR_HEIGHT_RATIO;
+}
+
 // src/emf-constants.ts
 var EMR_HEADER = 1;
 var EMR_POLYBEZIER = 2;
@@ -64,6 +105,9 @@ var EMR_SETWINDOWORGEX = 10;
 var EMR_SETVIEWPORTEXTEX = 11;
 var EMR_SETVIEWPORTORGEX = 12;
 var EMR_SETBRUSHORGEX = 13;
+var EMR_CREATEMONOBRUSH = 93;
+var EMR_CREATEDIBPATTERNBRUSHPT = 94;
+var EMR_STRETCHBLT = 77;
 var EMR_EOF = 14;
 var EMR_SETPIXELV = 15;
 var EMR_SETMAPMODE = 17;
@@ -468,7 +512,7 @@ function mapFontFamily(face, map) {
   return resolved;
 }
 function fontSizePx(state, scale = 1) {
-  return Math.max(Math.abs(state.fontHeight) * Math.abs(scale || 1), 8);
+  return Math.max(resolveFontPixelHeight(state.fontHeight) * Math.abs(scale || 1), 8);
 }
 function applyFont(ctx, state, scale = 1) {
   const italic = state.fontItalic ? "italic " : "";
@@ -620,6 +664,28 @@ function canvasDrawImage(ctx, image, dx, dy, dw, dh) {
   const draw = ctx.drawImage;
   draw.call(ctx, image, dx, dy, dw, dh);
 }
+function canvasGetImageData(ctx, x, y, w, h) {
+  const get = ctx.getImageData;
+  return get.call(ctx, x, y, w, h);
+}
+function canvasPutImageData(ctx, data, x, y) {
+  const put = ctx.putImageData;
+  put.call(ctx, data, x, y);
+}
+function canvasCreatePattern(ctx, image, repetition) {
+  const create = ctx.createPattern;
+  return create.call(ctx, image, repetition);
+}
+function createImageDataCompat(data, width, height) {
+  if (typeof ImageData !== "undefined") {
+    return new ImageData(data, width, height);
+  }
+  if (nodeCanvasModule) {
+    const Ctor = nodeCanvasModule.ImageData;
+    return new Ctor(data, width, height);
+  }
+  throw new ReferenceError("ImageData is not defined");
+}
 
 // src/emf-header-parser.ts
 function parseEmfHeader(view) {
@@ -938,218 +1004,6 @@ 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;
@@ -1245,7 +1099,7 @@ function decodeRleBitmap(view, bitsOffset, bitsSize, width, height, _topDown, is
       }
     }
   }
-  return new ImageData(
+  return createImageDataCompat(
     new Uint8ClampedArray(out.buffer, out.byteOffset, out.byteLength),
     width,
     height
@@ -1455,138 +1309,855 @@ function decodeDibToImageData(view, bmiOffset, bitsOffset, bitsSize) {
     masks,
     out
   );
-  return new ImageData(out, width, height);
+  return createImageDataCompat(out, width, height);
 }
 
-// src/emf-gdi-draw-text-bitmap.ts
-function handleExtTextOutW(rCtx, offset, dataOff, recSize) {
-  const { ctx, view, state } = rCtx;
-  if (recSize >= 76) {
-    const refX = view.getInt32(dataOff + 28, true);
-    const refY = view.getInt32(dataOff + 32, true);
-    const nChars = view.getUint32(dataOff + 36, true);
-    const offString = view.getUint32(dataOff + 40, true);
-    const maxOffset = view.byteLength;
-    if (nChars > 0 && offString > 0 && offset + offString + nChars * 2 <= maxOffset) {
-      const text = readUtf16LE(view, offset + offString, nChars);
-      if (text.length > 0) {
-        const fontScale = Math.abs(gmh(rCtx, 1));
-        applyFont(ctx, state, fontScale);
-        ctx.fillStyle = state.textColor;
-        const vAlign = state.textAlign & 24;
-        const alignBaseline = vAlign === 24 ? "alphabetic" : vAlign === 8 ? "bottom" : "top";
-        let alignHoriz = "left";
-        if (state.textAlign & 6) {
-          alignHoriz = "center";
-        }
-        if (state.textAlign & 2) {
-          alignHoriz = "right";
-        }
-        ctx.textBaseline = alignBaseline;
-        ctx.textAlign = alignHoriz;
-        if (state.bkMode === 2) {
-          const measured = ctx.measureText(text);
-          const bgH = fontSizePx(state, fontScale);
-          ctx.fillStyle = state.bkColor;
-          ctx.fillRect(gmx(rCtx, refX), gmy(rCtx, refY) - bgH, measured.width, bgH);
-          ctx.fillStyle = state.textColor;
+// src/emf-gdi-brush-pattern.ts
+var HATCH_ROWS = [
+  [0, 0, 0, 255, 0, 0, 0, 0],
+  // HS_HORIZONTAL
+  [8, 8, 8, 8, 8, 8, 8, 8],
+  // HS_VERTICAL
+  [128, 64, 32, 16, 8, 4, 2, 1],
+  // HS_FDIAGONAL
+  [1, 2, 4, 8, 16, 32, 64, 128],
+  // HS_BDIAGONAL
+  [8, 8, 8, 255, 8, 8, 8, 8],
+  // HS_CROSS
+  [129, 66, 36, 24, 24, 36, 66, 129]
+  // HS_DIAGCROSS
+];
+function hatchBit(hatch, x, y) {
+  const rows = HATCH_ROWS[hatch] ?? HATCH_ROWS[0];
+  return (rows[y & 7] >> 7 - (x & 7) & 1) === 1;
+}
+function cssHexToRgb(color) {
+  const m = /^#([0-9a-f]{6}|[0-9a-f]{3})$/i.exec(color.trim());
+  if (!m) {
+    return 0;
+  }
+  const hex = m[1].length === 3 ? m[1].replace(/./g, (c) => c + c) : m[1];
+  return parseInt(hex, 16);
+}
+function decodeMonoBits(view, bmiOffset, bitsOffset) {
+  if (bmiOffset + 16 > view.byteLength) {
+    return null;
+  }
+  const width = view.getInt32(bmiOffset + 4, true);
+  const heightRaw = view.getInt32(bmiOffset + 8, true);
+  const bitCount = view.getUint16(bmiOffset + 14, true);
+  const height = Math.abs(heightRaw);
+  if (bitCount !== 1 || width <= 0 || height === 0 || width > 256 || height > 256) {
+    return null;
+  }
+  const stride = (width + 31 >> 5) * 4;
+  if (bitsOffset + stride * height > view.byteLength) {
+    return null;
+  }
+  const bits = new Uint8Array(width * height);
+  for (let row = 0; row < height; row++) {
+    const y = heightRaw > 0 ? height - 1 - row : row;
+    const rowOff = bitsOffset + row * stride;
+    for (let x = 0; x < width; x++) {
+      bits[y * width + x] = view.getUint8(rowOff + (x >> 3)) >> 7 - (x & 7) & 1;
+    }
+  }
+  return { width, height, bits };
+}
+function parsePatternBrush(view, offset, dataOff, mono) {
+  if (dataOff + 24 > view.byteLength) {
+    return null;
+  }
+  const offBmi = view.getUint32(dataOff + 8, true);
+  const offBits = view.getUint32(dataOff + 16, true);
+  const cbBits = view.getUint32(dataOff + 20, true);
+  const bmi = offset + offBmi;
+  const bitsAt = offset + offBits;
+  const bitCount = bmi + 16 <= view.byteLength ? view.getUint16(bmi + 14, true) : 0;
+  if (mono || bitCount === 1) {
+    const decoded = decodeMonoBits(view, bmi, bitsAt);
+    if (decoded && mono) {
+      return { kind: "mono", ...decoded };
+    }
+  }
+  const image = decodeDibToImageData(view, bmi, bitsAt, cbBits);
+  if (!image) {
+    return null;
+  }
+  const rgb = new Uint32Array(image.width * image.height);
+  const d = image.data;
+  for (let i = 0; i < rgb.length; i++) {
+    rgb[i] = d[i * 4] << 16 | d[i * 4 + 1] << 8 | d[i * 4 + 2];
+  }
+  return { kind: "bitmap", width: image.width, height: image.height, rgb };
+}
+function realizeBrush(state) {
+  if (state.brushStyle === 1) {
+    return { kind: "none" };
+  }
+  const pattern = state.brushPattern;
+  if (!pattern) {
+    return { kind: "solid", rgb: cssHexToRgb(state.brushColor) };
+  }
+  if (pattern.kind === "bitmap") {
+    return { kind: "tile", width: pattern.width, height: pattern.height, rgb: pattern.rgb };
+  }
+  const bk = cssHexToRgb(state.bkColor);
+  if (pattern.kind === "hatch") {
+    const fg = cssHexToRgb(state.brushColor);
+    const rgb2 = new Uint32Array(64);
+    for (let y = 0; y < 8; y++) {
+      for (let x = 0; x < 8; x++) {
+        rgb2[y * 8 + x] = hatchBit(pattern.hatch, x, y) ? fg : bk;
+      }
+    }
+    return { kind: "tile", width: 8, height: 8, rgb: rgb2 };
+  }
+  const text = cssHexToRgb(state.textColor);
+  const rgb = new Uint32Array(pattern.width * pattern.height);
+  for (let i = 0; i < rgb.length; i++) {
+    rgb[i] = pattern.bits[i] ? bk : text;
+  }
+  return { kind: "tile", width: pattern.width, height: pattern.height, rgb };
+}
+function sampleTile(tile, devX, devY, orgX, orgY) {
+  const tx = ((devX - orgX) % tile.width + tile.width) % tile.width;
+  const ty = ((devY - orgY) % tile.height + tile.height) % tile.height;
+  return tile.rgb[ty * tile.width + tx];
+}
+
+// src/emf-gdi-stretch.ts
+var BLACKONWHITE = 1;
+var WHITEONBLACK = 2;
+var HALFTONE = 4;
+function gdiNearest(i, srcLen, dstLen) {
+  const k = Math.floor((2 * i + 1) * srcLen / (2 * dstLen));
+  return Math.max(0, Math.min(srcLen - 1, k));
+}
+function axisSamples(srcStart, srcLen, dstLen, reverse, combine) {
+  const out = [];
+  const at = (k) => reverse ? srcStart + srcLen - 1 - k : srcStart + k;
+  if (dstLen <= 0 || srcLen <= 0) {
+    return out;
+  }
+  let prev = -1;
+  for (let i = 0; i < dstLen; i++) {
+    const c = gdiNearest(i, srcLen, dstLen);
+    const run = [];
+    const from = combine && dstLen < srcLen ? prev + 1 : c;
+    for (let k = from; k <= c; k++) {
+      run.push(at(k));
+    }
+    out.push(run);
+    prev = c;
+  }
+  return out;
+}
+function stretchGdi(src, sx, sy, sw, sh, dw, dh, mode) {
+  const W = Math.max(0, Math.round(Math.abs(dw)));
+  const H = Math.max(0, Math.round(Math.abs(dh)));
+  const flipX = dw < 0 !== sw < 0;
+  const flipY = dh < 0 !== sh < 0;
+  const combine = mode === BLACKONWHITE || mode === WHITEONBLACK;
+  const cols = axisSamples(Math.round(Math.min(sx, sx + sw)), Math.round(Math.abs(sw)), W, flipX, combine);
+  const rows = axisSamples(Math.round(Math.min(sy, sy + sh)), Math.round(Math.abs(sh)), H, flipY, combine);
+  const data = new Uint8ClampedArray(W * H * 4);
+  const s = src.data;
+  const read = (x, y) => {
+    if (x < 0 || y < 0 || x >= src.width || y >= src.height) {
+      return 0;
+    }
+    const i = (y * src.width + x) * 4;
+    return s[i] << 16 | s[i + 1] << 8 | s[i + 2];
+  };
+  for (let y = 0; y < H; y++) {
+    const ys = rows[y] ?? [];
+    for (let x = 0; x < W; x++) {
+      const xs = cols[x] ?? [];
+      let v = mode === BLACKONWHITE ? 16777215 : 0;
+      let first = true;
+      for (const yy of ys) {
+        for (const xx of xs) {
+          const p = read(xx, yy);
+          if (mode === BLACKONWHITE) {
+            v &= p;
+          } else if (mode === WHITEONBLACK) {
+            v |= p;
+          } else if (first) {
+            v = p;
+          }
+          first = false;
+        }
+      }
+      const o = (y * W + x) * 4;
+      data[o] = v >> 16 & 255;
+      data[o + 1] = v >> 8 & 255;
+      data[o + 2] = v & 255;
+      data[o + 3] = 255;
+    }
+  }
+  return { width: W, height: H, data };
+}
+
+// src/emf-rop3.ts
+function rop3Index(rop) {
+  return rop >>> 16 & 255;
+}
+function rop3Operands(index) {
+  const t = index & 255;
+  return {
+    usesP: (t >> 4 & 15) !== (t & 15),
+    usesS: (t >> 2 & 51) !== (t & 51),
+    usesD: (t >> 1 & 85) !== (t & 85)
+  };
+}
+function evalRop3(index, p, s, d, mask = 16777215) {
+  let out = 0;
+  const np = ~p;
+  const ns = ~s;
+  const nd = ~d;
+  for (let i = 0; i < 8; i++) {
+    if (index & 1 << i) {
+      out |= (i & 4 ? p : np) & (i & 2 ? s : ns) & (i & 1 ? d : nd);
+    }
+  }
+  return out & mask;
+}
+function classifyRop3(rop) {
+  const index = rop3Index(rop);
+  switch (index) {
+    case 204:
+      return { kind: "copy" };
+    case 0:
+      return { kind: "solid", color: "black" };
+    case 255:
+      return { kind: "solid", color: "white" };
+    case 170:
+      return { kind: "noop" };
+    case 85:
+      return { kind: "invert-dest" };
+    default:
+      return { kind: "ternary", index, operands: rop3Operands(index) };
+  }
+}
+function applyRop3(dst, src, pattern, index, originX, originY) {
+  const d = dst.data;
+  const s = src ? src.data : null;
+  const w = dst.width;
+  const h = dst.height;
+  const solidP = typeof pattern === "number" ? pattern : 0;
+  const sampleP = typeof pattern === "function" ? pattern : null;
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      const i = (y * w + x) * 4;
+      const dv = d[i] << 16 | d[i + 1] << 8 | d[i + 2];
+      const sv = s ? s[i] << 16 | s[i + 1] << 8 | s[i + 2] : 0;
+      const pv = sampleP ? sampleP(originX + x, originY + y) : solidP;
+      const r = evalRop3(index, pv, sv, dv);
+      d[i] = r >> 16 & 255;
+      d[i + 1] = r >> 8 & 255;
+      d[i + 2] = r & 255;
+      d[i + 3] = 255;
+    }
+  }
+}
+function clampPositiveRect(x, y, w, h, canvasW, canvasH) {
+  let left = w < 0 ? x + w : x;
+  let top = h < 0 ? y + h : y;
+  let width = Math.abs(w);
+  let height = Math.abs(h);
+  left = Math.round(left);
+  top = Math.round(top);
+  width = Math.round(width);
+  height = Math.round(height);
+  const right = Math.min(left + width, Math.round(canvasW));
+  const bottom = Math.min(top + height, Math.round(canvasH));
+  left = Math.max(left, 0);
+  top = Math.max(top, 0);
+  width = right - left;
+  height = bottom - top;
+  if (width <= 0 || height <= 0) {
+    return null;
+  }
+  return { x: left, y: top, w: width, h: height };
+}
+
+// src/emf-gdi-draw-bitmap.ts
+function patternOperand(rCtx, brush) {
+  if (brush.kind === "solid") {
+    return brush.rgb;
+  }
+  if (brush.kind === "none") {
+    return 0;
+  }
+  const { state, bounds } = rCtx;
+  const sx = rCtx.sx || 1;
+  const sy = rCtx.sy || 1;
+  return (x, y) => sampleTile(
+    brush,
+    Math.floor(bounds.left + (x + 0.5) / sx),
+    Math.floor(bounds.top + (y + 0.5) / sy),
+    state.brushOrgX,
+    state.brushOrgY
+  );
+}
+function drawSourceMapped(target, decoded, req, offsetX, offsetY, mode) {
+  const dLeft = Math.min(req.dx, req.dx + req.dw) - offsetX;
+  const dTop = Math.min(req.dy, req.dy + req.dh) - offsetY;
+  if (mode !== HALFTONE) {
+    const px = stretchGdi(decoded.pixels, req.sx, req.sy, req.sw, req.sh, req.dw, req.dh, mode);
+    const tile = createTempCanvas(px.width, px.height);
+    if (!tile) {
+      return;
+    }
+    canvasPutImageData(tile.ctx, createImageDataCompat(px.data, px.width, px.height), 0, 0);
+    target.save();
+    target.globalCompositeOperation = "source-over";
+    canvasDrawImage(target, tile.canvas, Math.round(dLeft), Math.round(dTop), px.width, px.height);
+    target.restore();
+    return;
+  }
+  const flipX = req.dw < 0 !== req.sw < 0;
+  const flipY = req.dh < 0 !== req.sh < 0;
+  const adw = Math.abs(req.dw);
+  const adh = Math.abs(req.dh);
+  target.save();
+  target.imageSmoothingEnabled = true;
+  target.transform(
+    flipX ? -1 : 1,
+    0,
+    0,
+    flipY ? -1 : 1,
+    flipX ? dLeft * 2 + adw : 0,
+    flipY ? dTop * 2 + adh : 0
+  );
+  const draw = target.drawImage;
+  draw.call(
+    target,
+    decoded.canvas,
+    Math.min(req.sx, req.sx + req.sw),
+    Math.min(req.sy, req.sy + req.sh),
+    Math.abs(req.sw),
+    Math.abs(req.sh),
+    dLeft,
+    dTop,
+    adw,
+    adh
+  );
+  target.restore();
+}
+function decodeSource(rCtx, req) {
+  if (!req.source) {
+    return null;
+  }
+  const image = decodeDibToImageData(rCtx.view, req.source.bmi, req.source.bits, req.source.cbBits);
+  if (!image) {
+    return null;
+  }
+  const temp = createTempCanvas(image.width, image.height);
+  if (!temp) {
+    return null;
+  }
+  canvasPutImageData(temp.ctx, image, 0, 0);
+  let { sy } = req;
+  if (req.dibOrigin === "bottom-left" && rCtx.view.getInt32(req.source.bmi + 8, true) > 0) {
+    sy = image.height - sy - req.sh;
+  }
+  return {
+    decoded: { pixels: image, canvas: temp.canvas },
+    req: { ...req, sy }
+  };
+}
+function fillRectWith(ctx, style, gco, req) {
+  const prevGco = ctx.globalCompositeOperation;
+  const prevFill = ctx.fillStyle;
+  ctx.globalCompositeOperation = gco;
+  ctx.fillStyle = style;
+  ctx.fillRect(req.dx, req.dy, req.dw, req.dh);
+  ctx.globalCompositeOperation = prevGco;
+  ctx.fillStyle = prevFill;
+}
+function runTernary(rCtx, req, index, usesP, usesS) {
+  const { ctx } = rCtx;
+  const rect = clampPositiveRect(req.dx, req.dy, req.dw, req.dh, rCtx.canvasW, rCtx.canvasH);
+  if (!rect) {
+    return;
+  }
+  if (typeof ctx.getImageData !== "function") {
+    return;
+  }
+  const brush = realizeBrush(rCtx.state);
+  if (usesP && brush.kind === "none") {
+    return;
+  }
+  const layer = createTempCanvas(rect.w, rect.h);
+  if (!layer) {
+    return;
+  }
+  let src = null;
+  if (usesS) {
+    const decoded = decodeSource(rCtx, req);
+    if (!decoded) {
+      return;
+    }
+    drawSourceMapped(layer.ctx, decoded.decoded, decoded.req, rect.x, rect.y, rCtx.state.stretchBltMode);
+    src = canvasGetImageData(layer.ctx, 0, 0, rect.w, rect.h);
+  }
+  const dst = canvasGetImageData(ctx, rect.x, rect.y, rect.w, rect.h);
+  applyRop3(dst, src, patternOperand(rCtx, brush), index, rect.x, rect.y);
+  canvasPutImageData(layer.ctx, dst, 0, 0);
+  ctx.save();
+  ctx.setTransform(1, 0, 0, 1, 0, 0);
+  ctx.globalCompositeOperation = "source-over";
+  ctx.globalAlpha = 1;
+  canvasDrawImage(ctx, layer.canvas, rect.x, rect.y, rect.w, rect.h);
+  ctx.restore();
+}
+function alignMirroredDest(rCtx, req) {
+  const pxX = rCtx.useMappingMode ? 1 : rCtx.sx;
+  const pxY = rCtx.useMappingMode ? 1 : rCtx.sy;
+  return {
+    ...req,
+    dx: req.dw < 0 ? req.dx + pxX : req.dx,
+    dy: req.dh < 0 ? req.dy + pxY : req.dy
+  };
+}
+function executeBlit(rCtx, request) {
+  const { ctx } = rCtx;
+  const req = alignMirroredDest(rCtx, request);
+  const plan = req.plan;
+  switch (plan.kind) {
+    case "noop":
+      return;
+    case "solid":
+      fillRectWith(ctx, plan.color === "black" ? "#000000" : "#ffffff", "source-over", req);
+      return;
+    case "invert-dest":
+      fillRectWith(ctx, "#ffffff", "difference", req);
+      return;
+    case "copy": {
+      const decoded = decodeSource(rCtx, req);
+      if (decoded) {
+        drawSourceMapped(ctx, decoded.decoded, decoded.req, 0, 0, rCtx.state.stretchBltMode);
+      }
+      return;
+    }
+    case "ternary": {
+      const brush = realizeBrush(rCtx.state);
+      if (plan.index === 240 && brush.kind !== "tile") {
+        if (brush.kind === "solid") {
+          fillRectWith(ctx, rCtx.state.brushColor, "source-over", req);
+        }
+        return;
+      }
+      runTernary(rCtx, req, plan.index, plan.operands.usesP, plan.operands.usesS);
+    }
+  }
+}
+function sourceOf(offset, offBmi, cbBmi, offBits, cbBits) {
+  return offBmi > 0 && cbBmi > 0 && offBits > 0 && cbBits > 0 ? { bmi: offset + offBmi, bits: offset + offBits, cbBits } : null;
+}
+function handleBlt(rCtx, offset, dataOff, recSize, stretch) {
+  const { view } = rCtx;
+  if (recSize < (stretch ? 108 : 96)) {
+    return true;
+  }
+  const xDest = view.getInt32(dataOff + 16, true);
+  const yDest = view.getInt32(dataOff + 20, true);
+  const cxDest = view.getInt32(dataOff + 24, true);
+  const cyDest = view.getInt32(dataOff + 28, true);
+  const rop = view.getUint32(dataOff + 32, true);
+  const xSrc = view.getInt32(dataOff + 36, true);
+  const ySrc = view.getInt32(dataOff + 40, true);
+  const m11 = view.getFloat32(dataOff + 44, true);
+  const m12 = view.getFloat32(dataOff + 48, true);
+  const m21 = view.getFloat32(dataOff + 52, true);
+  const m22 = view.getFloat32(dataOff + 56, true);
+  const mdx = view.getFloat32(dataOff + 60, true);
+  const mdy = view.getFloat32(dataOff + 64, true);
+  const cxSrc = stretch ? view.getInt32(dataOff + 92, true) : cxDest;
+  const cySrc = stretch ? view.getInt32(dataOff + 96, true) : cyDest;
+  const source = recSize >= 100 ? sourceOf(
+    offset,
+    view.getUint32(dataOff + 76, true),
+    view.getUint32(dataOff + 80, true),
+    view.getUint32(dataOff + 84, true),
+    view.getUint32(dataOff + 88, true)
+  ) : null;
+  const identity = m11 === 0 && m22 === 0 && m12 === 0 && m21 === 0;
+  const a = identity ? 1 : m11;
+  const d = identity ? 1 : m22;
+  executeBlit(rCtx, {
+    plan: classifyRop3(rop),
+    dx: gmx(rCtx, xDest),
+    dy: gmy(rCtx, yDest),
+    dw: gmw(rCtx, cxDest),
+    dh: gmh(rCtx, cyDest),
+    source,
+    sx: a * xSrc + (identity ? 0 : m21 * ySrc + mdx),
+    sy: d * ySrc + (identity ? 0 : m12 * xSrc + mdy),
+    sw: a * cxSrc,
+    sh: d * cySrc,
+    dibOrigin: "top-left"
+  });
+  return true;
+}
+function handleStretchDibits(rCtx, offset, dataOff, recSize) {
+  const { view } = rCtx;
+  if (recSize < 80) {
+    return true;
+  }
+  executeBlit(rCtx, {
+    plan: classifyRop3(view.getUint32(dataOff + 60, true)),
+    dx: gmx(rCtx, view.getInt32(dataOff + 16, true)),
+    dy: gmy(rCtx, view.getInt32(dataOff + 20, true)),
+    dw: gmw(rCtx, view.getInt32(dataOff + 64, true)),
+    dh: gmh(rCtx, view.getInt32(dataOff + 68, true)),
+    source: sourceOf(
+      offset,
+      view.getUint32(dataOff + 40, true),
+      view.getUint32(dataOff + 44, true),
+      view.getUint32(dataOff + 48, true),
+      view.getUint32(dataOff + 52, true)
+    ),
+    sx: view.getInt32(dataOff + 24, true),
+    sy: view.getInt32(dataOff + 28, true),
+    sw: view.getInt32(dataOff + 32, true),
+    sh: view.getInt32(dataOff + 36, true),
+    dibOrigin: "bottom-left"
+  });
+  return true;
+}
+function handleEmfGdiBitmapRecord(rCtx, recType, offset, dataOff, recSize) {
+  switch (recType) {
+    case EMR_BITBLT:
+      return handleBlt(rCtx, offset, dataOff, recSize, false);
+    case EMR_STRETCHBLT:
+      return handleBlt(rCtx, offset, dataOff, recSize, true);
+    case EMR_STRETCHDIBITS:
+      return handleStretchDibits(rCtx, offset, dataOff, recSize);
+    default:
+      return false;
+  }
+}
+
+// src/emf-gdi-draw-text.ts
+function readDxArray(view, offset, dataOff, nChars, viewEnd) {
+  const offDx = view.getUint32(dataOff + 64, true);
+  if (offDx === 0) {
+    return null;
+  }
+  const start = offset + offDx;
+  const end = start + nChars * 4;
+  if (start < 0 || end > viewEnd) {
+    return null;
+  }
+  const dx = [];
+  for (let i = 0; i < nChars; i++) {
+    dx.push(view.getUint32(start + i * 4, true));
+  }
+  return dx;
+}
+function horizontalAlign(textAlign) {
+  if (textAlign & 2) {
+    return "right";
+  }
+  if (textAlign & 6) {
+    return "center";
+  }
+  return "left";
+}
+function verticalBaseline(textAlign) {
+  const vAlign = textAlign & 24;
+  return vAlign === 24 ? "alphabetic" : vAlign === 8 ? "bottom" : "top";
+}
+function paintRun(ctx, state, text, dxDevice, startX, y, align, fontScale) {
+  const totalWidth = dxDevice ? totalGlyphAdvance(dxDevice) : ctx.measureText(text).width;
+  const runStartX = dxDevice ? startX + alignmentStartOffset(totalWidth, align) : startX;
+  if (state.bkMode === 2) {
+    const bgH = fontSizePx(state, fontScale);
+    const prevFill = ctx.fillStyle;
+    ctx.fillStyle = state.bkColor;
+    ctx.fillRect(runStartX, y - bgH, totalWidth, bgH);
+    ctx.fillStyle = prevFill;
+  }
+  ctx.fillStyle = state.textColor;
+  if (dxDevice) {
+    const offsets = cumulativeGlyphOffsets(dxDevice);
+    const prevAlign = ctx.textAlign;
+    ctx.textAlign = "left";
+    for (let i = 0; i < text.length && i < offsets.length; i++) {
+      ctx.fillText(text[i], runStartX + offsets[i], y);
+    }
+    ctx.textAlign = prevAlign;
+  } else {
+    ctx.fillText(text, startX, y);
+  }
+  if (state.fontUnderline || state.fontStrikeOut) {
+    drawTextDecorations(ctx, state, runStartX, y, totalWidth, fontScale);
+  }
+}
+function handleExtTextOutW(rCtx, offset, dataOff, recSize) {
+  const { ctx, view, state } = rCtx;
+  if (recSize < 76) {
+    return true;
+  }
+  const refX = view.getInt32(dataOff + 28, true);
+  const refY = view.getInt32(dataOff + 32, true);
+  const nChars = view.getUint32(dataOff + 36, true);
+  const offString = view.getUint32(dataOff + 40, true);
+  const viewEnd = view.byteLength;
+  if (nChars === 0 || offString === 0 || offset + offString + nChars * 2 > viewEnd) {
+    return true;
+  }
+  const text = readUtf16LE(view, offset + offString, nChars);
+  if (text.length === 0) {
+    return true;
+  }
+  const fontScale = Math.abs(gmh(rCtx, 1));
+  applyFont(ctx, state, fontScale);
+  const align = horizontalAlign(state.textAlign);
+  ctx.textBaseline = verticalBaseline(state.textAlign);
+  ctx.textAlign = align === "center" ? "center" : align === "right" ? "right" : "left";
+  const dxLogical = readDxArray(view, offset, dataOff, nChars, viewEnd);
+  const dxDevice = dxLogical ? dxLogical.map((v) => gmw(rCtx, v)) : null;
+  if (dxDevice) {
+    ctx.textAlign = "left";
+  }
+  const baseX = gmx(rCtx, refX);
+  const baseY = gmy(rCtx, refY);
+  const radians = escapementToCanvasRadians(state.fontEscapementTenthDeg);
+  if (radians !== 0) {
+    ctx.save();
+    ctx.translate(baseX, baseY);
+    ctx.rotate(radians);
+    paintRun(ctx, state, text, dxDevice, 0, 0, align, fontScale);
+    ctx.restore();
+  } else {
+    paintRun(ctx, state, text, dxDevice, baseX, baseY, align, fontScale);
+  }
+  return true;
+}
+function handleEmfGdiDrawTextRecord(rCtx, recType, offset, dataOff, recSize) {
+  if (recType === EMR_EXTTEXTOUTW) {
+    return handleExtTextOutW(rCtx, offset, dataOff, recSize);
+  }
+  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 };
         }
-        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, fontScale);
+        if (current.length === 1) {
+          return combineClip(null, current[0], "exclude");
         }
+        return { region: current, exact: false };
       }
     }
   }
-  return true;
+  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 };
+    }
+  }
 }
-var ROP_PATCOPY = 15728673;
-var BS_NULL = 1;
-function handleBitBlt(rCtx, offset, dataOff, recSize) {
-  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;
+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;
     }
-    if (offBmiSrc > 0 && cbBmiSrc > 0 && offBitsSrc > 0 && cbBitsSrc > 0) {
-      const imageData = decodeDibToImageData(
-        view,
-        offset + offBmiSrc,
-        offset + offBitsSrc,
-        cbBitsSrc
-      );
-      if (imageData) {
-        const temp = createTempCanvas(imageData.width, imageData.height);
-        if (temp) {
-          temp.ctx.putImageData(imageData, 0, 0);
-          canvasDrawImage(
-            ctx,
-            temp.canvas,
-            gmx(rCtx, dstX),
-            gmy(rCtx, dstY),
-            gmw(rCtx, dstW),
-            gmh(rCtx, dstH)
-          );
-        }
-      }
+  }
+}
+function applyClipShapes(ctx, shapes) {
+  for (const s of shapes) {
+    ctx.beginPath();
+    replayClipCmds(ctx, s.cmds);
+    try {
+      ctx.clip(s.fillRule);
+    } catch {
     }
   }
-  return true;
 }
-function handleStretchDibits(rCtx, offset, dataOff, recSize) {
-  const { ctx, view } = rCtx;
-  if (recSize >= 80) {
-    const dstX = view.getInt32(dataOff + 16, true);
-    const dstY = view.getInt32(dataOff + 20, true);
-    const dstW = view.getInt32(dataOff + 64, true);
-    const dstH = view.getInt32(dataOff + 68, true);
-    const offBmiSrc = view.getUint32(dataOff + 40, true);
-    const cbBmiSrc = view.getUint32(dataOff + 44, true);
-    const offBitsSrc = view.getUint32(dataOff + 48, true);
-    const cbBitsSrc = view.getUint32(dataOff + 52, true);
-    if (offBmiSrc > 0 && cbBmiSrc > 0 && offBitsSrc > 0 && cbBitsSrc > 0) {
-      const imageData = decodeDibToImageData(
-        view,
-        offset + offBmiSrc,
-        offset + offBitsSrc,
-        cbBitsSrc
-      );
-      if (imageData) {
-        const temp = createTempCanvas(imageData.width, imageData.height);
-        if (temp) {
-          temp.ctx.putImageData(imageData, 0, 0);
-          canvasDrawImage(
-            ctx,
-            temp.canvas,
-            gmx(rCtx, dstX),
-            gmy(rCtx, dstY),
-            gmw(rCtx, dstW),
-            gmh(rCtx, dstH)
-          );
-        }
-      }
+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);
   }
-  return true;
 }
+
+// src/emf-gdi-clip-records.ts
 function gdiCombineClip(rCtx, shape, op) {
   const { ctx } = rCtx;
   if (rCtx.clipUntracked && op !== "replace") {
@@ -1718,14 +2289,8 @@ function handleOffsetClipRgn(rCtx, dataOff, recSize) {
   }
   return true;
 }
-function handleEmfGdiTextBitmapRecord(rCtx, recType, offset, dataOff, recSize) {
+function handleEmfGdiClipRecord(rCtx, recType, dataOff, recSize) {
   switch (recType) {
-    case EMR_EXTTEXTOUTW:
-      return handleExtTextOutW(rCtx, offset, dataOff, recSize);
-    case EMR_BITBLT:
-      return handleBitBlt(rCtx, offset, dataOff, recSize);
-    case EMR_STRETCHDIBITS:
-      return handleStretchDibits(rCtx, offset, dataOff, recSize);
     case EMR_INTERSECTCLIPRECT:
       return handleIntersectClipRect(rCtx, dataOff, recSize);
     case EMR_EXTSELECTCLIPRGN:
@@ -1739,6 +2304,11 @@ function handleEmfGdiTextBitmapRecord(rCtx, recType, offset, dataOff, recSize) {
   }
 }
 
+// src/emf-gdi-draw-text-bitmap.ts
+function handleEmfGdiTextBitmapRecord(rCtx, recType, offset, dataOff, recSize) {
+  return handleEmfGdiDrawTextRecord(rCtx, recType, offset, dataOff, recSize) || handleEmfGdiBitmapRecord(rCtx, recType, offset, dataOff, recSize) || handleEmfGdiClipRecord(rCtx, recType, dataOff, recSize);
+}
+
 // src/emf-gdi-draw-handlers.ts
 function handleEmfGdiDrawRecord(rCtx, recType, offset, dataOff, recSize) {
   return handleEmfGdiShapeRecord(rCtx, recType, dataOff, recSize) || handleEmfGdiTextBitmapRecord(rCtx, recType, offset, dataOff, recSize);
@@ -2091,10 +2661,28 @@ function handleEmfObjectRecord(rCtx, recType, dataOff, recSize) {
         const ihBrush = view.getUint32(dataOff, true);
         const brushStyle = view.getUint32(dataOff + 4, true);
         const color = readColorRef(view, dataOff + 8);
+        const hatch = view.getUint32(dataOff + 12, true);
         rCtx.objectTable.set(ihBrush, {
           kind: "brush",
           style: brushStyle,
-          color
+          color,
+          ...brushStyle === 2 && hatch <= 5 ? { pattern: { kind: "hatch", hatch } } : {}
+        });
+      }
+      return true;
+    }
+    case EMR_CREATEMONOBRUSH:
+    case EMR_CREATEDIBPATTERNBRUSHPT: {
+      if (recSize >= 32) {
+        const ihBrush = view.getUint32(dataOff, true);
+        const mono = recType === EMR_CREATEMONOBRUSH;
+        const pattern = parsePatternBrush(view, dataOff - 8, dataOff, mono);
+        rCtx.objectTable.set(ihBrush, {
+          kind: "brush",
+          style: pattern ? mono ? 3 : 6 : 0,
+          // Flat stand-in for fills that do not realise the pattern.
+          color: "#808080",
+          ...pattern ? { pattern } : {}
         });
       }
       return true;
@@ -2103,19 +2691,23 @@ function handleEmfObjectRecord(rCtx, recType, dataOff, recSize) {
       if (recSize >= 332) {
         const ihFont = view.getUint32(dataOff, true);
         const height = view.getInt32(dataOff + 4, true);
+        const escapementTenthDeg = view.getInt32(dataOff + 12, 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";
+        const family = readUtf16LE(view, dataOff + 32, 32) || "sans-serif";
         rCtx.objectTable.set(ihFont, {
           kind: "font",
-          height: Math.abs(height),
+          // Sign kept (not Math.abs'd): resolveFontPixelHeight() needs it
+          // to distinguish GDI's cell-height vs character-height convention.
+          height,
           weight,
           italic: italic !== 0,
           underline: underline !== 0,
           strikeOut: strikeOut !== 0,
-          family
+          family,
+          escapementTenthDeg
         });
       }
       return true;
@@ -2134,6 +2726,7 @@ function handleEmfObjectRecord(rCtx, recType, dataOff, recSize) {
             case "brush":
               state.brushStyle = obj.style;
               state.brushColor = obj.color;
+              state.brushPattern = obj.pattern ?? null;
               break;
             case "font":
               state.fontHeight = obj.height;
@@ -2142,6 +2735,7 @@ function handleEmfObjectRecord(rCtx, recType, dataOff, recSize) {
               state.fontUnderline = obj.underline;
               state.fontStrikeOut = obj.strikeOut;
               state.fontFamily = obj.family;
+              state.fontEscapementTenthDeg = obj.escapementTenthDeg ?? 0;
               break;
           }
         }
@@ -2310,15 +2904,22 @@ function defaultState() {
     penStyle: 0,
     brushColor: "#ffffff",
     brushStyle: 0,
+    brushPattern: null,
+    brushOrgX: 0,
+    brushOrgY: 0,
+    stretchBltMode: 1,
     textColor: "#000000",
     bkColor: "#ffffff",
     bkMode: 1,
-    fontHeight: 12,
+    // Negative (character-height convention) so the no-font-selected default
+    // resolves to exactly 12px, matching this library's historical fallback.
+    fontHeight: -12,
     fontWeight: 400,
     fontItalic: false,
     fontFamily: "sans-serif",
     fontUnderline: false,
     fontStrikeOut: false,
+    fontEscapementTenthDeg: 0,
     rop2: 13,
     curX: 0,
     curY: 0,
@@ -2435,7 +3036,19 @@ function handleEmfGdiStateRecord(rCtx, recType, _offset, dataOff, recSize) {
       }
       return true;
     }
-    case EMR_SETSTRETCHBLTMODE:
+    case EMR_SETSTRETCHBLTMODE: {
+      if (recSize >= 12) {
+        state.stretchBltMode = view.getUint32(dataOff, true);
+      }
+      return true;
+    }
+    case EMR_SETBRUSHORGEX: {
+      if (recSize >= 16) {
+        state.brushOrgX = view.getInt32(dataOff, true);
+        state.brushOrgY = view.getInt32(dataOff + 4, true);
+      }
+      return true;
+    }
     case EMR_SETMITERLIMIT:
     case EMR_SETTEXTALIGN: {
       if (recType === EMR_SETTEXTALIGN && recSize >= 12) {
@@ -2478,6 +3091,375 @@ function readPointFromView(view, offset, compressed) {
   };
 }
 
+// src/emf-plus-brush-gradient.ts
+var IDENTITY = [1, 0, 0, 1, 0, 0];
+function mulMatrix(a, b) {
+  return [
+    a[0] * b[0] + a[2] * b[1],
+    a[1] * b[0] + a[3] * b[1],
+    a[0] * b[2] + a[2] * b[3],
+    a[1] * b[2] + a[3] * b[3],
+    a[0] * b[4] + a[2] * b[5] + a[4],
+    a[1] * b[4] + a[3] * b[5] + a[5]
+  ];
+}
+function invertLinear(m) {
+  const det = m[0] * m[3] - m[1] * m[2];
+  if (!Number.isFinite(det) || Math.abs(det) < 1e-12) {
+    return null;
+  }
+  return [m[3] / det, -m[1] / det, -m[2] / det, m[0] / det];
+}
+function lerpArgb(a, b, t) {
+  const ch = (shift) => {
+    const ca = a >>> shift & 255;
+    const cb = b >>> shift & 255;
+    return Math.round(ca + (cb - ca) * t);
+  };
+  return (ch(24) << 24 | ch(16) << 16 | ch(8) << 8 | ch(0)) >>> 0;
+}
+function piecewise(xs, ys, x) {
+  const n = Math.min(xs.length, ys.length);
+  if (n === 0) {
+    return x;
+  }
+  if (x <= xs[0]) {
+    return ys[0];
+  }
+  for (let i = 1; i < n; i++) {
+    if (x <= xs[i]) {
+      const span = xs[i] - xs[i - 1];
+      const f = span > 0 ? (x - xs[i - 1]) / span : 1;
+      return ys[i - 1] + (ys[i] - ys[i - 1]) * f;
+    }
+  }
+  return ys[n - 1];
+}
+function stopColorAt(stops, t) {
+  if (stops.length === 0 || stops.some((s) => s.argb === void 0)) {
+    return null;
+  }
+  if (t <= stops[0].offset) {
+    return stops[0].argb;
+  }
+  for (let i = 1; i < stops.length; i++) {
+    const b = stops[i];
+    if (t <= b.offset) {
+      const a = stops[i - 1];
+      const span = b.offset - a.offset;
+      return lerpArgb(a.argb, b.argb, span > 0 ? (t - a.offset) / span : 1);
+    }
+  }
+  return stops[stops.length - 1].argb;
+}
+function pathGradientColorAt(shape, x, y) {
+  const { center, boundary, boundaryArgb } = shape;
+  const n = boundary.length;
+  const px = x - center.x;
+  const py = y - center.y;
+  let found = -1;
+  let bestS = 0;
+  let bestU = 0;
+  const eps = 1e-9;
+  for (let i = 0; i < n; i++) {
+    const v0 = boundary[i];
+    const v1 = boundary[(i + 1) % n];
+    const ax = v0.x - center.x;
+    const ay = v0.y - center.y;
+    const ex = v1.x - v0.x;
+    const ey = v1.y - v0.y;
+    const det = ax * ey - ay * ex;
+    if (Math.abs(det) < 1e-12) {
+      continue;
+    }
+    const alpha = (px * ey - py * ex) / det;
+    const beta = (ax * py - ay * px) / det;
+    if (alpha < -eps || beta < -eps || beta > alpha + eps || alpha > 1 + eps) {
+      continue;
+    }
+    found = i;
+    bestS = Math.max(0, alpha);
+    bestU = alpha > 0 ? Math.min(1, Math.max(0, beta / alpha)) : 0;
+  }
+  if (found < 0) {
+    return null;
+  }
+  let s = bestS;
+  if (shape.focus) {
+    const f = Math.min(0.999, Math.max(0, (shape.focus.x + shape.focus.y) / 2));
+    s = s <= f ? 0 : (s - f) / (1 - f);
+  }
+  const pos = 1 - s;
+  if (shape.preset && shape.preset.positions.length > 0) {
+    const { positions, argb } = shape.preset;
+    if (pos <= positions[0]) {
+      return argb[0];
+    }
+    for (let k = 1; k < positions.length; k++) {
+      if (pos <= positions[k]) {
+        const span = positions[k] - positions[k - 1];
+        return lerpArgb(argb[k - 1], argb[k], span > 0 ? (pos - positions[k - 1]) / span : 1);
+      }
+    }
+    return argb[positions.length - 1];
+  }
+  const c0 = boundaryArgb[found] ?? shape.centerArgb;
+  const c1 = boundaryArgb[(found + 1) % n] ?? c0;
+  const surround = lerpArgb(c0, c1, bestU);
+  const factor = shape.blend ? piecewise(shape.blend.positions, shape.blend.factors, pos) : pos;
+  return lerpArgb(surround, shape.centerArgb, Math.min(1, Math.max(0, factor)));
+}
+var MAX_TILE = 2048;
+function mirrorFlags(wrap) {
+  return {
+    x: wrap === "tile-flip-x" || wrap === "tile-flip-xy",
+    y: wrap === "tile-flip-y" || wrap === "tile-flip-xy"
+  };
+}
+function buildPattern(ctx, rect, tw, th, wrap, brush, delta, sampling, colorAt) {
+  if (typeof ctx.createPattern !== "function") {
+    return null;
+  }
+  const mirror = wrap === "clamp" ? { x: false, y: false } : mirrorFlags(wrap);
+  const w = tw * (mirror.x ? 2 : 1);
+  const h = th * (mirror.y ? 2 : 1);
+  const temp = createTempCanvas(w, h);
+  if (!temp) {
+    return null;
+  }
+  const stepX = rect.w / tw;
+  const stepY = rect.h / th;
+  const offX = (i) => {
+    const d = i % tw * stepX + (0.5 + sampling.phaseX) * stepX;
+    return i < tw ? d : rect.w - sampling.lagX - (d - (0.5 + sampling.phaseX) * stepX) - 0.5 * stepX;
+  };
+  const offY = (j) => {
+    const d = (j % th + 0.5) * stepY;
+    return j < th ? d : rect.h - sampling.lagY - d;
+  };
+  const data = new Uint8ClampedArray(w * h * 4);
+  for (let j = 0; j < h; j++) {
+    const by = rect.y + offY(j);
+    for (let i = 0; i < w; i++) {
+      const c = colorAt(rect.x + offX(i), by);
+      if (c === null) {
+        continue;
+      }
+      const o = (j * w + i) * 4;
+      data[o] = c >>> 16 & 255;
+      data[o + 1] = c >>> 8 & 255;
+      data[o + 2] = c & 255;
+      data[o + 3] = c >>> 24 & 255;
+    }
+  }
+  canvasPutImageData(temp.ctx, createImageDataCompat(data, w, h), 0, 0);
+  const pattern = canvasCreatePattern(ctx, temp.canvas, wrap === "clamp" ? "no-repeat" : "repeat");
+  if (!pattern || typeof pattern.setTransform !== "function") {
+    return null;
+  }
+  const place = [stepX, 0, 0, stepY, rect.x + sampling.phaseX * stepX, rect.y];
+  const m = mulMatrix([1, 0, 0, 1, delta.x, delta.y], mulMatrix(brush, place));
+  try {
+    pattern.setTransform({ a: m[0], b: m[1], c: m[2], d: m[3], e: m[4], f: m[5] });
+  } catch {
+    return null;
+  }
+  return pattern;
+}
+function halfPixelDelta(device) {
+  const inv = invertLinear(device);
+  if (!inv) {
+    return { x: 0, y: 0 };
+  }
+  return { x: inv[0] * 0.5 + inv[2] * 0.5, y: inv[1] * 0.5 + inv[3] * 0.5 };
+}
+var SUPERSAMPLE = 4;
+function texelsFor(full, axis, length) {
+  const scale = axis === "x" ? Math.hypot(full[0], full[1]) : Math.hypot(full[2], full[3]);
+  return Math.max(2, Math.min(MAX_TILE, Math.ceil(Math.abs(length) * scale * SUPERSAMPLE)));
+}
+function linearGradientEndpoints(rect, transform) {
+  const m = transform ?? IDENTITY;
+  const map = (x, y) => ({
+    x: m[0] * x + m[2] * y + m[4],
+    y: m[1] * x + m[3] * y + m[5]
+  });
+  const p1 = map(rect.x, rect.y + rect.h / 2);
+  const pe = map(rect.x + rect.w, rect.y + rect.h / 2);
+  const nx = m[3];
+  const ny = -m[2];
+  const nn = nx * nx + ny * ny;
+  if (nn < 1e-12) {
+    return { x1: p1.x, y1: p1.y, x2: pe.x, y2: pe.y };
+  }
+  const t = ((pe.x - p1.x) * nx + (pe.y - p1.y) * ny) / nn;
+  return { x1: p1.x, y1: p1.y, x2: p1.x + nx * t, y2: p1.y + ny * t };
+}
+function plainLinear(ctx, grad) {
+  if (typeof ctx.createLinearGradient !== "function") {
+    return null;
+  }
+  const pts = grad.rect ? linearGradientEndpoints(grad.rect, grad.transform) : grad;
+  if (pts.x1 === pts.x2 && pts.y1 === pts.y2) {
+    return null;
+  }
+  const g = ctx.createLinearGradient(pts.x1, pts.y1, pts.x2, pts.y2);
+  for (const stop of grad.stops) {
+    g.addColorStop(stop.offset, stop.color);
+  }
+  return g;
+}
+var SEAM_BIAS = 1e-5;
+var MAX_PERIODS = 2048;
+function surfaceSize(ctx) {
+  const canvas = ctx.canvas;
+  const w = canvas?.width;
+  const h = canvas?.height;
+  return typeof w === "number" && typeof h === "number" && w > 0 && h > 0 ? { w, h } : null;
+}
+function tiledLinear(ctx, grad, rect, device) {
+  const size = surfaceSize(ctx);
+  const inv = invertLinear(device);
+  if (!size || !inv || typeof ctx.createLinearGradient !== "function") {
+    return null;
+  }
+  const e = linearGradientEndpoints(rect, grad.transform);
+  const delta = halfPixelDelta(device);
+  const dx = e.x2 - e.x1;
+  const dy = e.y2 - e.y1;
+  const x1 = e.x1 + delta.x + dx * SEAM_BIAS;
+  const y1 = e.y1 + delta.y + dy * SEAM_BIAS;
+  const len2 = dx * dx + dy * dy;
+  if (!(len2 > 1e-12)) {
+    return null;
+  }
+  let tMin = Infinity;
+  let tMax = -Infinity;
+  for (const [cx, cy] of [
+    [0, 0],
+    [size.w, 0],
+    [0, size.h],
+    [size.w, size.h]
+  ]) {
+    const px = cx - device[4];
+    const py = cy - device[5];
+    const wx = inv[0] * px + inv[2] * py;
+    const wy = inv[1] * px + inv[3] * py;
+    const t = ((wx - x1) * dx + (wy - y1) * dy) / len2;
+    tMin = Math.min(tMin, t);
+    tMax = Math.max(tMax, t);
+  }
+  const k0 = Math.floor(tMin);
+  const k1 = Math.max(k0 + 1, Math.ceil(tMax));
+  if (k1 - k0 > MAX_PERIODS) {
+    return null;
+  }
+  const g = ctx.createLinearGradient(x1 + dx * k0, y1 + dy * k0, x1 + dx * k1, y1 + dy * k1);
+  const span = k1 - k0;
+  const mirrorX = mirrorFlags(grad.wrapMode).x;
+  const reversed = [...grad.stops].reverse();
+  for (let k = k0; k < k1; k++) {
+    const mirrored = mirrorX && (k % 2 + 2) % 2 === 1;
+    for (const stop of mirrored ? reversed : grad.stops) {
+      const local = mirrored ? 1 - stop.offset : stop.offset;
+      g.addColorStop(Math.min(1, Math.max(0, (k - k0 + local) / span)), stop.color);
+    }
+  }
+  return g;
+}
+function linearPaint(ctx, grad, device) {
+  const rect = grad.rect;
+  if (grad.wrapMode !== "clamp" && rect && rect.w !== 0) {
+    const unrolled = tiledLinear(ctx, grad, rect, device);
+    if (unrolled) {
+      return unrolled;
+    }
+    if (stopColorAt(grad.stops, 0) !== null) {
+      const brush = grad.transform ?? IDENTITY;
+      const tw = texelsFor(mulMatrix(device, brush), "x", rect.w);
+      const pattern = buildPattern(
+        ctx,
+        rect,
+        tw,
+        1,
+        grad.wrapMode,
+        brush,
+        halfPixelDelta(device),
+        { phaseX: 0.5, lagX: 0, lagY: 0 },
+        (bx) => stopColorAt(grad.stops, (bx - rect.x) / rect.w)
+      );
+      if (pattern) {
+        return pattern;
+      }
+    }
+  }
+  return plainLinear(ctx, grad);
+}
+function boundaryBox(points) {
+  if (points.length < 3) {
+    return null;
+  }
+  let x0 = Infinity;
+  let y0 = Infinity;
+  let x1 = -Infinity;
+  let y1 = -Infinity;
+  for (const p of points) {
+    x0 = Math.min(x0, p.x);
+    y0 = Math.min(y0, p.y);
+    x1 = Math.max(x1, p.x);
+    y1 = Math.max(y1, p.y);
+  }
+  return x1 > x0 && y1 > y0 ? { x: x0, y: y0, w: x1 - x0, h: y1 - y0 } : null;
+}
+function pathPaint(ctx, shape, wrap, device) {
+  const box = boundaryBox(shape.boundary);
+  if (!box) {
+    return null;
+  }
+  const brush = shape.transform ?? IDENTITY;
+  const full = mulMatrix(device, brush);
+  const pxX = Math.hypot(full[0], full[1]);
+  const pxY = Math.hypot(full[2], full[3]);
+  return buildPattern(
+    ctx,
+    box,
+    texelsFor(full, "x", box.w),
+    texelsFor(full, "y", box.h),
+    wrap,
+    brush,
+    halfPixelDelta(device),
+    { phaseX: 0, lagX: pxX > 0 ? 1 / pxX : 0, lagY: pxY > 0 ? 1 / pxY : 0 },
+    (bx, by) => pathGradientColorAt(shape, bx, by)
+  );
+}
+function radialFallback(ctx, grad) {
+  if (!(grad.r > 0) || typeof ctx.createRadialGradient !== "function") {
+    return null;
+  }
+  const g = ctx.createRadialGradient(grad.cx, grad.cy, 0, grad.cx, grad.cy, grad.r);
+  for (const stop of grad.stops) {
+    g.addColorStop(stop.offset, stop.color);
+  }
+  return g;
+}
+function createBrushGradient(ctx, grad, device = IDENTITY) {
+  try {
+    if (grad.type === "linear") {
+      return linearPaint(ctx, grad, device);
+    }
+    if (grad.shape) {
+      const pattern = pathPaint(ctx, grad.shape, grad.wrapMode, device);
+      if (pattern) {
+        return pattern;
+      }
+      emfLog("createBrushGradient: path gradient pattern unavailable, using the radial approximation");
+    }
+    return radialFallback(ctx, grad);
+  } catch {
+    return null;
+  }
+}
+
 // src/emf-plus-path.ts
 function parseEmfPlusPath(data, off, maxLen) {
   if (maxLen < 12) {
@@ -2612,32 +3594,6 @@ function multiplyMatrix(m1, m2) {
     m1[4] * m2[1] + m1[5] * m2[3] + m2[5]
   ];
 }
-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);
@@ -2645,7 +3601,7 @@ function resolveBrushPaint(rCtx, flags, brushIdOrColor) {
   const obj = rCtx.objectTable.get(brushIdOrColor & 255);
   if (obj && obj.kind === "plus-brush") {
     if (obj.gradient) {
-      const g = createBrushGradient(rCtx, obj.gradient);
+      const g = createBrushGradient(rCtx.ctx, obj.gradient, plusWorldMatrix(rCtx));
       if (g) {
         return g;
       }
@@ -2680,18 +3636,14 @@ function getPageUnitMultiplier(pageUnit, pageScale) {
   }
   return unitToPixel * pageScale;
 }
-function applyPlusWorldTransform(rCtx) {
+function plusWorldMatrix(rCtx) {
   const wt = rCtx.worldTransform;
-  const m = getPageUnitMultiplier(rCtx.pageUnit, rCtx.pageScale);
-  const d = rCtx.dpiScale;
-  rCtx.ctx.setTransform(
-    wt[0] * m * d,
-    wt[1] * m * d,
-    wt[2] * m * d,
-    wt[3] * m * d,
-    wt[4] * m * d,
-    wt[5] * m * d
-  );
+  const k = getPageUnitMultiplier(rCtx.pageUnit, rCtx.pageScale) * rCtx.dpiScale;
+  return [wt[0] * k, wt[1] * k, wt[2] * k, wt[3] * k, wt[4] * k, wt[5] * k];
+}
+function applyPlusWorldTransform(rCtx) {
+  const m = plusWorldMatrix(rCtx);
+  rCtx.ctx.setTransform(m[0], m[1], m[2], m[3], m[4], m[5]);
 }
 function pushState(rCtx, stackId) {
   rCtx.saveStack.push({
@@ -3214,6 +4166,7 @@ var BRUSH_DATA_PATH = 1;
 var BRUSH_DATA_TRANSFORM = 2;
 var BRUSH_DATA_PRESET_COLORS = 4;
 var BRUSH_DATA_BLEND_FACTORS_H = 8;
+var BRUSH_DATA_FOCUS_SCALES = 64;
 var MAX_GRADIENT_ELEMENTS = 4096;
 function looksLikeGraphicsVersion(v) {
   return v >>> 12 === 900097;
@@ -3234,8 +4187,22 @@ function applyMatrix(m, x, y) {
 function clamp01(v) {
   return Number.isFinite(v) ? Math.min(1, Math.max(0, v)) : 0;
 }
+function readWrapMode(raw) {
+  switch (raw) {
+    case 0:
+      return "tile";
+    case 1:
+      return "tile-flip-x";
+    case 2:
+      return "tile-flip-y";
+    case 3:
+      return "tile-flip-xy";
+    default:
+      return "clamp";
+  }
+}
 function normaliseStops(stops) {
-  return stops.map((s) => ({ offset: clamp01(s.offset), color: s.color })).sort((a, b) => a.offset - b.offset);
+  return stops.map((s) => ({ ...s, offset: clamp01(s.offset) })).sort((a, b) => a.offset - b.offset);
 }
 function readPresetColors(view, off, end) {
   if (off + 4 > end) {
@@ -3253,9 +4220,11 @@ function readPresetColors(view, off, end) {
   }
   const stops = [];
   for (let i = 0; i < count; i++) {
+    const argb = view.getUint32(colOff + i * 4, true);
     stops.push({
       offset: view.getFloat32(posOff + i * 4, true),
-      color: argbToRgba(view.getUint32(colOff + i * 4, true))
+      color: argbToRgba(argb),
+      argb
     });
   }
   return { stops, next };
@@ -3288,6 +4257,7 @@ function parseLinearGradient(view, b, end) {
     return null;
   }
   const flags = view.getUint32(b, true);
+  const wrapMode = readWrapMode(view.getUint32(b + 4, true));
   const rx = view.getFloat32(b + 8, true);
   const ry = view.getFloat32(b + 12, true);
   const rw = view.getFloat32(b + 16, true);
@@ -3301,8 +4271,8 @@ function parseLinearGradient(view, b, end) {
     o += 24;
   }
   let stops = [
-    { offset: 0, color: argbToRgba(startArgb) },
-    { offset: 1, color: argbToRgba(endArgb) }
+    { offset: 0, color: argbToRgba(startArgb), argb: startArgb },
+    { offset: 1, color: argbToRgba(endArgb), argb: endArgb }
   ];
   if (flags & BRUSH_DATA_PRESET_COLORS) {
     const preset = readPresetColors(view, o, end);
@@ -3314,7 +4284,8 @@ function parseLinearGradient(view, b, end) {
     if (blend) {
       stops = blend.entries.map((e) => ({
         offset: e.pos,
-        color: lerpArgbToRgba(startArgb, endArgb, e.factor)
+        color: lerpArgbToRgba(startArgb, endArgb, e.factor),
+        argb: lerpArgb2(startArgb, endArgb, e.factor)
       }));
     }
   }
@@ -3336,7 +4307,10 @@ function parseLinearGradient(view, b, end) {
       y1: p1.y,
       x2: p2.x,
       y2: p2.y,
-      stops: normaliseStops(stops)
+      stops: normaliseStops(stops),
+      wrapMode,
+      rect: { x: rx, y: ry, w: rw, h: rh },
+      transform
     }
   };
 }
@@ -3345,6 +4319,7 @@ function parsePathGradient(view, b, end) {
     return null;
   }
   const flags = view.getUint32(b, true);
+  const wrapMode = readWrapMode(view.getUint32(b + 4, true));
   const centerArgb = view.getUint32(b + 8, true);
   let cx = view.getFloat32(b + 12, true);
   let cy = view.getFloat32(b + 16, true);
@@ -3359,6 +4334,8 @@ function parsePathGradient(view, b, end) {
     o += 4;
   }
   let boundaryPts = [];
+  let boundaryArgb = [];
+  const surroundAt = (k) => surround.length > 0 ? surround[Math.min(k, surround.length - 1)] : centerArgb;
   if (flags & BRUSH_DATA_PATH) {
     if (o + 4 <= end) {
       const pathSize = view.getInt32(o, true);
@@ -3366,7 +4343,9 @@ function parsePathGradient(view, b, end) {
       if (pathSize > 0 && o + pathSize <= end) {
         const path = parseEmfPlusPath(view, o, pathSize);
         if (path) {
-          boundaryPts = path.points;
+          const flat = flattenFirstFigure(path.points, path.types, surroundAt);
+          boundaryPts = flat.points;
+          boundaryArgb = flat.argb;
         }
         o += pathSize;
       }
@@ -3380,6 +4359,7 @@ function parsePathGradient(view, b, end) {
           x: view.getFloat32(o + i * 8, true),
           y: view.getFloat32(o + i * 8 + 4, true)
         });
+        boundaryArgb.push(surroundAt(i));
       }
       o += ptCount * 8;
     }
@@ -3389,31 +4369,50 @@ function parsePathGradient(view, b, 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 center = { x: cx, y: cy };
+  const m = transform;
+  const worldBoundary = m ? boundaryPts.map((p) => applyMatrix(m, p.x, p.y)) : boundaryPts;
+  if (m) {
+    ({ x: cx, y: cy } = applyMatrix(m, cx, cy));
   }
   const surroundArgb = surround.length > 0 ? surround[0] : centerArgb;
   let stops = [
-    { offset: 0, color: argbToRgba(centerArgb) },
-    { offset: 1, color: argbToRgba(surroundArgb) }
+    { offset: 0, color: argbToRgba(centerArgb), argb: centerArgb },
+    { offset: 1, color: argbToRgba(surroundArgb), argb: surroundArgb }
   ];
+  let blend = null;
+  let preset = null;
   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 }));
+    const presetData = readPresetColors(view, o, end);
+    if (presetData) {
+      stops = presetData.stops.map((s) => ({ ...s, offset: 1 - s.offset }));
+      preset = {
+        positions: presetData.stops.map((s) => s.offset),
+        argb: presetData.stops.map((s) => s.argb ?? 0)
+      };
+      o = presetData.next;
     }
   } else if (flags & BRUSH_DATA_BLEND_FACTORS_H) {
-    const blend = readBlendFactors(view, o, end);
-    if (blend) {
-      stops = blend.entries.map((e) => ({
+    const blendData = readBlendFactors(view, o, end);
+    if (blendData) {
+      stops = blendData.entries.map((e) => ({
         offset: 1 - e.pos,
-        color: lerpArgbToRgba(surroundArgb, centerArgb, e.factor)
+        color: lerpArgbToRgba(surroundArgb, centerArgb, e.factor),
+        argb: lerpArgb2(surroundArgb, centerArgb, e.factor)
       }));
+      blend = {
+        positions: blendData.entries.map((e) => e.pos),
+        factors: blendData.entries.map((e) => e.factor)
+      };
+      o = blendData.next;
     }
   }
+  let focus = null;
+  if (flags & BRUSH_DATA_FOCUS_SCALES && o + 12 <= end && view.getUint32(o, true) === 2) {
+    focus = { x: view.getFloat32(o + 4, true), y: view.getFloat32(o + 8, true) };
+  }
   let r = 0;
-  for (const p of boundaryPts) {
+  for (const p of worldBoundary) {
     const d = Math.hypot(p.x - cx, p.y - cy);
     if (d > r) {
       r = d;
@@ -3423,14 +4422,85 @@ function parsePathGradient(view, b, end) {
     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)`
+    `parseEmfPlusBrushObject: path gradient centre=(${cx.toFixed(1)},${cy.toFixed(1)}), ${boundaryPts.length} boundary point(s)`
   );
   return {
     kind: "plus-brush",
     color: argbToRgba(centerArgb),
-    gradient: { type: "radial", cx, cy, r, stops: normaliseStops(stops) }
+    gradient: {
+      type: "radial",
+      cx,
+      cy,
+      r,
+      stops: normaliseStops(stops),
+      wrapMode,
+      shape: {
+        center,
+        centerArgb,
+        boundary: boundaryPts,
+        boundaryArgb,
+        blend,
+        preset,
+        focus,
+        transform
+      }
+    }
   };
 }
+function lerpArgb2(a, b, t) {
+  const tc = Math.min(1, Math.max(0, t));
+  let out = 0;
+  for (let shift = 24; shift >= 0; shift -= 8) {
+    const ca = a >>> shift & 255;
+    const cb = b >>> shift & 255;
+    out = out * 256 + Math.round(ca + (cb - ca) * tc);
+  }
+  return out >>> 0;
+}
+var BEZIER_STEPS = 24;
+function flattenFirstFigure(points, types, colorAt) {
+  const outPts = [];
+  const outArgb = [];
+  for (let k = 0; k < points.length; k++) {
+    const kind = types[k] & 7;
+    if (k > 0 && kind === 0) {
+      break;
+    }
+    if (kind === 3 && k > 0 && k + 2 < points.length) {
+      const p0 = points[k - 1];
+      const p1 = points[k];
+      const p2 = points[k + 1];
+      const p3 = points[k + 2];
+      const c0 = colorAt(k - 1);
+      const c3 = colorAt(k + 2);
+      for (let i = 1; i <= BEZIER_STEPS; i++) {
+        const t = i / BEZIER_STEPS;
+        const u = 1 - t;
+        outPts.push({
+          x: u * u * u * p0.x + 3 * u * u * t * p1.x + 3 * u * t * t * p2.x + t * t * t * p3.x,
+          y: u * u * u * p0.y + 3 * u * u * t * p1.y + 3 * u * t * t * p2.y + t * t * t * p3.y
+        });
+        outArgb.push(lerpArgb2(c0, c3, t));
+      }
+      k += 2;
+      if (types[k] & 128) {
+        break;
+      }
+      continue;
+    }
+    outPts.push(points[k]);
+    outArgb.push(colorAt(k));
+    if (types[k] & 128) {
+      break;
+    }
+  }
+  const n = outPts.length;
+  if (n > 1 && outPts[0].x === outPts[n - 1].x && outPts[0].y === outPts[n - 1].y) {
+    outPts.pop();
+    outArgb.pop();
+  }
+  return { points: outPts, argb: outArgb };
+}
 function parseEmfPlusBrushObject(view, dataOff, recDataSize) {
   if (recDataSize < 8) {
     return null;
@@ -4451,7 +5521,7 @@ function replayEmfRecords(view, ctx, bounds, canvasW, canvasH, dpiScale = 1, rep
       );
       break;
     }
-    if (recType === EMR_SETBRUSHORGEX || recType === EMR_SETMETARGN || recType === EMR_SETICMMODE || recType === EMR_SETLAYOUT || recType === EMR_HEADER) {
+    if (recType === EMR_SETMETARGN || recType === EMR_SETICMMODE || recType === EMR_SETLAYOUT || recType === EMR_HEADER) {
       offset += recSize;
       continue;
     }
@@ -4846,8 +5916,8 @@ function replayWmfRecords(view, ctx, header, canvasW, canvasH, replayOptions = {
       case META_CREATEFONTINDIRECT:
         if (recSize >= 24) {
           let family = "";
-          for (let i = 0; i < 32 && dataOff + 14 + i < offset + recSize; i++) {
-            const ch = view.getUint8(dataOff + 14 + i);
+          for (let i = 0; i < 32 && dataOff + 18 + i < offset + recSize; i++) {
+            const ch = view.getUint8(dataOff + 18 + i);
             if (ch === 0) {
               break;
             }
@@ -4856,12 +5926,15 @@ function replayWmfRecords(view, ctx, header, canvasW, canvasH, replayOptions = {
           const slot = allocObjectSlot();
           objectTable.set(slot, {
             kind: "font",
-            height: Math.abs(view.getInt16(dataOff, true)),
+            // Sign kept (not Math.abs'd): resolveFontPixelHeight() needs it
+            // to distinguish GDI's cell-height vs character-height convention.
+            height: 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"
+            family: family || "sans-serif",
+            escapementTenthDeg: view.getInt16(dataOff + 4, true)
           });
         }
         break;
@@ -4886,6 +5959,7 @@ function replayWmfRecords(view, ctx, header, canvasW, canvasH, replayOptions = {
                 state.fontUnderline = obj.underline;
                 state.fontStrikeOut = obj.strikeOut;
                 state.fontFamily = obj.family;
+                state.fontEscapementTenthDeg = obj.escapementTenthDeg ?? 0;
                 break;
             }
           }