emf-converter 3.0.2 → 3.2.0

package/dist/index.js

@@ -52,6 +52,469 @@ function invertCssColor(color) {
   return color;
 }
 
+// src/emf-dib-rle-decoder.ts
+function decodeRleBitmap(view, bitsOffset, bitsSize, width, height, _topDown, isRle4, colorTable, out, setPixel) {
+  let x = 0;
+  let y = height - 1;
+  let off = bitsOffset;
+  const endOff = bitsOffset + bitsSize;
+  while (off + 1 < endOff && y >= 0) {
+    const first = view.getUint8(off);
+    const second = view.getUint8(off + 1);
+    off += 2;
+    if (first === 0) {
+      if (second === 0) {
+        x = 0;
+        y--;
+      } else if (second === 1) {
+        break;
+      } else if (second === 2) {
+        if (off + 1 >= endOff) {
+          break;
+        }
+        x += view.getUint8(off);
+        y -= view.getUint8(off + 1);
+        off += 2;
+      } else {
+        const count = second;
+        if (!isRle4) {
+          for (let i = 0; i < count && off < endOff && x < width; i++) {
+            const idx = view.getUint8(off++);
+            if (idx < colorTable.length) {
+              setPixel(
+                x,
+                height - 1 - y,
+                colorTable[idx][0],
+                colorTable[idx][1],
+                colorTable[idx][2],
+                255
+              );
+            }
+            x++;
+          }
+          if (count & 1) {
+            off++;
+          }
+        } else {
+          const bytes = Math.ceil(count / 2);
+          let pi = 0;
+          for (let i = 0; i < bytes && off < endOff; i++) {
+            const byte = view.getUint8(off++);
+            for (let nibble = 0; nibble < 2 && pi < count; nibble++) {
+              const idx = nibble === 0 ? byte >> 4 & 15 : byte & 15;
+              if (idx < colorTable.length && x < width) {
+                setPixel(
+                  x,
+                  height - 1 - y,
+                  colorTable[idx][0],
+                  colorTable[idx][1],
+                  colorTable[idx][2],
+                  255
+                );
+              }
+              x++;
+              pi++;
+            }
+          }
+          if (bytes & 1) {
+            off++;
+          }
+        }
+      }
+    } else if (!isRle4) {
+      const idx = second;
+      const c = idx < colorTable.length ? colorTable[idx] : [0, 0, 0];
+      for (let i = 0; i < first && x < width; i++) {
+        setPixel(x, height - 1 - y, c[0], c[1], c[2], 255);
+        x++;
+      }
+    } else {
+      const hi = second >> 4 & 15;
+      const lo = second & 15;
+      for (let i = 0; i < first && x < width; i++) {
+        const idx = (i & 1) === 0 ? hi : lo;
+        if (idx < colorTable.length) {
+          setPixel(
+            x,
+            height - 1 - y,
+            colorTable[idx][0],
+            colorTable[idx][1],
+            colorTable[idx][2],
+            255
+          );
+        }
+        x++;
+      }
+    }
+  }
+  return createImageDataCompat(
+    new Uint8ClampedArray(out.buffer, out.byteOffset, out.byteLength),
+    width,
+    height
+  );
+}
+
+// src/emf-dib-uncompressed.ts
+function countTrailingZeros(v) {
+  if (v === 0) {
+    return 0;
+  }
+  let c = 0;
+  let val = v;
+  while ((val & 1) === 0) {
+    val >>>= 1;
+    c++;
+  }
+  return c;
+}
+var BI_BITFIELDS = 3;
+function parseBitfieldMasks(view, bmiOffset, headerSize, compression, bitCount) {
+  let rMask = 0, gMask = 0, bMask = 0;
+  let rShift = 0, gShift = 0, bShift = 0;
+  let rMax = 1, gMax = 1, bMax = 1;
+  if (compression === BI_BITFIELDS) {
+    const bfOff = bmiOffset + headerSize;
+    if (bfOff + 12 > view.byteLength) {
+      return null;
+    }
+    rMask = view.getUint32(bfOff, true);
+    gMask = view.getUint32(bfOff + 4, true);
+    bMask = view.getUint32(bfOff + 8, true);
+    rShift = countTrailingZeros(rMask);
+    gShift = countTrailingZeros(gMask);
+    bShift = countTrailingZeros(bMask);
+    rMax = rMask >>> rShift || 1;
+    gMax = gMask >>> gShift || 1;
+    bMax = bMask >>> bShift || 1;
+  } else if (bitCount === 16) {
+    rMask = 31744;
+    gMask = 992;
+    bMask = 31;
+    rShift = 10;
+    gShift = 5;
+    bShift = 0;
+    rMax = 31;
+    gMax = 31;
+    bMax = 31;
+  }
+  return { rMask, gMask, bMask, rShift, gShift, bShift, rMax, gMax, bMax };
+}
+function decodeUncompressedRows(view, bitsOffset, width, height, topDown, bitCount, colorTable, masks, out) {
+  const rowStride = Math.floor((bitCount * width + 31) / 32) * 4;
+  const { rMask, gMask, bMask, rShift, gShift, bShift, rMax, gMax, bMax } = masks;
+  for (let y = 0; y < height; y++) {
+    const srcY = topDown ? y : height - 1 - y;
+    const rowStart = bitsOffset + srcY * rowStride;
+    if (rowStart + rowStride > view.byteLength) {
+      continue;
+    }
+    for (let x = 0; x < width; x++) {
+      const dstPx = (y * width + x) * 4;
+      if (bitCount === 1) {
+        const byteIdx = rowStart + (x >> 3);
+        const bit = view.getUint8(byteIdx) >> 7 - (x & 7) & 1;
+        if (bit < colorTable.length) {
+          out[dstPx] = colorTable[bit][0];
+          out[dstPx + 1] = colorTable[bit][1];
+          out[dstPx + 2] = colorTable[bit][2];
+        }
+        out[dstPx + 3] = 255;
+      } else if (bitCount === 4) {
+        const byteIdx = rowStart + (x >> 1);
+        const nibble = (x & 1) === 0 ? view.getUint8(byteIdx) >> 4 & 15 : view.getUint8(byteIdx) & 15;
+        if (nibble < colorTable.length) {
+          out[dstPx] = colorTable[nibble][0];
+          out[dstPx + 1] = colorTable[nibble][1];
+          out[dstPx + 2] = colorTable[nibble][2];
+        }
+        out[dstPx + 3] = 255;
+      } else if (bitCount === 8) {
+        const idx = view.getUint8(rowStart + x);
+        if (idx < colorTable.length) {
+          out[dstPx] = colorTable[idx][0];
+          out[dstPx + 1] = colorTable[idx][1];
+          out[dstPx + 2] = colorTable[idx][2];
+        }
+        out[dstPx + 3] = 255;
+      } else if (bitCount === 16) {
+        const val = view.getUint16(rowStart + x * 2, true);
+        out[dstPx] = Math.round(((val & rMask) >>> rShift) * 255 / rMax);
+        out[dstPx + 1] = Math.round(((val & gMask) >>> gShift) * 255 / gMax);
+        out[dstPx + 2] = Math.round(((val & bMask) >>> bShift) * 255 / bMax);
+        out[dstPx + 3] = 255;
+      } else if (bitCount === 24) {
+        const srcPx = rowStart + x * 3;
+        out[dstPx] = view.getUint8(srcPx + 2);
+        out[dstPx + 1] = view.getUint8(srcPx + 1);
+        out[dstPx + 2] = view.getUint8(srcPx);
+        out[dstPx + 3] = 255;
+      } else {
+        const srcPx = rowStart + x * 4;
+        const bb = view.getUint8(srcPx);
+        const gg = view.getUint8(srcPx + 1);
+        const rr = view.getUint8(srcPx + 2);
+        const aa = view.getUint8(srcPx + 3);
+        out[dstPx] = rr;
+        out[dstPx + 1] = gg;
+        out[dstPx + 2] = bb;
+        out[dstPx + 3] = aa === 0 ? 255 : aa;
+      }
+    }
+  }
+}
+
+// src/emf-dib-decoder.ts
+function decodeDibToImageData(view, bmiOffset, bitsOffset, bitsSize) {
+  if (bmiOffset < 0 || bitsOffset < 0 || bmiOffset + 40 > view.byteLength || bitsOffset + bitsSize > view.byteLength) {
+    return null;
+  }
+  const headerSize = view.getUint32(bmiOffset, true);
+  if (headerSize < 40 || bmiOffset + headerSize > view.byteLength) {
+    return null;
+  }
+  const width = view.getInt32(bmiOffset + 4, true);
+  const heightRaw = view.getInt32(bmiOffset + 8, true);
+  const planes = view.getUint16(bmiOffset + 12, true);
+  const bitCount = view.getUint16(bmiOffset + 14, true);
+  const compression = view.getUint32(bmiOffset + 16, true);
+  if (planes !== 1 || width <= 0 || heightRaw === 0) {
+    return null;
+  }
+  if (width > 8192 || Math.abs(heightRaw) > 8192) {
+    return null;
+  }
+  const BI_RGB = 0;
+  const BI_RLE8 = 1;
+  const BI_RLE4 = 2;
+  const BI_BITFIELDS2 = 3;
+  if (bitCount !== 1 && bitCount !== 4 && bitCount !== 8 && bitCount !== 16 && bitCount !== 24 && bitCount !== 32) {
+    return null;
+  }
+  if (compression === BI_RLE8 && bitCount !== 8) {
+    return null;
+  }
+  if (compression === BI_RLE4 && bitCount !== 4) {
+    return null;
+  }
+  if (compression === BI_BITFIELDS2 && bitCount !== 16 && bitCount !== 32) {
+    return null;
+  }
+  if (compression !== BI_RGB && compression !== BI_RLE8 && compression !== BI_RLE4 && compression !== BI_BITFIELDS2) {
+    return null;
+  }
+  const height = Math.abs(heightRaw);
+  const topDown = heightRaw < 0;
+  const colorTable = [];
+  if (bitCount <= 8) {
+    const maxColors = 1 << bitCount;
+    const colorsUsed = view.getUint32(bmiOffset + 32, true) || maxColors;
+    const numColors = Math.min(colorsUsed, maxColors);
+    const ctOffset = bmiOffset + headerSize;
+    if (ctOffset + numColors * 4 > view.byteLength) {
+      return null;
+    }
+    for (let i = 0; i < numColors; i++) {
+      const b = view.getUint8(ctOffset + i * 4);
+      const g = view.getUint8(ctOffset + i * 4 + 1);
+      const r = view.getUint8(ctOffset + i * 4 + 2);
+      colorTable.push([r, g, b]);
+    }
+  }
+  const masks = parseBitfieldMasks(view, bmiOffset, headerSize, compression, bitCount);
+  if (!masks) {
+    return null;
+  }
+  const out = new Uint8ClampedArray(width * height * 4);
+  if (compression === BI_RLE8 || compression === BI_RLE4) {
+    const setPixel = (x, y, r, g, b, a) => {
+      const dstPx = (y * width + x) * 4;
+      out[dstPx] = r;
+      out[dstPx + 1] = g;
+      out[dstPx + 2] = b;
+      out[dstPx + 3] = a;
+    };
+    return decodeRleBitmap(
+      view,
+      bitsOffset,
+      bitsSize,
+      width,
+      height,
+      topDown,
+      compression === BI_RLE4,
+      colorTable,
+      out,
+      setPixel
+    );
+  }
+  decodeUncompressedRows(
+    view,
+    bitsOffset,
+    width,
+    height,
+    topDown,
+    bitCount,
+    colorTable,
+    masks,
+    out
+  );
+  return createImageDataCompat(out, width, height);
+}
+
+// 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-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;
@@ -66,6 +529,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;
@@ -193,6 +659,7 @@ var EMFPLUS_OBJECTTYPE_STRINGFORMAT = 7;
 var EMFPLUS_OBJECTTYPE_REGION = 8;
 var EMFPLUS_BRUSHTYPE_SOLID = 0;
 var EMFPLUS_BRUSHTYPE_HATCHFILL = 1;
