emf-converter 3.1.0 → 3.2.0

package/dist/index.js

@@ -52,6 +52,428 @@ 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 = [];
@@ -237,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;
@@ -487,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;
   }
@@ -639,793 +1063,784 @@ async function exportCanvasToPngDataUrl(canvas) {
     emfLog(
       `exportCanvasToPngDataUrl: using HTMLCanvasElement.toDataURL (${canvas.width}\xD7${canvas.height})`
     );
-    return canvas.toDataURL("image/png");
-  }
-  if (nodeCanvasModule && canvas instanceof nodeCanvasModule.Canvas) {
-    emfLog(
-      `exportCanvasToPngDataUrl: using @napi-rs/canvas toDataURLAsync (${canvas.width}\xD7${canvas.height})`
-    );
-    return canvas.toDataURLAsync();
-  }
-  return null;
-}
-async function decodeDeferredImageBytes(bytes, mime) {
-  if (nodeCanvasModule) {
-    const image = await nodeCanvasModule.loadImage(new Uint8Array(bytes));
-    return { drawable: image, width: image.width, height: image.height, close: () => {
-    } };
-  }
-  if (typeof createImageBitmap !== "function") {
-    return null;
-  }
-  const blob = mime !== void 0 ? new Blob([bytes], { type: mime }) : new Blob([bytes]);
-  const bitmap = await createImageBitmap(blob);
-  return { drawable: bitmap, width: bitmap.width, height: bitmap.height, close: () => bitmap.close() };
-}
-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) {
-  emfLog("parseEmfHeader: byteLength =", view.byteLength);
-  if (view.byteLength < 88) {
-    return null;
-  }
-  const recordType = view.getUint32(0, true);
-  if (recordType !== EMR_HEADER) {
-    return null;
-  }
-  const boundsLeft = view.getInt32(8, true);
-  const boundsTop = view.getInt32(12, true);
-  const boundsRight = view.getInt32(16, true);
-  const boundsBottom = view.getInt32(20, true);
-  const frameLeft = view.getInt32(24, true);
-  const frameTop = view.getInt32(28, true);
-  const frameRight = view.getInt32(32, true);
-  const frameBottom = view.getInt32(36, true);
-  const frameW = frameRight - frameLeft;
-  const frameH = frameBottom - frameTop;
-  return {
-    bounds: {
-      left: boundsLeft,
-      top: boundsTop,
-      right: boundsRight,
-      bottom: boundsBottom
-    },
-    frameW,
-    frameH
-  };
-}
-function getRenderableEmfBounds(header) {
-  const boundsW = header.bounds.right - header.bounds.left;
-  const boundsH = header.bounds.bottom - header.bounds.top;
-  if (boundsW > 0 && boundsH > 0) {
-    return header.bounds;
-  }
-  if (header.frameW > 0 && header.frameH > 0) {
-    emfLog(
-      `getRenderableEmfBounds: bounds invalid (${boundsW}\xD7${boundsH}), falling back to frame ${header.frameW}\xD7${header.frameH}`
-    );
-    return { left: 0, top: 0, right: header.frameW, bottom: header.frameH };
-  }
-  return null;
-}
-function parseWmfHeader(view) {
-  if (view.byteLength < 22) {
-    return null;
-  }
-  const magic = view.getUint32(0, true);
-  let headerOffset = 0;
-  let boundsLeft = 0;
-  let boundsTop = 0;
-  let boundsRight = 800;
-  let boundsBottom = 600;
-  let unitsPerInch = 96;
-  if (magic === 2596720087) {
-    boundsLeft = view.getInt16(6, true);
-    boundsTop = view.getInt16(8, true);
-    boundsRight = view.getInt16(10, true);
-    boundsBottom = view.getInt16(12, true);
-    unitsPerInch = view.getUint16(14, true) || 96;
-    headerOffset = 22;
-  }
-  if (headerOffset + 18 > view.byteLength) {
-    return null;
-  }
-  const fileType = view.getUint16(headerOffset, true);
-  if (fileType !== 1 && fileType !== 2) {
-    return null;
-  }
-  const headerSize = view.getUint16(headerOffset + 2, true) * 2;
-  const maxRecordSize = view.getUint32(headerOffset + 8, true) * 2;
-  return {
-    headerSize: headerOffset + headerSize,
-    maxRecordSize,
-    boundsLeft,
-    boundsTop,
-    boundsRight,
-    boundsBottom,
-    unitsPerInch
-  };
-}
-
-// src/emf-gdi-coord.ts
-function gmx(r, x) {
-  const wt = r.state.worldTransform;
-  const px = wt[0] * x + wt[4];
-  if (r.useMappingMode) {
-    return (px - r.windowOrg.x) / (r.windowExt.cx || 1) * (r.viewportExt.cx || 1) + r.viewportOrg.x;
-  }
-  return (px - r.bounds.left) * r.sx;
-}
-function gmy(r, y) {
-  const wt = r.state.worldTransform;
-  const py = wt[3] * y + wt[5];
-  if (r.useMappingMode) {
-    return (py - r.windowOrg.y) / (r.windowExt.cy || 1) * (r.viewportExt.cy || 1) + r.viewportOrg.y;
-  }
-  return (py - r.bounds.top) * r.sy;
-}
-function gmw(r, w) {
-  const pw = r.state.worldTransform[0] * w;
-  if (r.useMappingMode) {
-    return pw / (r.windowExt.cx || 1) * (r.viewportExt.cx || 1);
-  }
-  return pw * r.sx;
-}
-function gmh(r, h) {
-  const ph = r.state.worldTransform[3] * h;
-  if (r.useMappingMode) {
-    return ph / (r.windowExt.cy || 1) * (r.viewportExt.cy || 1);
-  }
-  return ph * r.sy;
-}
-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 canvas.toDataURL("image/png");
   }
-  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));
-    }
+  if (nodeCanvasModule && canvas instanceof nodeCanvasModule.Canvas) {
+    emfLog(
+      `exportCanvasToPngDataUrl: using @napi-rs/canvas toDataURLAsync (${canvas.width}\xD7${canvas.height})`
+    );
+    return canvas.toDataURLAsync();
   }
-  return true;
+  return null;
 }
-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();
-    }
+async function decodeDeferredImageBytes(bytes, mime) {
+  if (nodeCanvasModule) {
+    const image = await nodeCanvasModule.loadImage(new Uint8Array(bytes));
+    return { drawable: image, width: image.width, height: image.height, close: () => {
+    } };
   }
-  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();
-    }
+  if (typeof createImageBitmap !== "function") {
+    return null;
   }
-  return true;
+  const blob = mime !== void 0 ? new Blob([bytes], { type: mime }) : new Blob([bytes]);
+  const bitmap = await createImageBitmap(blob);
+  return { drawable: bitmap, width: bitmap.width, height: bitmap.height, close: () => bitmap.close() };
 }
-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 canvasDrawImage(ctx, image, dx, dy, dw, dh) {
+  const draw = ctx.drawImage;
+  draw.call(ctx, image, dx, dy, dw, dh);
 }
-function handleEmfGdiShapeRecord(rCtx, recType, dataOff, recSize) {
-  switch (recType) {
-    case EMR_SETPIXELV:
-      return handleSetPixelV(rCtx, dataOff, recSize);
-    case EMR_MOVETOEX:
-      return handleMoveToEx(rCtx, dataOff, recSize);
-    case EMR_LINETO:
-      return handleLineTo(rCtx, dataOff, recSize);
-    case EMR_RECTANGLE:
-      return handleRectangle(rCtx, dataOff, recSize);
-    case EMR_ROUNDRECT:
-      return handleRoundRect(rCtx, dataOff, recSize);
-    case EMR_ELLIPSE:
-      return handleEllipse(rCtx, dataOff, recSize);
-    case EMR_ARC:
-    case EMR_ARCTO:
-    case EMR_CHORD:
-    case EMR_PIE:
-      return handleArcFamily(rCtx, recType, dataOff, recSize);
-    default:
-      return false;
+function 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-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++;
-      }
-    }
+// src/emf-header-parser.ts
+function parseEmfHeader(view) {
+  emfLog("parseEmfHeader: byteLength =", view.byteLength);
+  if (view.byteLength < 88) {
+    return null;
+  }
+  const recordType = view.getUint32(0, true);
+  if (recordType !== EMR_HEADER) {
+    return null;
+  }
+  const boundsLeft = view.getInt32(8, true);
+  const boundsTop = view.getInt32(12, true);
+  const boundsRight = view.getInt32(16, true);
+  const boundsBottom = view.getInt32(20, true);
+  const frameLeft = view.getInt32(24, true);
+  const frameTop = view.getInt32(28, true);
+  const frameRight = view.getInt32(32, true);
+  const frameBottom = view.getInt32(36, true);
+  const frameW = frameRight - frameLeft;
+  const frameH = frameBottom - frameTop;
+  return {
+    bounds: {
+      left: boundsLeft,
+      top: boundsTop,
+      right: boundsRight,
+      bottom: boundsBottom
+    },
+    frameW,
+    frameH
+  };
+}
+function getRenderableEmfBounds(header) {
+  const boundsW = header.bounds.right - header.bounds.left;
+  const boundsH = header.bounds.bottom - header.bounds.top;
+  if (boundsW > 0 && boundsH > 0) {
+    return header.bounds;
   }
-  return createImageDataCompat(
-    new Uint8ClampedArray(out.buffer, out.byteOffset, out.byteLength),
-    width,
-    height
-  );
+  if (header.frameW > 0 && header.frameH > 0) {
+    emfLog(
+      `getRenderableEmfBounds: bounds invalid (${boundsW}\xD7${boundsH}), falling back to frame ${header.frameW}\xD7${header.frameH}`
+    );
+    return { left: 0, top: 0, right: header.frameW, bottom: header.frameH };
+  }
+  return null;
+}
+function parseWmfHeader(view) {
+  if (view.byteLength < 22) {
+    return null;
+  }
+  const magic = view.getUint32(0, true);
+  let headerOffset = 0;
+  let boundsLeft = 0;
+  let boundsTop = 0;
+  let boundsRight = 800;
+  let boundsBottom = 600;
+  let unitsPerInch = 96;
+  if (magic === 2596720087) {
+    boundsLeft = view.getInt16(6, true);
+    boundsTop = view.getInt16(8, true);
+    boundsRight = view.getInt16(10, true);
+    boundsBottom = view.getInt16(12, true);
+    unitsPerInch = view.getUint16(14, true) || 96;
+    headerOffset = 22;
+  }
+  if (headerOffset + 18 > view.byteLength) {
+    return null;
+  }
+  const fileType = view.getUint16(headerOffset, true);
+  if (fileType !== 1 && fileType !== 2) {
+    return null;
+  }
+  const headerSize = view.getUint16(headerOffset + 2, true) * 2;
+  const maxRecordSize = view.getUint32(headerOffset + 8, true) * 2;
+  return {
+    headerSize: headerOffset + headerSize,
+    maxRecordSize,
+    boundsLeft,
+    boundsTop,
+    boundsRight,
+    boundsBottom,
+    unitsPerInch
+  };
 }
 