+var EMFPLUS_BRUSHTYPE_TEXTUREFILL = 2;
 var EMFPLUS_BRUSHTYPE_PATHGRADIENT = 3;
 var EMFPLUS_BRUSHTYPE_LINEARGRADIENT = 4;
 var META_EOF = 0;
@@ -443,7 +910,8 @@ function applyPen(ctx, state) {
 function applyBrush(ctx, state) {
   const paint = rop2Paint(state.rop2);
   ctx.globalCompositeOperation = paint.gco;
-  if (state.brushStyle === 1) {
+  const realized = realizeBrush(state);
+  if (realized.kind === "none") {
     ctx.fillStyle = "rgba(0,0,0,0)";
     return;
   }
@@ -470,7 +938,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 " : "";
@@ -622,6 +1090,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) {
@@ -741,854 +1231,1267 @@ function gmh(r, h) {
 function activateGdiMappingMode(r) {
   r.useMappingMode = true;
 }
-
-// src/emf-gdi-draw-shapes.ts
-function handleSetPixelV(rCtx, dataOff, recSize) {
-  const { ctx, view } = rCtx;
-  if (recSize >= 20) {
-    const x = view.getInt32(dataOff, true);
-    const y = view.getInt32(dataOff + 4, true);
-    const color = readColorRef(view, dataOff + 8);
-    ctx.fillStyle = color;
-    ctx.fillRect(gmx(rCtx, x), gmy(rCtx, y), 1, 1);
-  }
-  return true;
-}
-function handleMoveToEx(rCtx, dataOff, recSize) {
-  const { ctx, view, state, inPath } = rCtx;
-  if (recSize >= 16) {
-    state.curX = view.getInt32(dataOff, true);
-    state.curY = view.getInt32(dataOff + 4, true);
-    if (inPath) {
-      ctx.moveTo(gmx(rCtx, state.curX), gmy(rCtx, state.curY));
-    }
-  }
-  return true;
-}
-function handleLineTo(rCtx, dataOff, recSize) {
-  const { ctx, view, state, inPath } = rCtx;
-  if (recSize >= 16) {
-    const lx = view.getInt32(dataOff, true);
-    const ly = view.getInt32(dataOff + 4, true);
-    if (inPath) {
-      ctx.lineTo(gmx(rCtx, lx), gmy(rCtx, ly));
-    } else {
-      applyPen(ctx, state);
-      ctx.beginPath();
-      ctx.moveTo(gmx(rCtx, state.curX), gmy(rCtx, state.curY));
-      ctx.lineTo(gmx(rCtx, lx), gmy(rCtx, ly));
-      ctx.stroke();
-    }
-    state.curX = lx;
-    state.curY = ly;
-  }
-  return true;
-}
-function handleRectangle(rCtx, dataOff, recSize) {
-  const { ctx, view, state, inPath } = rCtx;
-  if (recSize >= 24) {
-    const l = view.getInt32(dataOff, true);
-    const t = view.getInt32(dataOff + 4, true);
-    const r = view.getInt32(dataOff + 8, true);
-    const b = view.getInt32(dataOff + 12, true);
-    if (inPath) {
-      ctx.rect(gmx(rCtx, l), gmy(rCtx, t), gmw(rCtx, r - l), gmh(rCtx, b - t));
-    } else {
-      applyBrush(ctx, state);
-      ctx.fillRect(gmx(rCtx, l), gmy(rCtx, t), gmw(rCtx, r - l), gmh(rCtx, b - t));
-      applyPen(ctx, state);
-      ctx.strokeRect(gmx(rCtx, l), gmy(rCtx, t), gmw(rCtx, r - l), gmh(rCtx, b - t));
-    }
-  }
-  return true;
-}
-function handleRoundRect(rCtx, dataOff, recSize) {
-  const { ctx, view, state, inPath } = rCtx;
-  if (recSize >= 32) {
-    const l = view.getInt32(dataOff, true);
-    const t = view.getInt32(dataOff + 4, true);
-    const r = view.getInt32(dataOff + 8, true);
-    const b = view.getInt32(dataOff + 12, true);
-    const rw = Math.abs(gmw(rCtx, view.getInt32(dataOff + 16, true))) / 2;
-    const rh = Math.abs(gmh(rCtx, view.getInt32(dataOff + 20, true))) / 2;
-    const x1 = gmx(rCtx, l);
-    const y1 = gmy(rCtx, t);
-    const w = gmw(rCtx, r - l);
-    const h = gmh(rCtx, b - t);
-    const drawRoundRect = () => {
-      const radius = Math.min(rw, rh, w / 2, h / 2);
-      ctx.moveTo(x1 + radius, y1);
-      ctx.lineTo(x1 + w - radius, y1);
-      ctx.arcTo(x1 + w, y1, x1 + w, y1 + radius, radius);
-      ctx.lineTo(x1 + w, y1 + h - radius);
-      ctx.arcTo(x1 + w, y1 + h, x1 + w - radius, y1 + h, radius);
-      ctx.lineTo(x1 + radius, y1 + h);
-      ctx.arcTo(x1, y1 + h, x1, y1 + h - radius, radius);
-      ctx.lineTo(x1, y1 + radius);
-      ctx.arcTo(x1, y1, x1 + radius, y1, radius);
-      ctx.closePath();
-    };
-    if (inPath) {
-      drawRoundRect();
-    } else {
-      ctx.beginPath();
-      drawRoundRect();
-      applyBrush(ctx, state);
-      ctx.fill();
-      applyPen(ctx, state);
-      ctx.stroke();
-    }
-  }
-  return true;
-}
-function handleEllipse(rCtx, dataOff, recSize) {
-  const { ctx, view, state, inPath } = rCtx;
-  if (recSize >= 24) {
-    const l = view.getInt32(dataOff, true);
-    const t = view.getInt32(dataOff + 4, true);
-    const r = view.getInt32(dataOff + 8, true);
-    const b = view.getInt32(dataOff + 12, true);
-    const cx = gmx(rCtx, (l + r) / 2);
-    const cy = gmy(rCtx, (t + b) / 2);
-    const rx = Math.abs(gmw(rCtx, r - l)) / 2;
-    const ry = Math.abs(gmh(rCtx, b - t)) / 2;
-    if (inPath) {
-      ctx.ellipse(cx, cy, rx, ry, 0, 0, Math.PI * 2);
-    } else {
-      ctx.beginPath();
-      ctx.ellipse(cx, cy, rx, ry, 0, 0, Math.PI * 2);
-      applyBrush(ctx, state);
-      ctx.fill();
-      applyPen(ctx, state);
-      ctx.stroke();
-    }
-  }
-  return true;
-}
-function handleArcFamily(rCtx, recType, dataOff, recSize) {
-  const { ctx, view, state, inPath } = rCtx;
-  if (recSize >= 40) {
-    const l = view.getInt32(dataOff, true);
-    const t = view.getInt32(dataOff + 4, true);
-    const r = view.getInt32(dataOff + 8, true);
-    const b = view.getInt32(dataOff + 12, true);
-    const startX = view.getInt32(dataOff + 16, true);
-    const startY = view.getInt32(dataOff + 20, true);
-    const endX = view.getInt32(dataOff + 24, true);
-    const endY = view.getInt32(dataOff + 28, true);
-    const cxA = (l + r) / 2;
-    const cyA = (t + b) / 2;
-    const rx = Math.abs(r - l) / 2;
-    const ry = Math.abs(b - t) / 2;
-    const startAngle = Math.atan2((startY - cyA) / (ry || 1), (startX - cxA) / (rx || 1));
-    const endAngle = Math.atan2((endY - cyA) / (ry || 1), (endX - cxA) / (rx || 1));
-    const mcx = gmx(rCtx, cxA);
-    const mcy = gmy(rCtx, cyA);
-    const mrx = Math.abs(gmw(rCtx, rx));
-    const mry = Math.abs(gmh(rCtx, ry));
-    const isArcTo = recType === EMR_ARCTO;
-    const needsFill = recType === EMR_PIE || recType === EMR_CHORD;
-    if (!inPath) {
-      ctx.beginPath();
-    }
-    if (recType === EMR_PIE) {
-      ctx.moveTo(mcx, mcy);
-    }
-    if (isArcTo) {
-      ctx.lineTo(mcx + mrx * Math.cos(startAngle), mcy + mry * Math.sin(startAngle));
-    }
-    ctx.ellipse(mcx, mcy, mrx, mry, 0, startAngle, endAngle, false);
-    if (recType === EMR_PIE || recType === EMR_CHORD) {
-      ctx.closePath();
-    }
-    if (!inPath) {
-      if (needsFill) {
-        applyBrush(ctx, state);
-        ctx.fill();
-      }
-      applyPen(ctx, state);
-      ctx.stroke();
-    }
-    if (isArcTo) {
-      state.curX = endX;
-      state.curY = endY;
-    }
-  }
-  return true;
-}
-function handleEmfGdiShapeRecord(rCtx, recType, dataOff, recSize) {
-  switch (recType) {
-    case EMR_SETPIXELV:
-      return handleSetPixelV(rCtx, dataOff, recSize);
-    case EMR_MOVETOEX:
-      return handleMoveToEx(rCtx, dataOff, recSize);
-    case EMR_LINETO:
-      return handleLineTo(rCtx, dataOff, recSize);
-    case EMR_RECTANGLE:
-      return handleRectangle(rCtx, dataOff, recSize);
-    case EMR_ROUNDRECT:
-      return handleRoundRect(rCtx, dataOff, recSize);
-    case EMR_ELLIPSE:
-      return handleEllipse(rCtx, dataOff, recSize);
-    case EMR_ARC:
-    case EMR_ARCTO:
-    case EMR_CHORD:
-    case EMR_PIE:
-      return handleArcFamily(rCtx, recType, dataOff, recSize);
-    default:
-      return false;
-  }
-}
-
-// 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 hasWorldRotation(r) {
+  const wt = r.state.worldTransform;
+  return wt[1] !== 0 || wt[2] !== 0;
+}
+function gdiDeviceMatrix(r) {
+  const wt = r.state.worldTransform;
+  if (r.useMappingMode) {
+    const kx = (r.viewportExt.cx || 1) / (r.windowExt.cx || 1);
+    const ky = (r.viewportExt.cy || 1) / (r.windowExt.cy || 1);
+    return [
+      wt[0] * kx,
+      wt[1] * ky,
+      wt[2] * kx,
+      wt[3] * ky,
+      (wt[4] - r.windowOrg.x) * kx + r.viewportOrg.x,
+      (wt[5] - r.windowOrg.y) * ky + r.viewportOrg.y
+    ];
+  }
+  const sx = r.sx || 1;
+  const sy = r.sy || 1;
+  return [wt[0] * sx, wt[1] * sy, wt[2] * sx, wt[3] * sy, (wt[4] - r.bounds.left) * sx, (wt[5] - r.bounds.top) * sy];
+}
+function gmapPoint(r, x, y) {
+  const m = gdiDeviceMatrix(r);
+  return { x: m[0] * x + m[2] * y + m[4], y: m[1] * x + m[3] * y + m[5] };
+}
+function gdiEllipseParams(r, cx0, cy0, rx0, ry0) {
+  const m = gdiDeviceMatrix(r);
+  const center = gmapPoint(r, cx0, cy0);
+  const a11 = m[0] * rx0;
+  const a12 = m[2] * ry0;
+  const a21 = m[1] * rx0;
+  const a22 = m[3] * ry0;
+  const p = a11 * a11 + a12 * a12;
+  const q = a11 * a21 + a12 * a22;
+  const s = a21 * a21 + a22 * a22;
+  const mid = (p + s) / 2;
+  const spread = Math.sqrt(Math.max(0, ((p - s) / 2) ** 2 + q * q));
+  const lambda1 = Math.max(0, mid + spread);
+  const lambda2 = Math.max(0, mid - spread);
+  const rotation = 0.5 * Math.atan2(2 * q, p - s);
+  return {
+    cx: center.x,
+    cy: center.y,
+    rx: Math.sqrt(lambda1),
+    ry: Math.sqrt(lambda2),
+    rotation
   };
 }
-function translateClipRegion(region, dx, dy) {
-  if (!region) {
+
+// 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 region.map((s) => translateClipShape(s, dx, dy));
+  return { x: left, y: top, w: width, h: height };
 }
-function isComposable(shape) {
-  return shape.simple && shape.fillRule === "nonzero";
+
+// src/emf-rop2-exact.ts
+var ROP2_EXACT_INDEX = {
+  [R2_MASKPEN]: 160,
+  // P & D
+  [R2_MERGEPEN]: 250,
+  // P | D
+  [R2_XORPEN]: 90,
+  // P ^ D
+  [R2_NOTXORPEN]: 165,
+  // ~(P ^ D)
+  [R2_MASKPENNOT]: 80,
+  // P & ~D
+  [R2_MERGEPENNOT]: 245,
+  // P | ~D
+  [R2_MASKNOTPEN]: 10,
+  // ~P & D
+  [R2_MERGENOTPEN]: 175,
+  // ~P | D
+  [R2_NOTMASKPEN]: 95,
+  // ~(P & D)
+  [R2_NOTMERGEPEN]: 5
+  // ~(P | D)
+};
+function isExactRop2Bitwise(rop2) {
+  return rop2 in ROP2_EXACT_INDEX;
 }
-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 packRgb(r, g, b) {
+  return r << 16 | g << 8 | b;
 }
-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 };
+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 paintWithExactRop2(ctx, rop2, color, draw) {
+  const index = ROP2_EXACT_INDEX[rop2];
+  if (index === void 0) {
+    return false;
+  }
+  const size = surfaceSize(ctx);
+  if (!size) {
+    return false;
+  }
+  try {
+    const temp = createTempCanvas(size.w, size.h);
+    if (!temp) {
+      return false;
     }
-    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
-        };
+    temp.ctx.fillStyle = color;
+    temp.ctx.strokeStyle = color;
+    draw(temp.ctx);
+    const paint = canvasGetImageData(temp.ctx, 0, 0, size.w, size.h);
+    const dest = canvasGetImageData(ctx, 0, 0, size.w, size.h);
+    const pd = paint.data;
+    const dd = dest.data;
+    for (let i = 0; i < dd.length; i += 4) {
+      const coverage = pd[i + 3] / 255;
+      if (coverage <= 0) {
+        continue;
       }
-      return { region: current, exact: false };
-    }
-    case "xor": {
-      if (!current) {
-        if (isComposable(shape)) {
-          return { region: [invertClipShape(shape)], exact: true };
+      const p = packRgb(pd[i], pd[i + 1], pd[i + 2]);
+      const d = packRgb(dd[i], dd[i + 1], dd[i + 2]);
+      const combined = evalRop3(index, p, d, d);
+      const cr = combined >> 16 & 255;
+      const cg = combined >> 8 & 255;
+      const cb = combined & 255;
+      dd[i] = Math.round(dd[i] + (cr - dd[i]) * coverage);
+      dd[i + 1] = Math.round(dd[i + 1] + (cg - dd[i + 1]) * coverage);
+      dd[i + 2] = Math.round(dd[i + 2] + (cb - dd[i + 2]) * coverage);
+      dd[i + 3] = 255;
+    }
+    canvasPutImageData(ctx, dest, 0, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/emf-gdi-shape-paint.ts
+function surfaceSize2(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 fillCurrentPathWithGdiPattern(rCtx, fillRule) {
+  const { ctx, bounds, state } = rCtx;
+  const realized = realizeBrush(state);
+  if (realized.kind !== "tile") {
+    return false;
+  }
+  const size = surfaceSize2(ctx);
+  if (!size || typeof ctx.isPointInPath !== "function") {
+    return false;
+  }
+  const sx = rCtx.sx || 1;
+  const sy = rCtx.sy || 1;
+  try {
+    const img = canvasGetImageData(ctx, 0, 0, size.w, size.h);
+    const d = img.data;
+    for (let y = 0; y < size.h; y++) {
+      for (let x = 0; x < size.w; x++) {
+        if (!ctx.isPointInPath(x + 0.5, y + 0.5, fillRule)) {
+          continue;
         }
-        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 };
+        const lx = Math.floor(bounds.left + (x + 0.5) / sx);
+        const ly = Math.floor(bounds.top + (y + 0.5) / sy);
+        const c = sampleTile(realized, lx, ly, state.brushOrgX, state.brushOrgY);
+        const o = (y * size.w + x) * 4;
+        d[o] = c >>> 16 & 255;
+        d[o + 1] = c >>> 8 & 255;
+        d[o + 2] = c & 255;
+        d[o + 3] = 255;
       }
-      return { region: [shape], exact: false };
     }
+    canvasPutImageData(ctx, img, 0, 0);
+    return true;
+  } catch {
+    return 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);
+function fillShapeExactOrFast(rCtx, buildPath, fillRule = "nonzero") {
+  const { ctx, state } = rCtx;
+  if (state.brushStyle === 1) {
+    return;
   }
-  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 };
-      }
+  if (realizeBrush(state).kind === "tile") {
+    if (fillCurrentPathWithGdiPattern(rCtx, fillRule)) {
+      return;
     }
-  }
-  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");
+  } else {
+    const paint = rop2Paint(state.rop2);
+    if (!paint.exact && isExactRop2Bitwise(state.rop2)) {
+      const handled = paintWithExactRop2(ctx, state.rop2, state.brushColor, (scratch) => {
+        buildPath(scratch);
+        scratch.fill(fillRule);
+      });
+      if (handled) {
+        return;
       }
-      return { region: incoming, exact: false };
     }
   }
+  applyBrush(ctx, state);
+  ctx.fill(fillRule);
 }
-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 applyPenGeometry(ctx, state) {
+  ctx.lineWidth = Math.max(state.penWidth, 1);
+  switch (state.penStyle) {
+    case 1:
+      ctx.setLineDash([8, 4]);
+      break;
+    case 2:
+      ctx.setLineDash([2, 2]);
+      break;
+    case 3:
+      ctx.setLineDash([8, 4, 2, 4]);
+      break;
+    case 4:
+      ctx.setLineDash([8, 4, 2, 4, 2, 4]);
+      break;
+    default:
+      ctx.setLineDash([]);
+      break;
+  }
+}
+function strokeShapeExactOrFast(rCtx, buildPath) {
+  const { ctx, state } = rCtx;
+  const paint = rop2Paint(state.rop2);
+  if (!paint.exact && isExactRop2Bitwise(state.rop2) && state.penStyle !== 5) {
+    const handled = paintWithExactRop2(ctx, state.rop2, state.penColor, (scratch) => {
+      applyPenGeometry(scratch, state);
+      buildPath(scratch);
+      scratch.stroke();
+    });
+    if (handled) {
+      return;
     }
   }
+  applyPen(ctx, state);
+  ctx.stroke();
 }
-function applyClipShapes(ctx, shapes) {
-  for (const s of shapes) {
-    ctx.beginPath();
-    replayClipCmds(ctx, s.cmds);
-    try {
-      ctx.clip(s.fillRule);
-    } catch {
+
+// src/emf-gdi-draw-shapes.ts
+function needsPathBasedRectangle(rCtx) {
+  const paint = rop2Paint(rCtx.state.rop2);
+  const ropExact = !paint.exact && isExactRop2Bitwise(rCtx.state.rop2);
+  return ropExact || realizeBrush(rCtx.state).kind === "tile";
+}
+function handleSetPixelV(rCtx, dataOff, recSize) {
+  const { ctx, view } = rCtx;
+  if (recSize >= 20) {
+    const x = view.getInt32(dataOff, true);
+    const y = view.getInt32(dataOff + 4, true);
+    const color = readColorRef(view, dataOff + 8);
+    const p = hasWorldRotation(rCtx) ? gmapPoint(rCtx, x, y) : { x: gmx(rCtx, x), y: gmy(rCtx, y) };
+    ctx.fillStyle = color;
+    ctx.fillRect(p.x, p.y, 1, 1);
+  }
+  return true;
+}
+function handleMoveToEx(rCtx, dataOff, recSize) {
+  const { ctx, view, state, inPath } = rCtx;
+  if (recSize >= 16) {
+    state.curX = view.getInt32(dataOff, true);
+    state.curY = view.getInt32(dataOff + 4, true);
+    if (inPath) {
+      const p = hasWorldRotation(rCtx) ? gmapPoint(rCtx, state.curX, state.curY) : { x: gmx(rCtx, state.curX), y: gmy(rCtx, state.curY) };
+      ctx.moveTo(p.x, p.y);
     }
   }
+  return true;
 }
-function reapplyClipRegion(holder, region, identityTransform = false) {
-  const { ctx } = holder;
-  while (holder.clipSaveDepth > 0) {
-    ctx.restore();
-    holder.clipSaveDepth--;
+function handleLineTo(rCtx, dataOff, recSize) {
+  const { ctx, view, state, inPath } = rCtx;
+  if (recSize >= 16) {
+    const lx = view.getInt32(dataOff, true);
+    const ly = view.getInt32(dataOff + 4, true);
+    const rotated = hasWorldRotation(rCtx);
+    const to = rotated ? gmapPoint(rCtx, lx, ly) : { x: gmx(rCtx, lx), y: gmy(rCtx, ly) };
+    if (inPath) {
+      ctx.lineTo(to.x, to.y);
+    } else {
+      const from = rotated ? gmapPoint(rCtx, state.curX, state.curY) : { x: gmx(rCtx, state.curX), y: gmy(rCtx, state.curY) };
+      const build = (c) => {
+        c.beginPath();
+        c.moveTo(from.x, from.y);
+        c.lineTo(to.x, to.y);
+      };
+      build(ctx);
+      strokeShapeExactOrFast(rCtx, build);
+    }
+    state.curX = lx;
+    state.curY = ly;
   }
-  if (region) {
-    ctx.save();
-    holder.clipSaveDepth = 1;
-    if (identityTransform) {
-      ctx.setTransform(1, 0, 0, 1, 0, 0);
+  return true;
+}
+function handleRectangle(rCtx, dataOff, recSize) {
+  const { ctx, view, state, inPath } = rCtx;
+  if (recSize >= 24) {
+    const l = view.getInt32(dataOff, true);
+    const t = view.getInt32(dataOff + 4, true);
+    const r = view.getInt32(dataOff + 8, true);
+    const b = view.getInt32(dataOff + 12, true);
+    const rotated = hasWorldRotation(rCtx);
+    if (rotated) {
+      const p1 = gmapPoint(rCtx, l, t);
+      const p2 = gmapPoint(rCtx, r, t);
+      const p3 = gmapPoint(rCtx, r, b);
+      const p4 = gmapPoint(rCtx, l, b);
+      const build = (c) => {
+        c.beginPath();
+        c.moveTo(p1.x, p1.y);
+        c.lineTo(p2.x, p2.y);
+        c.lineTo(p3.x, p3.y);
+        c.lineTo(p4.x, p4.y);
+        c.closePath();
+      };
+      if (inPath) {
+        build(ctx);
+      } else {
+        build(ctx);
+        fillShapeExactOrFast(rCtx, build);
+        strokeShapeExactOrFast(rCtx, build);
+      }
+      return true;
+    }
+    if (inPath) {
+      ctx.rect(gmx(rCtx, l), gmy(rCtx, t), gmw(rCtx, r - l), gmh(rCtx, b - t));
+    } else {
+      const x = gmx(rCtx, l);
+      const y = gmy(rCtx, t);
+      const w = gmw(rCtx, r - l);
+      const h = gmh(rCtx, b - t);
+      if (needsPathBasedRectangle(rCtx)) {
+        const build = (c) => {
+          c.beginPath();
+          c.rect(x, y, w, h);
+        };
+        build(ctx);
+        fillShapeExactOrFast(rCtx, build);
+        strokeShapeExactOrFast(rCtx, build);
+      } else {
+        applyBrush(ctx, state);
+        ctx.fillRect(x, y, w, h);
+        applyPen(ctx, state);
+        ctx.strokeRect(x, y, w, h);
+      }
     }
-    applyClipShapes(ctx, region);
   }
+  return true;
 }
-
-// src/emf-dib-rle-decoder.ts
-function decodeRleBitmap(view, bitsOffset, bitsSize, width, height, _topDown, isRle4, colorTable, out, setPixel) {
-  let x = 0;
-  let y = height - 1;
-  let off = bitsOffset;
-  const endOff = bitsOffset + bitsSize;
-  while (off + 1 < endOff && y >= 0) {
-    const first = view.getUint8(off);
-    const second = view.getUint8(off + 1);
-    off += 2;
-    if (first === 0) {
-      if (second === 0) {
-        x = 0;
-        y--;
-      } else if (second === 1) {
-        break;
-      } else if (second === 2) {
-        if (off + 1 >= endOff) {
-          break;
+function handleRoundRect(rCtx, dataOff, recSize) {
+  const { ctx, view, inPath } = rCtx;
+  if (recSize >= 32) {
+    const l = view.getInt32(dataOff, true);
+    const t = view.getInt32(dataOff + 4, true);
+    const r = view.getInt32(dataOff + 8, true);
+    const b = view.getInt32(dataOff + 12, true);
+    const cornerW = view.getInt32(dataOff + 16, true);
+    const cornerH = view.getInt32(dataOff + 20, true);
+    const rotated = hasWorldRotation(rCtx);
+    const rw = Math.abs(rotated ? cornerW / 2 : gmw(rCtx, cornerW) / 2);
+    const rh = Math.abs(rotated ? cornerH / 2 : gmh(rCtx, cornerH) / 2);
+    const x1 = rotated ? l : gmx(rCtx, l);
+    const y1 = rotated ? t : gmy(rCtx, t);
+    const w = rotated ? r - l : gmw(rCtx, r - l);
+    const h = rotated ? b - t : gmh(rCtx, b - t);
+    const map = (x, y) => rotated ? gmapPoint(rCtx, x, y) : { x, y };
+    const drawRoundRect = (c) => {
+      const radius = Math.min(rw, rh, Math.abs(w) / 2, Math.abs(h) / 2);
+      const start = map(x1 + radius, y1);
+      c.moveTo(start.x, start.y);
+      if (rotated) {
+        const corners = [
+          [x1 + w - radius, y1],
+          [x1 + w, y1 + radius],
+          [x1 + w, y1 + h - radius],
+          [x1 + w - radius, y1 + h],
+          [x1 + radius, y1 + h],
+          [x1, y1 + h - radius],
+          [x1, y1 + radius],
+          [x1 + radius, y1]
+        ];
+        for (const [px, py] of corners) {
+          const q = map(px, py);
+          c.lineTo(q.x, q.y);
         }
-        x += view.getUint8(off);
-        y -= view.getUint8(off + 1);
-        off += 2;
       } else {
-        const count = second;
-        if (!isRle4) {
-          for (let i = 0; i < count && off < endOff && x < width; i++) {
-            const idx = view.getUint8(off++);
-            if (idx < colorTable.length) {
-              setPixel(
-                x,
-                height - 1 - y,
-                colorTable[idx][0],
-                colorTable[idx][1],
-                colorTable[idx][2],
-                255
-              );
-            }
-            x++;
-          }
-          if (count & 1) {
-            off++;
-          }
-        } else {
-          const bytes = Math.ceil(count / 2);
-          let pi = 0;
-          for (let i = 0; i < bytes && off < endOff; i++) {
-            const byte = view.getUint8(off++);
-            for (let nibble = 0; nibble < 2 && pi < count; nibble++) {
-              const idx = nibble === 0 ? byte >> 4 & 15 : byte & 15;
-              if (idx < colorTable.length && x < width) {
-                setPixel(
-                  x,
-                  height - 1 - y,
-                  colorTable[idx][0],
-                  colorTable[idx][1],
-                  colorTable[idx][2],
-                  255
-                );
-              }
-              x++;
-              pi++;
-            }
-          }
-          if (bytes & 1) {
-            off++;
-          }
-        }
-      }
-    } else if (!isRle4) {
-      const idx = second;
-      const c = idx < colorTable.length ? colorTable[idx] : [0, 0, 0];
-      for (let i = 0; i < first && x < width; i++) {
-        setPixel(x, height - 1 - y, c[0], c[1], c[2], 255);
-        x++;
-      }
+        const corner2 = map(x1 + w - radius, y1);
+        c.lineTo(corner2.x, corner2.y);
+        const arc1a = map(x1 + w, y1);
+        const arc1b = map(x1 + w, y1 + radius);
+        c.arcTo(arc1a.x, arc1a.y, arc1b.x, arc1b.y, radius);
+        const corner3 = map(x1 + w, y1 + h - radius);
+        c.lineTo(corner3.x, corner3.y);
+        const arc2a = map(x1 + w, y1 + h);
+        const arc2b = map(x1 + w - radius, y1 + h);
+        c.arcTo(arc2a.x, arc2a.y, arc2b.x, arc2b.y, radius);
+        const corner4 = map(x1 + radius, y1 + h);
+        c.lineTo(corner4.x, corner4.y);
+        const arc3a = map(x1, y1 + h);
+        const arc3b = map(x1, y1 + h - radius);
+        c.arcTo(arc3a.x, arc3a.y, arc3b.x, arc3b.y, radius);
+        const corner1 = map(x1, y1 + radius);
+        c.lineTo(corner1.x, corner1.y);
+        const arc4a = map(x1, y1);
+        const arc4b = map(x1 + radius, y1);
+        c.arcTo(arc4a.x, arc4a.y, arc4b.x, arc4b.y, radius);
+      }
+      c.closePath();
+    };
+    if (inPath) {
+      drawRoundRect(ctx);
     } else {
-      const hi = second >> 4 & 15;
-      const lo = second & 15;
-      for (let i = 0; i < first && x < width; i++) {
-        const idx = (i & 1) === 0 ? hi : lo;
-        if (idx < colorTable.length) {
-          setPixel(
-            x,
-            height - 1 - y,
-            colorTable[idx][0],
-            colorTable[idx][1],
-            colorTable[idx][2],
-            255
-          );
-        }
-        x++;
-      }
+      const build = (c) => {
+        c.beginPath();
+        drawRoundRect(c);
+      };
+      build(ctx);
+      fillShapeExactOrFast(rCtx, build);
+      strokeShapeExactOrFast(rCtx, build);
     }
   }
-  return new ImageData(
-    new Uint8ClampedArray(out.buffer, out.byteOffset, out.byteLength),
-    width,
-    height
-  );
+  return true;
 }
-
-// src/emf-dib-uncompressed.ts
-function countTrailingZeros(v) {
-  if (v === 0) {
-    return 0;
-  }
-  let c = 0;
-  let val = v;
-  while ((val & 1) === 0) {
-    val >>>= 1;
-    c++;
+function handleEllipse(rCtx, dataOff, recSize) {
+  const { ctx, view, inPath } = rCtx;
+  if (recSize >= 24) {
+    const l = view.getInt32(dataOff, true);
+    const t = view.getInt32(dataOff + 4, true);
+    const r = view.getInt32(dataOff + 8, true);
+    const b = view.getInt32(dataOff + 12, true);
+    const params = hasWorldRotation(rCtx) ? gdiEllipseParams(rCtx, (l + r) / 2, (t + b) / 2, Math.abs(r - l) / 2, Math.abs(b - t) / 2) : {
+      cx: gmx(rCtx, (l + r) / 2),
+      cy: gmy(rCtx, (t + b) / 2),
+      rx: Math.abs(gmw(rCtx, r - l)) / 2,
+      ry: Math.abs(gmh(rCtx, b - t)) / 2,
+      rotation: 0
+    };
+    if (inPath) {
+      ctx.ellipse(params.cx, params.cy, params.rx, params.ry, params.rotation, 0, Math.PI * 2);
+    } else {
+      const build = (c) => {
+        c.beginPath();
+        c.ellipse(params.cx, params.cy, params.rx, params.ry, params.rotation, 0, Math.PI * 2);
+      };
+      build(ctx);
+      fillShapeExactOrFast(rCtx, build);
+      strokeShapeExactOrFast(rCtx, build);
+    }
   }
-  return c;
+  return true;
 }
-var BI_BITFIELDS = 3;
-function parseBitfieldMasks(view, bmiOffset, headerSize, compression, bitCount) {
-  let rMask = 0, gMask = 0, bMask = 0;
-  let rShift = 0, gShift = 0, bShift = 0;
-  let rMax = 1, gMax = 1, bMax = 1;
-  if (compression === BI_BITFIELDS) {
-    const bfOff = bmiOffset + headerSize;
-    if (bfOff + 12 > view.byteLength) {
-      return null;
+function handleArcFamily(rCtx, recType, dataOff, recSize) {
+  const { ctx, view, state, inPath } = rCtx;
+  if (recSize >= 40) {
+    const l = view.getInt32(dataOff, true);
+    const t = view.getInt32(dataOff + 4, true);
+    const r = view.getInt32(dataOff + 8, true);
+    const b = view.getInt32(dataOff + 12, true);
+    const startX = view.getInt32(dataOff + 16, true);
+    const startY = view.getInt32(dataOff + 20, true);
+    const endX = view.getInt32(dataOff + 24, true);
+    const endY = view.getInt32(dataOff + 28, true);
+    const cxA = (l + r) / 2;
+    const cyA = (t + b) / 2;
+    const rx = Math.abs(r - l) / 2;
+    const ry = Math.abs(b - t) / 2;
+    const startAngle = Math.atan2((startY - cyA) / (ry || 1), (startX - cxA) / (rx || 1));
+    const endAngle = Math.atan2((endY - cyA) / (ry || 1), (endX - cxA) / (rx || 1));
+    const rotated = hasWorldRotation(rCtx);
+    const params = rotated ? gdiEllipseParams(rCtx, cxA, cyA, rx, ry) : {
+      cx: gmx(rCtx, cxA),
+      cy: gmy(rCtx, cyA),
+      rx: Math.abs(gmw(rCtx, rx)),
+      ry: Math.abs(gmh(rCtx, ry)),
+      rotation: 0
+    };
+    const isArcTo = recType === EMR_ARCTO;
+    const needsFill = recType === EMR_PIE || recType === EMR_CHORD;
+    const startPoint = rotated ? gmapPoint(rCtx, cxA + rx * Math.cos(startAngle), cyA + ry * Math.sin(startAngle)) : { x: params.cx + params.rx * Math.cos(startAngle), y: params.cy + params.ry * Math.sin(startAngle) };
+    const build = (c) => {
+      if (recType === EMR_PIE) {
+        c.moveTo(params.cx, params.cy);
+      }
+      if (isArcTo) {
+        c.lineTo(startPoint.x, startPoint.y);
+      }
+      c.ellipse(params.cx, params.cy, params.rx, params.ry, params.rotation, startAngle, endAngle, false);
+      if (needsFill) {
+        c.closePath();
+      }
+    };
+    if (!inPath) {
+      ctx.beginPath();
+    }
+    build(ctx);
+    if (!inPath) {
+      const buildWithPath = (c) => {
+        c.beginPath();
+        build(c);
+      };
+      if (needsFill) {
+        fillShapeExactOrFast(rCtx, buildWithPath);
+      }
+      strokeShapeExactOrFast(rCtx, buildWithPath);
+    }
+    if (isArcTo) {
+      state.curX = endX;
+      state.curY = endY;
     }
-    rMask = view.getUint32(bfOff, true);
-    gMask = view.getUint32(bfOff + 4, true);
-    bMask = view.getUint32(bfOff + 8, true);
-    rShift = countTrailingZeros(rMask);
-    gShift = countTrailingZeros(gMask);
-    bShift = countTrailingZeros(bMask);
-    rMax = rMask >>> rShift || 1;
-    gMax = gMask >>> gShift || 1;
-    bMax = bMask >>> bShift || 1;
-  } else if (bitCount === 16) {
-    rMask = 31744;
-    gMask = 992;
-    bMask = 31;
-    rShift = 10;
-    gShift = 5;
-    bShift = 0;
-    rMax = 31;
-    gMax = 31;
-    bMax = 31;
   }
-  return { rMask, gMask, bMask, rShift, gShift, bShift, rMax, gMax, bMax };
+  return true;
 }
-function decodeUncompressedRows(view, bitsOffset, width, height, topDown, bitCount, colorTable, masks, out) {
-  const rowStride = Math.floor((bitCount * width + 31) / 32) * 4;
-  const { rMask, gMask, bMask, rShift, gShift, bShift, rMax, gMax, bMax } = masks;
-  for (let y = 0; y < height; y++) {
-    const srcY = topDown ? y : height - 1 - y;
-    const rowStart = bitsOffset + srcY * rowStride;
-    if (rowStart + rowStride > view.byteLength) {
-      continue;
-    }
-    for (let x = 0; x < width; x++) {
-      const dstPx = (y * width + x) * 4;
-      if (bitCount === 1) {
-        const byteIdx = rowStart + (x >> 3);
-        const bit = view.getUint8(byteIdx) >> 7 - (x & 7) & 1;
-        if (bit < colorTable.length) {
-          out[dstPx] = colorTable[bit][0];
-          out[dstPx + 1] = colorTable[bit][1];
-          out[dstPx + 2] = colorTable[bit][2];
-        }
-        out[dstPx + 3] = 255;
-      } else if (bitCount === 4) {
-        const byteIdx = rowStart + (x >> 1);
-        const nibble = (x & 1) === 0 ? view.getUint8(byteIdx) >> 4 & 15 : view.getUint8(byteIdx) & 15;
-        if (nibble < colorTable.length) {
-          out[dstPx] = colorTable[nibble][0];
-          out[dstPx + 1] = colorTable[nibble][1];
-          out[dstPx + 2] = colorTable[nibble][2];
-        }
-        out[dstPx + 3] = 255;
-      } else if (bitCount === 8) {
-        const idx = view.getUint8(rowStart + x);
-        if (idx < colorTable.length) {
-          out[dstPx] = colorTable[idx][0];
-          out[dstPx + 1] = colorTable[idx][1];
-          out[dstPx + 2] = colorTable[idx][2];
+function handleEmfGdiShapeRecord(rCtx, recType, dataOff, recSize) {
+  switch (recType) {
+    case EMR_SETPIXELV:
+      return handleSetPixelV(rCtx, dataOff, recSize);
+    case EMR_MOVETOEX:
+      return handleMoveToEx(rCtx, dataOff, recSize);
+    case EMR_LINETO:
+      return handleLineTo(rCtx, dataOff, recSize);
+    case EMR_RECTANGLE:
+      return handleRectangle(rCtx, dataOff, recSize);
+    case EMR_ROUNDRECT:
+      return handleRoundRect(rCtx, dataOff, recSize);
+    case EMR_ELLIPSE:
+      return handleEllipse(rCtx, dataOff, recSize);
+    case EMR_ARC:
+    case EMR_ARCTO:
+    case EMR_CHORD:
+    case EMR_PIE:
+      return handleArcFamily(rCtx, recType, dataOff, recSize);
+    default:
+      return false;
+  }
+}
+
+// src/emf-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;
         }
-        out[dstPx + 3] = 255;
-      } else if (bitCount === 16) {
-        const val = view.getUint16(rowStart + x * 2, true);
-        out[dstPx] = Math.round(((val & rMask) >>> rShift) * 255 / rMax);
-        out[dstPx + 1] = Math.round(((val & gMask) >>> gShift) * 255 / gMax);
-        out[dstPx + 2] = Math.round(((val & bMask) >>> bShift) * 255 / bMax);
-        out[dstPx + 3] = 255;
-      } else if (bitCount === 24) {
-        const srcPx = rowStart + x * 3;
-        out[dstPx] = view.getUint8(srcPx + 2);
-        out[dstPx + 1] = view.getUint8(srcPx + 1);
-        out[dstPx + 2] = view.getUint8(srcPx);
-        out[dstPx + 3] = 255;
-      } else {
-        const srcPx = rowStart + x * 4;
-        const bb = view.getUint8(srcPx);
-        const gg = view.getUint8(srcPx + 1);
-        const rr = view.getUint8(srcPx + 2);
-        const aa = view.getUint8(srcPx + 3);
-        out[dstPx] = rr;
-        out[dstPx + 1] = gg;
-        out[dstPx + 2] = bb;
-        out[dstPx + 3] = aa === 0 ? 255 : aa;
       }
+      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-dib-decoder.ts
-function decodeDibToImageData(view, bmiOffset, bitsOffset, bitsSize) {
-  if (bmiOffset < 0 || bitsOffset < 0 || bmiOffset + 40 > view.byteLength || bitsOffset + bitsSize > view.byteLength) {
-    return null;
+// src/emf-gdi-draw-bitmap.ts
+function patternOperand(rCtx, brush) {
+  if (brush.kind === "solid") {
+    return brush.rgb;
   }
-  const headerSize = view.getUint32(bmiOffset, true);
-  if (headerSize < 40 || bmiOffset + headerSize > view.byteLength) {
-    return null;
+  if (brush.kind === "none") {
+    return 0;
   }
-  const width = view.getInt32(bmiOffset + 4, true);
-  const heightRaw = view.getInt32(bmiOffset + 8, true);
-  const planes = view.getUint16(bmiOffset + 12, true);
-  const bitCount = view.getUint16(bmiOffset + 14, true);
-  const compression = view.getUint32(bmiOffset + 16, true);
-  if (planes !== 1 || width <= 0 || heightRaw === 0) {
-    return null;
+  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;
   }
-  if (width > 8192 || Math.abs(heightRaw) > 8192) {
+  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 BI_RGB = 0;
-  const BI_RLE8 = 1;
-  const BI_RLE4 = 2;
-  const BI_BITFIELDS2 = 3;
-  if (bitCount !== 1 && bitCount !== 4 && bitCount !== 8 && bitCount !== 16 && bitCount !== 24 && bitCount !== 32) {
+  const image = decodeDibToImageData(rCtx.view, req.source.bmi, req.source.bits, req.source.cbBits);
+  if (!image) {
     return null;
   }
-  if (compression === BI_RLE8 && bitCount !== 8) {
+  const temp = createTempCanvas(image.width, image.height);
+  if (!temp) {
     return null;
   }
-  if (compression === BI_RLE4 && bitCount !== 4) {
+  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;
   }
-  if (compression === BI_BITFIELDS2 && bitCount !== 16 && bitCount !== 32) {
+  const start = offset + offDx;
+  const end = start + nChars * 4;
+  if (start < 0 || end > viewEnd) {
     return null;
   }
-  if (compression !== BI_RGB && compression !== BI_RLE8 && compression !== BI_RLE4 && compression !== BI_BITFIELDS2) {
+  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;
   }
-  const height = Math.abs(heightRaw);
-  const topDown = heightRaw < 0;
-  const colorTable = [];
-  if (bitCount <= 8) {
-    const maxColors = 1 << bitCount;
-    const colorsUsed = view.getUint32(bmiOffset + 32, true) || maxColors;
-    const numColors = Math.min(colorsUsed, maxColors);
-    const ctOffset = bmiOffset + headerSize;
-    if (ctOffset + numColors * 4 > view.byteLength) {
-      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 };
     }
-    for (let i = 0; i < numColors; i++) {
-      const b = view.getUint8(ctOffset + i * 4);
-      const g = view.getUint8(ctOffset + i * 4 + 1);
-      const r = view.getUint8(ctOffset + i * 4 + 2);
-      colorTable.push([r, g, b]);
+    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 };
     }
   }
-  const masks = parseBitfieldMasks(view, bmiOffset, headerSize, compression, bitCount);
-  if (!masks) {
-    return null;
+}
+function combineClipRegions(current, incoming, op) {
+  if (op === "replace") {
+    return { region: incoming, exact: true };
   }
-  const out = new Uint8ClampedArray(width * height * 4);
-  if (compression === BI_RLE8 || compression === BI_RLE4) {
-    const setPixel = (x, y, r, g, b, a) => {
-      const dstPx = (y * width + x) * 4;
-      out[dstPx] = r;
-      out[dstPx + 1] = g;
-      out[dstPx + 2] = b;
-      out[dstPx + 3] = a;
-    };
-    return decodeRleBitmap(
-      view,
-      bitsOffset,
-      bitsSize,
-      width,
-      height,
-      topDown,
-      compression === BI_RLE4,
-      colorTable,
-      out,
-      setPixel
-    );
+  if (incoming && incoming.length === 1) {
+    return combineClip(current, incoming[0], op);
   }
-  decodeUncompressedRows(
-    view,
-    bitsOffset,
-    width,
-    height,
-    topDown,
-    bitCount,
-    colorTable,
-    masks,
-    out
-  );
-  return new ImageData(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;
+  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") {
@@ -1720,14 +2623,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:
@@ -1741,12 +2638,36 @@ 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);
 }
 
 // src/emf-gdi-polypolygon-helpers.ts
+function buildPolyPolygonPath(target, rCtx, readPoint, countsOff, numPolys, totalPoints, close) {
+  const { view } = rCtx;
+  let pIdx = 0;
+  for (let p = 0; p < numPolys; p++) {
+    const count = view.getUint32(countsOff + p * 4, true);
+    for (let i = 0; i < count && pIdx < totalPoints; i++) {
+      const pt = readPoint(pIdx);
+      if (i === 0) {
+        target.moveTo(pt.x, pt.y);
+      } else {
+        target.lineTo(pt.x, pt.y);
+      }
+      pIdx++;
+    }
+    if (close) {
+      target.closePath();
+    }
+  }
+}
 function handlePolyPolygon32(rCtx, offset, dataOff, recSize) {
   const { ctx, view, state, inPath } = rCtx;
   const numPolys = view.getUint32(dataOff + 16, true);
@@ -1759,33 +2680,25 @@ function handlePolyPolygon32(rCtx, offset, dataOff, recSize) {
   if (ptOff + totalPoints * 8 > offset + recSize) {
     return;
   }
+  const readPoint = (pIdx) => gmapPoint(rCtx, view.getInt32(ptOff + pIdx * 8, true), view.getInt32(ptOff + pIdx * 8 + 4, true));
+  const build = (target) => {
+    buildPolyPolygonPath(target, rCtx, readPoint, countsOff, numPolys, totalPoints, true);
+  };
   if (!inPath) {
     ctx.beginPath();
   }
-  let pIdx = 0;
-  for (let p = 0; p < numPolys; p++) {
-    const count = view.getUint32(countsOff + p * 4, true);
-    for (let i = 0; i < count && pIdx < totalPoints; i++) {
-      const px = view.getInt32(ptOff + pIdx * 8, true);
-      const py = view.getInt32(ptOff + pIdx * 8 + 4, true);
-      if (i === 0) {
-        ctx.moveTo(gmx(rCtx, px), gmy(rCtx, py));
-      } else {
-        ctx.lineTo(gmx(rCtx, px), gmy(rCtx, py));
-      }
-      pIdx++;
-    }
-    ctx.closePath();
-  }
+  build(ctx);
   if (!inPath) {
-    applyBrush(ctx, state);
-    ctx.fill(state.polyFillMode === 2 ? "nonzero" : "evenodd");
-    applyPen(ctx, state);
-    ctx.stroke();
+    const buildWithPath = (target) => {
+      target.beginPath();
+      build(target);
+    };
+    fillShapeExactOrFast(rCtx, buildWithPath, state.polyFillMode === 2 ? "nonzero" : "evenodd");
+    strokeShapeExactOrFast(rCtx, buildWithPath);
   }
 }
 function handlePolyPolyline32(rCtx, offset, dataOff, recSize) {
-  const { ctx, view, state, inPath } = rCtx;
+  const { ctx, view, inPath } = rCtx;
   const numPolys = view.getUint32(dataOff + 16, true);
   const totalPoints = view.getUint32(dataOff + 20, true);
   if (numPolys === 0 || numPolys >= 1e4 || totalPoints >= 1e5) {
@@ -1796,26 +2709,20 @@ function handlePolyPolyline32(rCtx, offset, dataOff, recSize) {
   if (ptOff + totalPoints * 8 > offset + recSize) {
     return;
   }
+  const readPoint = (pIdx) => gmapPoint(rCtx, view.getInt32(ptOff + pIdx * 8, true), view.getInt32(ptOff + pIdx * 8 + 4, true));
+  const build = (target) => {
+    buildPolyPolygonPath(target, rCtx, readPoint, countsOff, numPolys, totalPoints, false);
+  };
   if (!inPath) {
     ctx.beginPath();
   }
-  let pIdx = 0;
-  for (let p = 0; p < numPolys; p++) {
-    const count = view.getUint32(countsOff + p * 4, true);
-    for (let i = 0; i < count && pIdx < totalPoints; i++) {
-      const px = view.getInt32(ptOff + pIdx * 8, true);
-      const py = view.getInt32(ptOff + pIdx * 8 + 4, true);
-      if (i === 0) {
-        ctx.moveTo(gmx(rCtx, px), gmy(rCtx, py));
-      } else {
-        ctx.lineTo(gmx(rCtx, px), gmy(rCtx, py));
-      }
-      pIdx++;
-    }
-  }
+  build(ctx);
   if (!inPath) {
-    applyPen(ctx, state);
-    ctx.stroke();
+    const buildWithPath = (target) => {
+      target.beginPath();
+      build(target);
+    };
+    strokeShapeExactOrFast(rCtx, buildWithPath);
   }
 }
 function handlePolyPolygon16(rCtx, offset, dataOff, recSize) {
@@ -1830,29 +2737,21 @@ function handlePolyPolygon16(rCtx, offset, dataOff, recSize) {
   if (ptOff + totalPoints * 4 > offset + recSize) {
     return;
   }
+  const readPoint = (pIdx) => gmapPoint(rCtx, view.getInt16(ptOff + pIdx * 4, true), view.getInt16(ptOff + pIdx * 4 + 2, true));
+  const build = (target) => {
+    buildPolyPolygonPath(target, rCtx, readPoint, countsOff, numPolys, totalPoints, true);
+  };
   if (!inPath) {
     ctx.beginPath();
   }
-  let pIdx = 0;
-  for (let p = 0; p < numPolys; p++) {
-    const count = view.getUint32(countsOff + p * 4, true);
-    for (let i = 0; i < count && pIdx < totalPoints; i++) {
-      const px = view.getInt16(ptOff + pIdx * 4, true);
-      const py = view.getInt16(ptOff + pIdx * 4 + 2, true);
-      if (i === 0) {
-        ctx.moveTo(gmx(rCtx, px), gmy(rCtx, py));
-      } else {
-        ctx.lineTo(gmx(rCtx, px), gmy(rCtx, py));
-      }
-      pIdx++;
-    }
-    ctx.closePath();
-  }
+  build(ctx);
   if (!inPath) {
-    applyBrush(ctx, state);
-    ctx.fill(state.polyFillMode === 2 ? "nonzero" : "evenodd");
-    applyPen(ctx, state);
-    ctx.stroke();
+    const buildWithPath = (target) => {
+      target.beginPath();
+      build(target);
+    };
+    fillShapeExactOrFast(rCtx, buildWithPath, state.polyFillMode === 2 ? "nonzero" : "evenodd");
+    strokeShapeExactOrFast(rCtx, buildWithPath);
   }
 }
 
@@ -1870,43 +2769,44 @@ function handlePoly32(rCtx, recType, offset, dataOff, recSize) {
   const isPolygon = recType === EMR_POLYGON;
   const isBezier = recType === EMR_POLYBEZIER || recType === EMR_POLYBEZIERTO;
   const isTo = recType === EMR_POLYBEZIERTO || recType === EMR_POLYLINETO;
-  if (!inPath) {
-    ctx.beginPath();
-  }
-  if (!isTo) {
-    ctx.moveTo(gmx(rCtx, view.getInt32(ptOff, true)), gmy(rCtx, view.getInt32(ptOff + 4, true)));
-  }
-  let i = isTo ? 0 : 1;
-  if (isBezier) {
-    while (i + 2 < count) {
-      ctx.bezierCurveTo(
-        gmx(rCtx, view.getInt32(ptOff + i * 8, true)),
-        gmy(rCtx, view.getInt32(ptOff + i * 8 + 4, true)),
-        gmx(rCtx, view.getInt32(ptOff + (i + 1) * 8, true)),
-        gmy(rCtx, view.getInt32(ptOff + (i + 1) * 8 + 4, true)),
-        gmx(rCtx, view.getInt32(ptOff + (i + 2) * 8, true)),
-        gmy(rCtx, view.getInt32(ptOff + (i + 2) * 8 + 4, true))
-      );
-      i += 3;
+  const pt = (i) => gmapPoint(rCtx, view.getInt32(ptOff + i * 8, true), view.getInt32(ptOff + i * 8 + 4, true));
+  const build = (target) => {
+    if (!isTo) {
+      const p0 = pt(0);
+      target.moveTo(p0.x, p0.y);
+    }
+    let i = isTo ? 0 : 1;
+    if (isBezier) {
+      while (i + 2 < count) {
+        const p1 = pt(i);
+        const p2 = pt(i + 1);
+        const p3 = pt(i + 2);
+        target.bezierCurveTo(p1.x, p1.y, p2.x, p2.y, p3.x, p3.y);
+        i += 3;
+      }
+    } else {
+      for (; i < count; i++) {
+        const p = pt(i);
+        target.lineTo(p.x, p.y);
+      }
     }
-  } else {
-    for (; i < count; i++) {
-      ctx.lineTo(
-        gmx(rCtx, view.getInt32(ptOff + i * 8, true)),
-        gmy(rCtx, view.getInt32(ptOff + i * 8 + 4, true))
-      );
+    if (isPolygon) {
+      target.closePath();
     }
+  };
+  if (!inPath) {
+    ctx.beginPath();
   }
-  if (isPolygon) {
-    ctx.closePath();
-  }
+  build(ctx);
   if (!inPath) {
+    const buildWithPath = (target) => {
+      target.beginPath();
+      build(target);
+    };
     if (isPolygon) {
-      applyBrush(ctx, state);
-      ctx.fill(state.polyFillMode === 2 ? "nonzero" : "evenodd");
+      fillShapeExactOrFast(rCtx, buildWithPath, state.polyFillMode === 2 ? "nonzero" : "evenodd");
     }
-    applyPen(ctx, state);
-    ctx.stroke();
+    strokeShapeExactOrFast(rCtx, buildWithPath);
   }
   if (count > 0) {
     const last = count - 1;
@@ -1928,43 +2828,44 @@ function handlePoly16(rCtx, recType, offset, dataOff, recSize) {
   const isPolygon = recType === EMR_POLYGON16;
   const isBezier = recType === EMR_POLYBEZIER16 || recType === EMR_POLYBEZIERTO16;
   const isTo = recType === EMR_POLYBEZIERTO16 || recType === EMR_POLYLINETO16;
-  if (!inPath) {
-    ctx.beginPath();
-  }
-  if (!isTo) {
-    ctx.moveTo(gmx(rCtx, view.getInt16(ptOff, true)), gmy(rCtx, view.getInt16(ptOff + 2, true)));
-  }
-  let i = isTo ? 0 : 1;
-  if (isBezier) {
-    while (i + 2 < count) {
-      ctx.bezierCurveTo(
-        gmx(rCtx, view.getInt16(ptOff + i * 4, true)),
-        gmy(rCtx, view.getInt16(ptOff + i * 4 + 2, true)),
-        gmx(rCtx, view.getInt16(ptOff + (i + 1) * 4, true)),
-        gmy(rCtx, view.getInt16(ptOff + (i + 1) * 4 + 2, true)),
-        gmx(rCtx, view.getInt16(ptOff + (i + 2) * 4, true)),
-        gmy(rCtx, view.getInt16(ptOff + (i + 2) * 4 + 2, true))
-      );
-      i += 3;
+  const pt = (i) => gmapPoint(rCtx, view.getInt16(ptOff + i * 4, true), view.getInt16(ptOff + i * 4 + 2, true));
+  const build = (target) => {
+    if (!isTo) {
+      const p0 = pt(0);
+      target.moveTo(p0.x, p0.y);
+    }
+    let i = isTo ? 0 : 1;
+    if (isBezier) {
+      while (i + 2 < count) {
+        const p1 = pt(i);
+        const p2 = pt(i + 1);
+        const p3 = pt(i + 2);
+        target.bezierCurveTo(p1.x, p1.y, p2.x, p2.y, p3.x, p3.y);
+        i += 3;
+      }
+    } else {
+      for (; i < count; i++) {
+        const p = pt(i);
+        target.lineTo(p.x, p.y);
+      }
     }
-  } else {
-    for (; i < count; i++) {
-      ctx.lineTo(
-        gmx(rCtx, view.getInt16(ptOff + i * 4, true)),
-        gmy(rCtx, view.getInt16(ptOff + i * 4 + 2, true))
-      );
+    if (isPolygon) {
+      target.closePath();
     }
+  };
+  if (!inPath) {
+    ctx.beginPath();
   }
-  if (isPolygon) {
-    ctx.closePath();
-  }
+  build(ctx);
   if (!inPath) {
+    const buildWithPath = (target) => {
+      target.beginPath();
+      build(target);
+    };
     if (isPolygon) {
-      applyBrush(ctx, state);
-      ctx.fill(state.polyFillMode === 2 ? "nonzero" : "evenodd");
+      fillShapeExactOrFast(rCtx, buildWithPath, state.polyFillMode === 2 ? "nonzero" : "evenodd");
     }
-    applyPen(ctx, state);
-    ctx.stroke();
+    strokeShapeExactOrFast(rCtx, buildWithPath);
   }
   if (count > 0) {
     const last = count - 1;
@@ -2017,16 +2918,24 @@ function handleEmfGdiPolyPathRecord(rCtx, recType, offset, dataOff, recSize) {
     case EMR_CLOSEFIGURE:
       ctx.closePath();
       return true;
-    case EMR_FILLPATH:
-      applyBrush(ctx, state);
-      ctx.fill(state.polyFillMode === 2 ? "nonzero" : "evenodd");
+    case EMR_FILLPATH: {
+      const fillRule = state.polyFillMode === 2 ? "nonzero" : "evenodd";
+      if (!fillCurrentPathWithGdiPattern(rCtx, fillRule)) {
+        applyBrush(ctx, state);
+        ctx.fill(fillRule);
+      }
       return true;
-    case EMR_STROKEANDFILLPATH:
-      applyBrush(ctx, state);
-      ctx.fill(state.polyFillMode === 2 ? "nonzero" : "evenodd");
+    }
+    case EMR_STROKEANDFILLPATH: {
+      const fillRule = state.polyFillMode === 2 ? "nonzero" : "evenodd";
+      if (!fillCurrentPathWithGdiPattern(rCtx, fillRule)) {
+        applyBrush(ctx, state);
+        ctx.fill(fillRule);
+      }
       applyPen(ctx, state);
       ctx.stroke();
       return true;
+    }
     case EMR_STROKEPATH:
       applyPen(ctx, state);
       ctx.stroke();
@@ -2091,12 +3000,30 @@ function handleEmfObjectRecord(rCtx, recType, dataOff, recSize) {
     case EMR_CREATEBRUSHINDIRECT: {
       if (recSize >= 24) {
         const ihBrush = view.getUint32(dataOff, true);
-        const brushStyle = view.getUint32(dataOff + 4, true);
-        const color = readColorRef(view, dataOff + 8);
+        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,
+          ...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: brushStyle,
-          color
+          style: pattern ? mono ? 3 : 6 : 0,
+          // Flat stand-in for fills that do not realise the pattern.
+          color: "#808080",
+          ...pattern ? { pattern } : {}
         });
       }
       return true;
@@ -2105,19 +3032,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;
@@ -2136,6 +3067,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;
@@ -2144,6 +3076,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;
           }
         }
@@ -2312,15 +3245,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,
@@ -2437,7 +3377,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) {
@@ -2480,6 +3432,411 @@ 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 surfaceSize3(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 = surfaceSize3(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-brush-texture.ts
+var IDENTITY2 = [1, 0, 0, 1, 0, 0];
+function packArgb(rgba, i) {
+  return (rgba[i + 3] << 24 | rgba[i] << 16 | rgba[i + 1] << 8 | rgba[i + 2]) >>> 0;
+}
+function createBrushTexture(ctx, texture, device = IDENTITY2) {
+  const { width, height, rgba } = texture;
+  if (width <= 0 || height <= 0) {
+    return null;
+  }
+  try {
+    const brush = texture.transform ?? IDENTITY2;
+    const colorAt = (bx, by) => {
+      const ix = Math.floor(bx);
+      const iy = Math.floor(by);
+      if (ix < 0 || iy < 0 || ix >= width || iy >= height) {
+        return null;
+      }
+      return packArgb(rgba, (iy * width + ix) * 4);
+    };
+    return buildPattern(
+      ctx,
+      { x: 0, y: 0, w: width, h: height },
+      width,
+      height,
+      texture.wrapMode,
+      brush,
+      halfPixelDelta(device),
+      { phaseX: 0, lagX: 0, lagY: 0 },
+      colorAt
+    );
+  } catch {
+    return null;
+  }
+}
+
 // src/emf-plus-path.ts
 function parseEmfPlusPath(data, off, maxLen) {
   if (maxLen < 12) {
@@ -2614,32 +3971,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);
@@ -2647,11 +3978,17 @@ 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;
       }
     }
+    if (obj.texture) {
+      const p = createBrushTexture(rCtx.ctx, obj.texture, plusWorldMatrix(rCtx));
+      if (p) {
+        return p;
+      }
+    }
     return obj.color;
   }
   return "rgba(0,0,0,1)";
@@ -2682,18 +4019,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({
@@ -3173,42 +4506,216 @@ function handleEmfPlusDrawRecord(rCtx, recType, recFlags, dataOff, recDataSize)
           } else {
             ctx.lineTo(pt.x, pt.y);
           }
-          pOff += ptSize;
+          pOff += ptSize;
+        }
+        if (recFlags & 8192) {
+          ctx.closePath();
+        }
+        ctx.stroke();
+      }
+      return true;
+    }
+    case EMFPLUS_FILLPOLYGON: {
+      if (recDataSize >= 8) {
+        const brushVal = view.getUint32(dataOff, true);
+        const count = view.getUint32(dataOff + 4, true);
+        const compressed = (recFlags & 16384) !== 0;
+        const ptSize = compressed ? 4 : 8;
+        ctx.fillStyle = resolveBrushPaint(rCtx, recFlags, brushVal);
+        applyPlusWorldTransform(rCtx);
+        ctx.beginPath();
+        let pOff = dataOff + 8;
+        for (let i = 0; i < count && pOff + ptSize <= dataOff + recDataSize; i++) {
+          const pt = readPointFromView(view, pOff, compressed);
+          if (i === 0) {
+            ctx.moveTo(pt.x, pt.y);
+          } else {
+            ctx.lineTo(pt.x, pt.y);
+          }
+          pOff += ptSize;
+        }
+        ctx.closePath();
+        ctx.fill();
+      }
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+
+// src/emf-plus-bitmap-decoder.ts
+var PIXELFORMAT_24BPP_RGB = 137224;
+var PIXELFORMAT_32BPP_RGB = 139273;
+var PIXELFORMAT_32BPP_ARGB = 2498570;
+var PIXELFORMAT_32BPP_PARGB = 925707;
+function decodeEmfPlusBitmapPixels(view, pixelStart, width, height, stride, pixelFormat) {
+  const absStride = Math.abs(stride);
+  const topDown = stride > 0;
+  const rowBytes = width * 4;
+  const bmpRowStride = rowBytes + 3 & -4;
+  const pixelDataSize = bmpRowStride * height;
+  const bmpData = new Uint8Array(pixelDataSize);
+  for (let y = 0; y < height; y++) {
+    const srcRow = topDown ? y : height - 1 - y;
+    const rowOff = pixelStart + srcRow * absStride;
+    const dstRow = (height - 1 - y) * bmpRowStride;
+    switch (pixelFormat) {
+      case PIXELFORMAT_32BPP_ARGB:
+      case PIXELFORMAT_32BPP_PARGB: {
+        for (let x = 0; x < width; x++) {
+          const off = rowOff + x * 4;
+          if (off + 3 >= view.byteLength) {
+            break;
+          }
+          let b = view.getUint8(off);
+          let g = view.getUint8(off + 1);
+          let r = view.getUint8(off + 2);
+          const a = view.getUint8(off + 3);
+          if (pixelFormat === PIXELFORMAT_32BPP_PARGB && a > 0 && a < 255) {
+            r = Math.min(255, Math.round(r * 255 / a));
+            g = Math.min(255, Math.round(g * 255 / a));
+            b = Math.min(255, Math.round(b * 255 / a));
+          }
+          const di = dstRow + x * 4;
+          bmpData[di] = b;
+          bmpData[di + 1] = g;
+          bmpData[di + 2] = r;
+          bmpData[di + 3] = a;
+        }
+        break;
+      }
+      case PIXELFORMAT_32BPP_RGB: {
+        for (let x = 0; x < width; x++) {
+          const off = rowOff + x * 4;
+          if (off + 3 >= view.byteLength) {
+            break;
+          }
+          const di = dstRow + x * 4;
+          bmpData[di] = view.getUint8(off);
+          bmpData[di + 1] = view.getUint8(off + 1);
+          bmpData[di + 2] = view.getUint8(off + 2);
+          bmpData[di + 3] = 255;
+        }
+        break;
+      }
+      case PIXELFORMAT_24BPP_RGB: {
+        for (let x = 0; x < width; x++) {
+          const off = rowOff + x * 3;
+          if (off + 2 >= view.byteLength) {
+            break;
+          }
+          const di = dstRow + x * 4;
+          bmpData[di] = view.getUint8(off);
+          bmpData[di + 1] = view.getUint8(off + 1);
+          bmpData[di + 2] = view.getUint8(off + 2);
+          bmpData[di + 3] = 255;
+        }
+        break;
+      }
+      default:
+        return null;
+    }
+  }
+  return wrapBmpFile(bmpData, bmpRowStride, width, height, pixelDataSize);
+}
+function decodeEmfPlusBitmapPixelsToRgba(view, pixelStart, width, height, stride, pixelFormat) {
+  const absStride = Math.abs(stride);
+  const topDown = stride > 0;
+  const rgba = new Uint8ClampedArray(width * height * 4);
+  for (let y = 0; y < height; y++) {
+    const srcRow = topDown ? y : height - 1 - y;
+    const rowOff = pixelStart + srcRow * absStride;
+    const dstRow = y * width * 4;
+    switch (pixelFormat) {
+      case PIXELFORMAT_32BPP_ARGB:
+      case PIXELFORMAT_32BPP_PARGB: {
+        for (let x = 0; x < width; x++) {
+          const off = rowOff + x * 4;
+          if (off + 3 >= view.byteLength) {
+            break;
+          }
+          let b = view.getUint8(off);
+          let g = view.getUint8(off + 1);
+          let r = view.getUint8(off + 2);
+          const a = view.getUint8(off + 3);
+          if (pixelFormat === PIXELFORMAT_32BPP_PARGB && a > 0 && a < 255) {
+            r = Math.min(255, Math.round(r * 255 / a));
+            g = Math.min(255, Math.round(g * 255 / a));
+            b = Math.min(255, Math.round(b * 255 / a));
+          }
+          const di = dstRow + x * 4;
+          rgba[di] = r;
+          rgba[di + 1] = g;
+          rgba[di + 2] = b;
+          rgba[di + 3] = a;
         }
-        if (recFlags & 8192) {
-          ctx.closePath();
+        break;
+      }
+      case PIXELFORMAT_32BPP_RGB: {
+        for (let x = 0; x < width; x++) {
+          const off = rowOff + x * 4;
+          if (off + 3 >= view.byteLength) {
+            break;
+          }
+          const di = dstRow + x * 4;
+          rgba[di] = view.getUint8(off + 2);
+          rgba[di + 1] = view.getUint8(off + 1);
+          rgba[di + 2] = view.getUint8(off);
+          rgba[di + 3] = 255;
         }
-        ctx.stroke();
+        break;
       }
-      return true;
-    }
-    case EMFPLUS_FILLPOLYGON: {
-      if (recDataSize >= 8) {
-        const brushVal = view.getUint32(dataOff, true);
-        const count = view.getUint32(dataOff + 4, true);
-        const compressed = (recFlags & 16384) !== 0;
-        const ptSize = compressed ? 4 : 8;
-        ctx.fillStyle = resolveBrushPaint(rCtx, recFlags, brushVal);
-        applyPlusWorldTransform(rCtx);
-        ctx.beginPath();
-        let pOff = dataOff + 8;
-        for (let i = 0; i < count && pOff + ptSize <= dataOff + recDataSize; i++) {
-          const pt = readPointFromView(view, pOff, compressed);
-          if (i === 0) {
-            ctx.moveTo(pt.x, pt.y);
-          } else {
-            ctx.lineTo(pt.x, pt.y);
+      case PIXELFORMAT_24BPP_RGB: {
+        for (let x = 0; x < width; x++) {
+          const off = rowOff + x * 3;
+          if (off + 2 >= view.byteLength) {
+            break;
           }
-          pOff += ptSize;
+          const di = dstRow + x * 4;
+          rgba[di] = view.getUint8(off + 2);
+          rgba[di + 1] = view.getUint8(off + 1);
+          rgba[di + 2] = view.getUint8(off);
+          rgba[di + 3] = 255;
         }
-        ctx.closePath();
-        ctx.fill();
+        break;
       }
-      return true;
+      default:
+        return null;
     }
-    default:
-      return false;
   }
+  return rgba;
+}
+function wrapBmpFile(bmpData, bmpRowStride, width, height, pixelDataSize) {
+  const fileHeaderSize = 14;
+  const dibHeaderSize = 108;
+  const fileSize = fileHeaderSize + dibHeaderSize + pixelDataSize;
+  const bmpFile = new ArrayBuffer(fileSize);
+  const bmpView = new DataView(bmpFile);
+  const bmpBytes = new Uint8Array(bmpFile);
+  bmpView.setUint8(0, 66);
+  bmpView.setUint8(1, 77);
+  bmpView.setUint32(2, fileSize, true);
+  bmpView.setUint32(6, 0, true);
+  bmpView.setUint32(10, fileHeaderSize + dibHeaderSize, true);
+  bmpView.setUint32(14, dibHeaderSize, true);
+  bmpView.setInt32(18, width, true);
+  bmpView.setInt32(22, height, true);
+  bmpView.setUint16(26, 1, true);
+  bmpView.setUint16(28, 32, true);
+  bmpView.setUint32(30, 3, true);
+  bmpView.setUint32(34, pixelDataSize, true);
+  bmpView.setInt32(38, 2835, true);
+  bmpView.setInt32(42, 2835, true);
+  bmpView.setUint32(46, 0, true);
+  bmpView.setUint32(50, 0, true);
+  bmpView.setUint32(54, 16711680, true);
+  bmpView.setUint32(58, 65280, true);
+  bmpView.setUint32(62, 255, true);
+  bmpView.setUint32(66, 4278190080, true);
+  bmpView.setUint32(70, 1934772034, true);
+  bmpBytes.set(bmpData, fileHeaderSize + dibHeaderSize);
+  return bmpFile;
 }
 
 // src/emf-plus-brush-parser.ts
@@ -3216,6 +4723,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;
@@ -3236,8 +4744,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) {
@@ -3255,9 +4777,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 };
@@ -3290,6 +4814,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);
@@ -3303,8 +4828,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);
@@ -3316,7 +4841,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)
       }));
     }
   }
@@ -3338,15 +4864,75 @@ 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
     }
   };
 }
+function decodeTextureImage(view, off, end) {
+  if (off + 28 > end) {
+    return null;
+  }
+  const imageDataType = view.getUint32(off + 4, true);
+  if (imageDataType !== 1) {
+    return null;
+  }
+  const width = view.getInt32(off + 8, true);
+  const height = view.getInt32(off + 12, true);
+  const stride = view.getInt32(off + 16, true);
+  const pixelFormat = view.getUint32(off + 20, true);
+  const pixelStart = off + 28;
+  const absStride = Math.abs(stride);
+  if (width <= 0 || height <= 0 || width > 8192 || height > 8192 || pixelStart + absStride * height > end) {
+    return null;
+  }
+  const rgba = decodeEmfPlusBitmapPixelsToRgba(view, pixelStart, width, height, stride, pixelFormat);
+  return rgba ? { width, height, rgba } : null;
+}
+function parseTextureBrush(view, b, end) {
+  if (b + 8 > end) {
+    return null;
+  }
+  const flags = view.getUint32(b, true);
+  const wrapMode = readWrapMode(view.getUint32(b + 4, true));
+  let o = b + 8;
+  let transform = null;
+  if (flags & BRUSH_DATA_TRANSFORM && o + 24 <= end) {
+    transform = readTransform(view, o);
+    o += 24;
+  }
+  const image = decodeTextureImage(view, o, end);
+  if (!image) {
+    return null;
+  }
+  const texture = {
+    width: image.width,
+    height: image.height,
+    rgba: image.rgba,
+    wrapMode,
+    transform
+  };
+  let r = 0;
+  let g = 0;
+  let bl = 0;
+  const n = image.width * image.height;
+  for (let i = 0; i < n; i++) {
+    r += image.rgba[i * 4];
+    g += image.rgba[i * 4 + 1];
+    bl += image.rgba[i * 4 + 2];
+  }
+  const avg = n > 0 ? `rgba(${Math.round(r / n)},${Math.round(g / n)},${Math.round(bl / n)},1)` : "rgba(128,128,128,1)";
+  emfLog(`parseEmfPlusBrushObject: texture fill ${image.width}x${image.height}, wrapMode=${wrapMode}`);
+  return { kind: "plus-brush", color: avg, texture };
+}
 function parsePathGradient(view, b, end) {
   if (b + 24 > 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);
@@ -3361,6 +4947,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);
@@ -3368,7 +4956,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;
       }
@@ -3382,6 +4972,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;
     }
@@ -3391,31 +4982,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;
@@ -3425,14 +5035,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;
@@ -3453,6 +5134,10 @@ function parseEmfPlusBrushObject(view, dataOff, recDataSize) {
         return { kind: "plus-brush", color: argbToRgba(view.getUint32(b + 4, true)) };
       }
       return { kind: "plus-brush", color: "rgba(0,0,0,1)" };
+    case EMFPLUS_BRUSHTYPE_TEXTUREFILL: {
+      const brush = parseTextureBrush(view, b, end);
+      return brush ?? { 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)" };
@@ -3466,110 +5151,6 @@ function parseEmfPlusBrushObject(view, dataOff, recDataSize) {
   }
 }
 
-// src/emf-plus-bitmap-decoder.ts
-var PIXELFORMAT_24BPP_RGB = 137224;
-var PIXELFORMAT_32BPP_RGB = 139273;
-var PIXELFORMAT_32BPP_ARGB = 2498570;
-var PIXELFORMAT_32BPP_PARGB = 925707;
-function decodeEmfPlusBitmapPixels(view, pixelStart, width, height, stride, pixelFormat) {
-  const absStride = Math.abs(stride);
-  const topDown = stride > 0;
-  const rowBytes = width * 4;
-  const bmpRowStride = rowBytes + 3 & -4;
-  const pixelDataSize = bmpRowStride * height;
-  const bmpData = new Uint8Array(pixelDataSize);
-  for (let y = 0; y < height; y++) {
-    const srcRow = topDown ? y : height - 1 - y;
-    const rowOff = pixelStart + srcRow * absStride;
-    const dstRow = (height - 1 - y) * bmpRowStride;
-    switch (pixelFormat) {
-      case PIXELFORMAT_32BPP_ARGB:
-      case PIXELFORMAT_32BPP_PARGB: {
-        for (let x = 0; x < width; x++) {
-          const off = rowOff + x * 4;
-          if (off + 3 >= view.byteLength) {
-            break;
-          }
-          let b = view.getUint8(off);
-          let g = view.getUint8(off + 1);
-          let r = view.getUint8(off + 2);
-          const a = view.getUint8(off + 3);
-          if (pixelFormat === PIXELFORMAT_32BPP_PARGB && a > 0 && a < 255) {
-            r = Math.min(255, Math.round(r * 255 / a));
-            g = Math.min(255, Math.round(g * 255 / a));
-            b = Math.min(255, Math.round(b * 255 / a));
-          }
-          const di = dstRow + x * 4;
-          bmpData[di] = b;
-          bmpData[di + 1] = g;
-          bmpData[di + 2] = r;
-          bmpData[di + 3] = a;
-        }
-        break;
-      }
-      case PIXELFORMAT_32BPP_RGB: {
-        for (let x = 0; x < width; x++) {
-          const off = rowOff + x * 4;
-          if (off + 3 >= view.byteLength) {
-            break;
-          }
-          const di = dstRow + x * 4;
-          bmpData[di] = view.getUint8(off);
-          bmpData[di + 1] = view.getUint8(off + 1);
-          bmpData[di + 2] = view.getUint8(off + 2);
-          bmpData[di + 3] = 255;
-        }
-        break;
-      }
-      case PIXELFORMAT_24BPP_RGB: {
-        for (let x = 0; x < width; x++) {
-          const off = rowOff + x * 3;
-          if (off + 2 >= view.byteLength) {
-            break;
-          }
-          const di = dstRow + x * 4;
-          bmpData[di] = view.getUint8(off);
-          bmpData[di + 1] = view.getUint8(off + 1);
-          bmpData[di + 2] = view.getUint8(off + 2);
-          bmpData[di + 3] = 255;
-        }
-        break;
-      }
-      default:
-        return null;
-    }
-  }
-  const fileHeaderSize = 14;
-  const dibHeaderSize = 108;
-  const fileSize = fileHeaderSize + dibHeaderSize + pixelDataSize;
-  const bmpFile = new ArrayBuffer(fileSize);
-  const bmpView = new DataView(bmpFile);
-  const bmpBytes = new Uint8Array(bmpFile);
-  bmpView.setUint8(0, 66);
-  bmpView.setUint8(1, 77);
-  bmpView.setUint32(2, fileSize, true);
-  bmpView.setUint32(6, 0, true);
-  bmpView.setUint32(10, fileHeaderSize + dibHeaderSize, true);
-  bmpView.setUint32(14, dibHeaderSize, true);
-  bmpView.setInt32(18, width, true);
-  bmpView.setInt32(22, height, true);
-  bmpView.setUint16(26, 1, true);
-  bmpView.setUint16(28, 32, true);
-  bmpView.setUint32(30, 3, true);
-  bmpView.setUint32(34, pixelDataSize, true);
-  bmpView.setInt32(38, 2835, true);
-  bmpView.setInt32(42, 2835, true);
-  bmpView.setUint32(46, 0, true);
-  bmpView.setUint32(50, 0, true);
-  bmpView.setUint32(54, 16711680, true);
-  bmpView.setUint32(58, 65280, true);
-  bmpView.setUint32(62, 255, true);
-  bmpView.setUint32(66, 4278190080, true);
-  bmpView.setUint32(70, 1934772034, true);
-  bmpBytes.set(bmpData, fileHeaderSize + dibHeaderSize);
-  return bmpFile;
-}
-
 // src/emf-plus-object-complex.ts
 function parseEmfPlusPenObject(view, dataOff, recDataSize) {
   if (recDataSize < 20) {
@@ -4453,7 +6034,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;
     }
@@ -4848,8 +6429,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;
             }
@@ -4858,12 +6439,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;
@@ -4888,6 +6472,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;
             }
           }