-// src/emf-dib-uncompressed.ts
-function countTrailingZeros(v) {
-  if (v === 0) {
-    return 0;
+// src/emf-gdi-coord.ts
+function gmx(r, x) {
+  const wt = r.state.worldTransform;
+  const px = wt[0] * x + wt[4];
+  if (r.useMappingMode) {
+    return (px - r.windowOrg.x) / (r.windowExt.cx || 1) * (r.viewportExt.cx || 1) + r.viewportOrg.x;
   }
-  let c = 0;
-  let val = v;
-  while ((val & 1) === 0) {
-    val >>>= 1;
-    c++;
+  return (px - r.bounds.left) * r.sx;
+}
+function gmy(r, y) {
+  const wt = r.state.worldTransform;
+  const py = wt[3] * y + wt[5];
+  if (r.useMappingMode) {
+    return (py - r.windowOrg.y) / (r.windowExt.cy || 1) * (r.viewportExt.cy || 1) + r.viewportOrg.y;
   }
-  return c;
+  return (py - r.bounds.top) * r.sy;
 }
-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;
+function gmw(r, w) {
+  const pw = r.state.worldTransform[0] * w;
+  if (r.useMappingMode) {
+    return pw / (r.windowExt.cx || 1) * (r.viewportExt.cx || 1);
   }
-  return { rMask, gMask, bMask, rShift, gShift, bShift, rMax, gMax, bMax };
+  return pw * r.sx;
 }
-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;
+function gmh(r, h) {
+  const ph = r.state.worldTransform[3] * h;
+  if (r.useMappingMode) {
+    return ph / (r.windowExt.cy || 1) * (r.viewportExt.cy || 1);
+  }
+  return ph * r.sy;
+}
+function activateGdiMappingMode(r) {
+  r.useMappingMode = true;
+}
+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
+  };
+}
+
+// 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);
     }
-    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;
-      }
+  }
+  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;
     }
   }
 }
-
-// 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) {
+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;
   }
-  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;
+  return { x: left, y: top, w: width, h: height };
+}
+
+// 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 packRgb(r, g, b) {
+  return r << 16 | g << 8 | b;
+}
+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;
   }
-  if (width > 8192 || Math.abs(heightRaw) > 8192) {
-    return null;
+  const size = surfaceSize(ctx);
+  if (!size) {
+    return false;
   }
-  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;
+  try {
+    const temp = createTempCanvas(size.w, size.h);
+    if (!temp) {
+      return 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;
+      }
+      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;
   }
-  if (compression === BI_RLE8 && bitCount !== 8) {
-    return null;
+}
+
+// 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;
   }
-  if (compression === BI_RLE4 && bitCount !== 4) {
-    return null;
+  const size = surfaceSize2(ctx);
+  if (!size || typeof ctx.isPointInPath !== "function") {
+    return false;
   }
-  if (compression === BI_BITFIELDS2 && bitCount !== 16 && bitCount !== 32) {
-    return null;
+  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;
+        }
+        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;
+      }
+    }
+    canvasPutImageData(ctx, img, 0, 0);
+    return true;
+  } catch {
+    return false;
   }
-  if (compression !== BI_RGB && compression !== BI_RLE8 && compression !== BI_RLE4 && compression !== BI_BITFIELDS2) {
-    return null;
+}
+function fillShapeExactOrFast(rCtx, buildPath, fillRule = "nonzero") {
+  const { ctx, state } = rCtx;
+  if (state.brushStyle === 1) {
+    return;
   }
-  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;
+  if (realizeBrush(state).kind === "tile") {
+    if (fillCurrentPathWithGdiPattern(rCtx, fillRule)) {
+      return;
     }
-    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]);
+  } 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;
+      }
     }
   }
-  const masks = parseBitfieldMasks(view, bmiOffset, headerSize, compression, bitCount);
-  if (!masks) {
-    return null;
+  applyBrush(ctx, state);
+  ctx.fill(fillRule);
+}
+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;
   }
-  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
-    );
+}
+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;
+    }
   }
-  decodeUncompressedRows(
-    view,
-    bitsOffset,
-    width,
-    height,
-    topDown,
-    bitCount,
-    colorTable,
-    masks,
-    out
-  );
-  return createImageDataCompat(out, width, height);
+  applyPen(ctx, state);
+  ctx.stroke();
 }
 
-// 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;
+// 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 cssHexToRgb(color) {
-  const m = /^#([0-9a-f]{6}|[0-9a-f]{3})$/i.exec(color.trim());
-  if (!m) {
-    return 0;
+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);
   }
-  const hex = m[1].length === 3 ? m[1].replace(/./g, (c) => c + c) : m[1];
-  return parseInt(hex, 16);
+  return true;
 }
-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;
+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);
+    }
   }
-  const stride = (width + 31 >> 5) * 4;
-  if (bitsOffset + stride * height > view.byteLength) {
-    return null;
+  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);
+    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;
   }
-  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 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);
+      }
     }
   }
-  return { width, height, bits };
+  return true;
 }
-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 };
+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);
+        }
+      } else {
+        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 build = (c) => {
+        c.beginPath();
+        drawRoundRect(c);
+      };
+      build(ctx);
+      fillShapeExactOrFast(rCtx, build);
+      strokeShapeExactOrFast(rCtx, build);
     }
   }
-  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 };
+  return true;
 }
-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 };
+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);
+    }
   }
-  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 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 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;
     }
-    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 };
+  return true;
 }
-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];
+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
@@ -1480,108 +1895,25 @@ function stretchGdi(src, sx, sy, sw, sh, dw, dh, mode) {
       let first = true;
       for (const yy of ys) {
         for (const xx of xs) {
-          const p = read(xx, yy);
-          if (mode === BLACKONWHITE) {
-            v &= p;
-          } else if (mode === WHITEONBLACK) {
-            v |= p;
-          } else if (first) {
-            v = p;
-          }
-          first = false;
-        }
-      }
-      const o = (y * W + x) * 4;
-      data[o] = v >> 16 & 255;
-      data[o + 1] = v >> 8 & 255;
-      data[o + 2] = v & 255;
-      data[o + 3] = 255;
-    }
-  }
-  return { width: W, height: H, data };
-}
-
-// src/emf-rop3.ts
-function rop3Index(rop) {
-  return rop >>> 16 & 255;
-}
-function rop3Operands(index) {
-  const t = index & 255;
-  return {
-    usesP: (t >> 4 & 15) !== (t & 15),
-    usesS: (t >> 2 & 51) !== (t & 51),
-    usesD: (t >> 1 & 85) !== (t & 85)
-  };
-}
-function evalRop3(index, p, s, d, mask = 16777215) {
-  let out = 0;
-  const np = ~p;
-  const ns = ~s;
-  const nd = ~d;
-  for (let i = 0; i < 8; i++) {
-    if (index & 1 << i) {
-      out |= (i & 4 ? p : np) & (i & 2 ? s : ns) & (i & 1 ? d : nd);
-    }
-  }
-  return out & mask;
-}
-function classifyRop3(rop) {
-  const index = rop3Index(rop);
-  switch (index) {
-    case 204:
-      return { kind: "copy" };
-    case 0:
-      return { kind: "solid", color: "black" };
-    case 255:
-      return { kind: "solid", color: "white" };
-    case 170:
-      return { kind: "noop" };
-    case 85:
-      return { kind: "invert-dest" };
-    default:
-      return { kind: "ternary", index, operands: rop3Operands(index) };
-  }
-}
-function applyRop3(dst, src, pattern, index, originX, originY) {
-  const d = dst.data;
-  const s = src ? src.data : null;
-  const w = dst.width;
-  const h = dst.height;
-  const solidP = typeof pattern === "number" ? pattern : 0;
-  const sampleP = typeof pattern === "function" ? pattern : null;
-  for (let y = 0; y < h; y++) {
-    for (let x = 0; x < w; x++) {
-      const i = (y * w + x) * 4;
-      const dv = d[i] << 16 | d[i + 1] << 8 | d[i + 2];
-      const sv = s ? s[i] << 16 | s[i + 1] << 8 | s[i + 2] : 0;
-      const pv = sampleP ? sampleP(originX + x, originY + y) : solidP;
-      const r = evalRop3(index, pv, sv, dv);
-      d[i] = r >> 16 & 255;
-      d[i + 1] = r >> 8 & 255;
-      d[i + 2] = r & 255;
-      d[i + 3] = 255;
-    }
-  }
-}
-function clampPositiveRect(x, y, w, h, canvasW, canvasH) {
-  let left = w < 0 ? x + w : x;
-  let top = h < 0 ? y + h : y;
-  let width = Math.abs(w);
-  let height = Math.abs(h);
-  left = Math.round(left);
-  top = Math.round(top);
-  width = Math.round(width);
-  height = Math.round(height);
-  const right = Math.min(left + width, Math.round(canvasW));
-  const bottom = Math.min(top + height, Math.round(canvasH));
-  left = Math.max(left, 0);
-  top = Math.max(top, 0);
-  width = right - left;
-  height = bottom - top;
-  if (width <= 0 || height <= 0) {
-    return null;
+          const p = read(xx, yy);
+          if (mode === BLACKONWHITE) {
+            v &= p;
+          } else if (mode === WHITEONBLACK) {
+            v |= p;
+          } else if (first) {
+            v = p;
+          }
+          first = false;
+        }
+      }
+      const o = (y * W + x) * 4;
+      data[o] = v >> 16 & 255;
+      data[o + 1] = v >> 8 & 255;
+      data[o + 2] = v & 255;
+      data[o + 3] = 255;
+    }
   }
-  return { x: left, y: top, w: width, h: height };
+  return { width: W, height: H, data };
 }
 
 // src/emf-gdi-draw-bitmap.ts
@@ -2317,6 +2649,25 @@ function handleEmfGdiDrawRecord(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);
@@ -2329,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) {
@@ -2366,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) {
@@ -2400,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);
   }
 }
 
@@ -2440,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;
@@ -2498,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;
@@ -2587,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();
@@ -3313,14 +3652,14 @@ function plainLinear(ctx, grad) {
 }
 var SEAM_BIAS = 1e-5;
 var MAX_PERIODS = 2048;
-function surfaceSize(ctx) {
+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 = surfaceSize(ctx);
+  const size = surfaceSize3(ctx);
   const inv = invertLinear(device);
   if (!size || !inv || typeof ctx.createLinearGradient !== "function") {
     return null;
@@ -3462,6 +3801,42 @@ function createBrushGradient(ctx, grad, device = IDENTITY) {
   }
 }
 
+// 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) {
@@ -3608,6 +3983,12 @@ function resolveBrushPaint(rCtx, flags, brushIdOrColor) {
         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)";
@@ -4103,64 +4484,238 @@ function handleEmfPlusDrawRecord(rCtx, recType, recFlags, dataOff, recDataSize)
       } else {
         ctx.stroke();
       }
-      return true;
+      return true;
+    }
+    case EMFPLUS_DRAWLINES: {
+      if (recDataSize >= 4) {
+        const penId = recFlags & 255;
+        const pen = objectTable.get(penId);
+        const count = view.getUint32(dataOff, true);
+        const compressed = (recFlags & 16384) !== 0;
+        const ptSize = compressed ? 4 : 8;
+        if (pen && pen.kind === "plus-pen") {
+          applyEmfPlusPen(ctx, pen);
+        }
+        applyPlusWorldTransform(rCtx);
+        ctx.beginPath();
+        let pOff = dataOff + 4;
+        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;
+        }
+        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;
     }
-    case EMFPLUS_DRAWLINES: {
-      if (recDataSize >= 4) {
-        const penId = recFlags & 255;
-        const pen = objectTable.get(penId);
-        const count = view.getUint32(dataOff, true);
-        const compressed = (recFlags & 16384) !== 0;
-        const ptSize = compressed ? 4 : 8;
-        if (pen && pen.kind === "plus-pen") {
-          applyEmfPlusPen(ctx, pen);
-        }
-        applyPlusWorldTransform(rCtx);
-        ctx.beginPath();
-        let pOff = dataOff + 4;
-        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);
+  }
+  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;
           }
-          pOff += ptSize;
+          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
@@ -4316,6 +4871,62 @@ function parseLinearGradient(view, b, end) {
     }
   };
 }
+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;
@@ -4523,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)" };
@@ -4536,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) {