emf-converter 4.8.19 → 4.8.21

package/README.md

@@ -18,15 +18,6 @@ Windows metafiles are recorded GDI and GDI+ drawing calls, commonly embedded in
 
 ---
 
-## What's new
-
-- **SVG output**: `convertMetafileToSvg`, `convertMetafileToSvgDataUrl`, `convertMetafileToSvgTree` + `svgTreeToReact` / `svgTreeToJsx` for JSX/TSX.
-- **Windows-exact PNG by default**: GDI shapes are drawn by a rasteriser fitted to Windows GDI (28.4 fixed-point geometry, GDI's fill rule, line algorithm, ellipse and Bezier construction, wide pens, dash styles), and EMF+ drawing follows the file's recorded GDI+ `SmoothingMode` with GDI+'s own rasteriser. **Breaking:** default PNG output is no longer Canvas-antialiased; pass `gdiAntialias: true` for the previous smooth edges.
-- **Exact text with the `fonts` option**: a built-in TrueType engine (hinting interpreter, dropout control, GDI font mapping and metrics, grayscale and ClearType) plus Windows raster `.fon` fonts. `loadSystemFonts()` reads the installed fonts in Node.js.
-- **No canvas required**: a built-in pure-JavaScript rasteriser renders SVG anywhere and PNG for drawings without text; `@napi-rs/canvas` is only needed for PNG output with text in plain Node.js.
-- **Complete WMF playback**: bitmaps, clipping, regions, mapping modes, palettes, flood fills, and embedded EMF comments, played as Windows' `PlayMetaFile` plays them.
-- Many correctness fixes found by the new fixtures (see the changelog).
-
 ## Documentation and demo
 
 The documentation site at **https://christophervr.github.io/emf-converter/** includes a live demo: drop an `.emf` or `.wmf` file to see the PNG or SVG output, download it, or copy it as a TSX component.
@@ -192,35 +183,15 @@ Node.js only (returns `[]` elsewhere; the package stays browser-safe). Reads the
 
 ## How it works
 
-A three-phase pipeline: **parse → replay → export**. The header parser reads the drawing bounds (a placeable WMF is sized from its header's units per inch), the output surface is created (clamped to `maxCanvasDimension`), and the records are replayed in order by the GDI, EMF+ or WMF handlers. PNG output draws onto a Canvas (OffscreenCanvas, HTMLCanvasElement, `@napi-rs/canvas`, or the built-in pure-JavaScript rasteriser); SVG output draws onto `SvgContext`, a recorder implementing the part of the Canvas 2D API the replay uses, mirrored onto a hidden raster wherever a raster operation must read the destination.
-
-Everything below is verified against output painted by Windows itself; `src/gdi-parity.fixture.test.ts` holds the per-fixture bounds.
-
-- **GDI shapes** (`gdi-raster.ts`, `gdi-raster-widen.ts`): 28.4 fixed-point geometry; GDI's fill rule (ALTERNATE/WINDING); one-pixel lines by GDI's diamond rule with its tie-breaks; GDI's own Bezier flattener, ellipse, rounded-rectangle, arc (GDI's trigonometry table and `SetArcDirection`), chord and pie construction; cosmetic dash styles (dash 18/6, dot 3/3, ...) and geometric dashes; wide pens widened from GDI's own pen polygons with every cap and join and the miter limit; rotated and skewed world transforms. Pixel-exact on the shape fixtures. A path bracket's GDI geometry has the points, point types, figure starts and direction that Windows' `GetPath` reports (checked against the Windows data in Wine's `gdi32` path tests).
-- **Raster operations**: all 256 ROP3 codes for `BitBlt`/`StretchBlt`/`StretchDIBits`/`PatBlt`, exact per bit against the destination, brush and source, with GDI's stretch modes, mirrored rectangles and rotated destinations (each device pixel mapped back to one source texel). Every `SetROP2` mode, including the bitwise AND/OR/XOR family, for shapes, paths and pattern-brush fills.
-- **Brushes**: hatch, monochrome and DIB pattern brushes anchored to the brush origin, with the background mode; GDI+ solid, hatch, texture (bilinear, WrapMode-aware, as GDI+ samples them), linear gradients (GDI+'s own interpolation table: preset colours, blend shapes, gamma correction, every WrapMode) and path gradients (true boundary-shaped falloff, every WrapMode).
-- **Clipping**: every GDI and GDI+ region combine mode exact for every clip (vector where possible, otherwise scan-converted to pixel regions, which is how GDI stores them), path clips with their fill mode, and region offsets.
-- **EMF+**: fills, pens and clips follow the recorded `SmoothingMode` with GDI+'s own fill rasteriser (8 x 4-sample antialiasing, blend arithmetic) and pen widener (joins, caps, dash caps, compound lines, inset alignment); `DrawImage` with every InterpolationMode/PixelOffsetMode kernel, ImageAttributes wrap modes, drawn in record order under the live clip; embedded metafiles replayed as vectors; continuation records reassembled; compressed textures and images decoded before replay.
-- **Text**: see [Exact text](#exact-text).
-- **WMF**: `PS_INSIDEFRAME` half-pixel width sweeps and mirrored line fixtures match Windows exactly; scaled shapes retain a small residual. Metric map modes default to a 96 dpi reference device; `wmfReferenceDpi` accepts a scalar or `{ x, y }` to reproduce another device.
-
-### Supported records
+A three-phase pipeline: **parse → replay → export**. Records are replayed by the GDI, EMF+ or WMF handlers onto a Canvas (or the built-in pure-JavaScript rasteriser) for PNG, or onto a recording context for SVG. GDI and GDI+ shapes, raster operations, brushes, clipping, text and WMF playback are all fitted to output painted by Windows itself.
 
-- **EMF**: Record playback includes logical palettes (`PALETTEINDEX`, `DIBPALETTEINDEX`, `PALETTERGB`, `DIB_PAL_COLORS`), `EMR_ALPHABLEND` (Windows' exact integer blend), `EMR_TRANSPARENTBLT`, `EMR_MASKBLT`, `EMR_PLGBLT`, `EMR_SETDIBITSTODEVICE`, `EMR_GRADIENTFILL` (rectangles and triangles), `EMR_FILLRGN` / `EMR_FRAMERGN` / `EMR_INVERTRGN` / `EMR_PAINTRGN`, `EMR_EXTFLOODFILL`, `EMR_ANGLEARC`, `EMR_POLYDRAW(16)`, `EMR_FLATTENPATH` / `EMR_WIDENPATH` / `EMR_ABORTPATH`, alongside shapes, paths, `EMR_EXTTEXTOUTA/W`, `EMR_POLYTEXTOUTA/W`, `EMR_SMALLTEXTOUT`, text justification, blits, clipping and transforms. Colour space, ICM, OpenGL, escape and font-driver records are consumed without effect, as on a Windows display.
-- **EMF+**: every record in MS-EMFPLUS (Beziers, cardinal curves, regions, containers, save/restore, compositing mode, rendering origin, text contrast, `StrokeFillPath`, the terminal-server `SetTSGraphics` / `SetTSClip`, `MultiFormat*` played as GDI+ plays them), with 32-bit, compressed 16-bit and relative point data, and every object type (solid, hatch, texture and gradient brushes; pens with caps, joins, dash styles, dash caps, compound lines and custom line caps; paths, regions, bitmap and metafile images, fonts, string formats, image attributes). Several encodings follow what GDI+ actually does where it differs from MS-EMFPLUS (relative points, `StrokeFillPath`, `SetTSGraphics`, `SetTSClip`).
-- **WMF**: META_ANIMATEPALETTE, META_ARC, META_BITBLT, META_CHORD, META_CREATEBITMAP, META_CREATEBITMAPINDIRECT, META_CREATEBRUSH, META_CREATEBRUSHINDIRECT, META_CREATEFONTINDIRECT, META_CREATEPALETTE, META_CREATEPATTERNBRUSH, META_CREATEPENINDIRECT, META_CREATEREGION, META_DELETEOBJECT, META_DIBBITBLT, META_DIBCREATEPATTERNBRUSH, META_DIBSTRETCHBLT, META_ELLIPSE, META_EOF, META_ESCAPE, META_EXCLUDECLIPRECT, META_EXTFLOODFILL, META_EXTTEXTOUT, META_FILLREGION, META_FLOODFILL, META_FRAMEREGION, META_INTERSECTCLIPRECT, META_INVERTREGION, META_LINETO, META_MOVETO, META_OFFSETCLIPRGN, META_OFFSETVIEWPORTORG, META_OFFSETWINDOWORG, META_PAINTREGION, META_PATBLT, META_PIE, META_POLYGON, META_POLYLINE, META_POLYPOLYGON, META_REALIZEPALETTE, META_RECTANGLE, META_RESIZEPALETTE, META_RESTOREDC, META_ROUNDRECT, META_SAVEDC, META_SCALEVIEWPORTEXT, META_SCALEWINDOWEXT, META_SELECTCLIPREGION, META_SELECTOBJECT, META_SELECTPALETTE, META_SETBKCOLOR, META_SETBKMODE, META_SETDIBTODEV, META_SETLAYOUT, META_SETMAPMODE, META_SETMAPPERFLAGS, META_SETPALENTRIES, META_SETPIXEL, META_SETPOLYFILLMODE, META_SETRELABS, META_SETROP2, META_SETSTRETCHBLTMODE, META_SETTEXTALIGN, META_SETTEXTCHAREXTRA, META_SETTEXTCOLOR, META_SETTEXTJUSTIFICATION, META_SETVIEWPORTEXT, META_SETVIEWPORTORG, META_SETWINDOWEXT, META_SETWINDOWORG, META_STRETCHBLT, META_STRETCHDIB, META_TEXTOUT. Where Windows no longer plays a record the way MS-WMF describes it (Win16 device bitmaps in META_BITBLT / META_STRETCHBLT, META_CREATEPATTERNBRUSH, banded META_SETDIBTODEV), the converter follows Windows.
+See [How it works](docs/how-it-works.md) for the pipeline, the Windows-parity details and the full list of supported records.
 
 ## Limitations
 
-Everything is measured against output painted by Windows itself; `src/gdi-parity.fixture.test.ts` holds the exact per-fixture bounds. Open work items are tracked in [docs/outstanding-work.md](docs/outstanding-work.md).
+Everything is measured against output painted by Windows itself, and a few areas still differ from it: some image effects, text with ClearType and EMF+ antialiasing, nonuniform wide-pen nibs, and rotated bicubic `DrawImage` sampling. Metric WMF map modes assume a 96 dpi device unless you pass `wmfReferenceDpi`.
 
-- **Colour adjustment and image effects**: all eleven EMF+ image effects are supported. Complete native tables cover every legal ColorCurve intensity. Deferred draws retain their effects. JPEG, GIF and TIFF have bundled decoders for environments without Canvas. Blur, sharpen, HSL and tint match the native algorithm captures; red-eye and GDI colour adjustment retain measured differences. Passing playback tolerances does not always mean pixel-exact output; see [the detailed limitations](docs/limitations.md) and [parity priorities](docs/outstanding-work.md).
-- **Pen transforms**: EMF+ pen transforms (uniform, nonuniform and skewed) match GDI+ exactly on the 17 pen-transform fixtures, including dashes, which GDI+ lays out along the path in world space at the untransformed pen width. Native fixtures verify dashes under both uniform and non-uniform scales. GDI+ rejects singular pen transforms; the converter ignores such malformed transform data. Square, round, diamond and arrow anchor caps use their native shapes; the new centered-cap fixtures match every pixel with and without antialiasing.
-- **Text**: ANSI, multi-string and small-text records render with residuals under 0.1% on their record fixtures. The broader font-engine fixtures still have larger ClearType, EMF+ antialiasing and TextContrast differences. ANSI decoding uses the host's `TextDecoder` for common Windows code pages; Johab and OEM CP437 use bundled Windows mappings. Vertical `ETO_PDY` advances work with and without the `fonts` engine. Without `fonts`, SVG text measurements use deterministic estimates, so precise justification requires supplying the matching fonts.
-- **Wide pens and paths**: the 2,136 native wide-path fills and widened ellipse outlines, including their inner triangles, match exactly. Square-capped curves, line-to-curve joins, fractional transformed inside-frame geometry and nonuniform GDI pen nibs remain open. EMF+ 1-pixel antialiased lines can differ by one sample at their ends; additional closed-figure Inset and compound-pen captures are still needed.
-- **GM_COMPATIBLE recordings**: EMF files do not record the graphics mode, and Windows plays RoundRect, Arc, Chord, Pie and null-pen Ellipse records back differently from how a GM_COMPATIBLE application drew them on screen; the converter follows Windows' playback.
-- **EMF+ sampling**: rotated `HighQualityBicubic` `DrawImage` retains 0.013% of pixels beyond eight channel levels, with more widespread small sampling differences in interpolation and path gradients. Linear `Blend` tables and the nested-metafile scale/clip fixtures now match exactly.
-- **WMF**: inside-frame half-pixel width sweeps and mirrored `LAYOUT_RTL` line fixtures match exactly; scaled shapes retain seven pixels in the current fixture. Metric map modes default to a 96 dpi reference device; supply `wmfReferenceDpi` when the original resolution is known.
+See [Limitations](docs/limitations.md) for the details and [Outstanding work](docs/outstanding-work.md) for what is still open.
 
 ## License
 

package/dist/browser.js

@@ -11661,11 +11661,20 @@ function ellipseBeziersBox(box, clockwise = false) {
   if (!clockwise) {
     return ellipsePoints(box, false);
   }
-  const e = clockwiseEllipseBeziersBox(box);
+  const { halfX, ...plain } = box;
+  const e = clockwiseEllipseBeziersBox(plain);
   const out = [];
   for (let i = e.length - 2; i >= 0; i -= 2) {
     out.push(e[i], e[i + 1]);
   }
+  const odd = Math.abs(plain.exx) % 2;
+  out[18] += odd;
+  out[6] -= odd;
+  if (halfX) {
+    for (const k of [0, 1, 2, 3, 4, 5, 12]) {
+      out[2 * k]++;
+    }
+  }
   return out;
 }
 function clockwiseEllipseBeziersBox(box) {
@@ -11681,10 +11690,10 @@ function ellipsePoints(box, cwControls) {
   const vMidHi = (v) => half(v, true);
   const vCtl = (v) => Math.floor(v / 2) - Math.floor(KAPPA * Math.floor(v / 2));
   const vCtlR = (v) => v - vCtl(v);
-  const vDist = (v) => Math.ceil(KAPPA * Math.floor(v / 2));
-  const rightUpper = cwControls ? (v) => vMidHi(v) - vDist(v) : vCtl;
+  const vDist = (v) => v % 2 === 0 ? Math.ceil(KAPPA * Math.floor(v / 2)) : Math.floor(KAPPA * Math.ceil(v / 2));
+  const rightUpper = cwControls ? (v) => vMidLo(v) - vDist(v) : vCtl;
   const leftUpper = cwControls ? (v) => vMidLo(v) - vDist(v) : vCtl;
-  const leftLower = cwControls ? (v) => vMidLo(v) + vDist(v) : vCtlR;
+  const leftLower = cwControls ? (v) => vMidHi(v) + vDist(v) : vCtlR;
   const rightLower = cwControls ? (v) => vMidHi(v) + vDist(v) : vCtlR;
   const zero = () => 0;
   const full = (v) => v;
@@ -11926,7 +11935,7 @@ function unitPiece(from, to, small) {
   }
   return { start: p0, ctrl };
 }
-function arcBeziers(l, t, r, b, xs, ys, xe, ye, clockwise) {
+function arcBeziers(l, t, r, b, xs, ys, xe, ye, clockwise, halfX = false, framed = false) {
   const w = r - l;
   const h = b - t;
   const Q = Math.PI / 2;
@@ -11946,11 +11955,25 @@ function arcBeziers(l, t, r, b, xs, ys, xe, ye, clockwise) {
   } else {
     while (a1 >= a0) a1 -= 2 * Math.PI;
   }
-  const px = (u) => Math.round(cx + rx * u);
+  const px = (u, v) => clockwise && halfX ? Math.ceil(cx + rx * u + 0.5 - v) : Math.round(cx + rx * u + (halfX ? 1 + v : 0));
   const py = (v) => Math.round(cy - ry * v);
-  const E = clockwise ? clockwiseEllipseBeziersBox(axisBox(l, t, r, b)) : ellipseBeziers(l, t, r, b);
+  const eb = axisBox(l, t, r, b);
+  if (halfX) eb.halfX = true;
+  const E = ellipseBeziersBox(eb);
+  if (clockwise) {
+    const cwPts = ellipseBeziersBox(eb, true);
+    for (let i = 0; i < cwPts.length; i += 2) {
+      E[cwPts.length - 2 - i] = cwPts[i];
+      E[cwPts.length - 1 - i] = cwPts[i + 1];
+    }
+  }
   const startUnit = small ? [Math.cos(a0), Math.sin(a0)] : polygonTrig(a0);
-  const out = [px(startUnit[0]), py(startUnit[1])];
+  const out = [px(startUnit[0], startUnit[1]), py(startUnit[1])];
+  const onAxis = (angle2) => Math.abs(angle2 / Q - Math.round(angle2 / Q)) < 1e-9;
+  const axisQuadrant = (angle2) => (Math.round(angle2 / Q) % 4 + 4) % 4;
+  if (framed && onAxis(a0) && (s > 0 ? axisQuadrant(a0) === 1 || axisQuadrant(a0) === 2 : axisQuadrant(a0) === 2 || axisQuadrant(a0) === 3)) {
+    out.push(out[0], out[1], out[0], out[1], out[0], out[1]);
+  }
   let a = a0;
   for (let guard = 0; guard < 8 && (s > 0 ? a < a1 - 1e-12 : a > a1 + 1e-12); guard++) {
     const next = s > 0 ? Math.floor(a / Q + 1e-9) * Q + Q : Math.ceil(a / Q - 1e-9) * Q - Q;
@@ -11972,10 +11995,16 @@ function arcBeziers(l, t, r, b, xs, ys, xe, ye, clockwise) {
     const e = s > 0 ? Math.min(next, a1) : Math.max(next, a1);
     const piece = unitPiece(a, e, small);
     for (let i = 0; i < 6; i += 2) {
-      out.push(px(piece.ctrl[i]), py(piece.ctrl[i + 1]));
+      out.push(px(piece.ctrl[i], piece.ctrl[i + 1]), py(piece.ctrl[i + 1]));
     }
     a = e;
   }
+  if (framed && onAxis(a1) && (s > 0 ? axisQuadrant(a1) === 3 || axisQuadrant(a1) === 0 : axisQuadrant(a1) === 1 || axisQuadrant(a1) === 0)) {
+    const endUnit = polygonTrig(a1);
+    const ex = px(endUnit[0], endUnit[1]);
+    const ey = py(endUnit[1]);
+    out.push(ex, ey, ex, ey, ex, ey);
+  }
   return out;
 }
 var GdiRasterPath = class {
@@ -29793,6 +29822,10 @@ function flipBox(box) {
 }
 function rectRasterPath(box, clockwise = false) {
   const c = boxCorners(clockwise ? flipBox(box) : box);
+  if (box.halfXRect) {
+    c[4]--;
+    c[6]--;
+  }
   const path = new GdiRasterPath();
   path.moveTo(c[0], c[1]);
   path.lineTo(c[2], c[3]);
@@ -29839,8 +29872,49 @@ function roundRectDeviceBeziers(box, cw, ch, clockwise = false, compatible = fal
     pts.push(...map(q[i], clockwise ? f.t + f.b - q[i + 1] : q[i + 1]));
   }
   if (box.halfX) {
-    for (const k of [1, 2, 3, 4, 5, 6, 8, 15]) {
-      pts[2 * k]++;
+    if (box.halfXCompat || !clockwise) {
+      const cy = (f.t + f.b) / 2;
+      const ry = (f.b - f.t) / 2 || 1;
+      for (let k = 0; k < 16; k++) {
+        const v = (cy - pts[2 * k + 1]) / ry;
+        pts[2 * k] += k >= 8 ? Math.round(1 + v) : Math.ceil(v - 0.5);
+      }
+    } else {
+      const tall = box.cornerExact !== void 0 && box.cornerExact[1] * 2 >= Math.abs(box.eyy) - 1e-9;
+      for (const k of tall ? [1, 2, 3, 4, 5, 6, 8, 15] : [0, 1, 2, 3, 4, 5, 6, 7]) {
+        pts[2 * k]++;
+      }
+    }
+  }
+  if (box.cornerExact && isAxisBox(box)) {
+    const w = f.r - f.l;
+    const h = f.b - f.t;
+    if (w >= 0 && h >= 0) {
+      const hx = w === 0 ? 0 : Math.round(box.cornerExact[0] * (w + w % 2) / w / 2);
+      const hy = h === 0 ? 0 : Math.round(box.cornerExact[1] * (clockwise ? h + h % 2 : h - h % 2) / h / 2);
+      const hc = Math.ceil(KAPPA * hx);
+      const vc = clockwise ? Math.ceil(KAPPA * hy) : Math.floor(KAPPA * hy);
+      const set = (k, x, y) => {
+        if (x !== null) pts[2 * k] = x;
+        pts[2 * k + 1] = clockwise ? f.t + f.b - y : y;
+      };
+      const a = box.halfX ? 1 : 0;
+      set(0, null, f.t + hy);
+      set(1, null, f.t + hy - vc);
+      set(2, f.r + a - hx + hc, f.t);
+      set(3, f.r + a - hx, f.t);
+      set(4, f.l + a + hx, f.t);
+      set(5, f.l + a + hx - hc, f.t);
+      set(6, null, f.t + hy - vc);
+      set(7, null, f.t + hy);
+      set(8, null, f.b - hy);
+      set(9, null, f.b - hy + vc);
+      set(10, f.l + hx - hc, f.b);
+      set(11, f.l + hx, f.b);
+      set(12, f.r - hx, f.b);
+      set(13, f.r - hx + hc, f.b);
+      set(14, null, f.b - hy + vc);
+      set(15, null, f.b - hy);
     }
   }
   return pts;
@@ -29883,7 +29957,7 @@ function arcRasterPath(box, s, e, clockwise, kind, from, path = new GdiRasterPat
       cw = !cw;
     }
   }
-  const bz = arcBeziers(f.l, f.t, f.r, f.b, sx, sy, ex, ey, cw);
+  const bz = arcBeziers(f.l, f.t, f.r, f.b, sx, sy, ex, ey, cw, !!box.halfX, !!box.framed);
   const pts = [];
   for (let i = 0; i < bz.length; i += 2) {
     pts.push(...map(bz[i], bz[i + 1]));
@@ -29897,7 +29971,7 @@ function arcRasterPath(box, s, e, clockwise, kind, from, path = new GdiRasterPat
   if (kind === "pie") {
     const w = f.r - f.l;
     const h = f.b - f.t;
-    const [cx, cy] = map(f.l + Math.ceil(w / 2), f.t + Math.ceil(h / 2));
+    const [cx, cy] = map(f.l + Math.ceil(w / 2) + (box.halfX ? 1 : 0), f.t + Math.ceil(h / 2));
     path.lineTo(cx, cy);
   }
   if (kind === "pie" || kind === "chord") {
@@ -30954,9 +31028,24 @@ function insideFrameInset(rCtx, box, rectangle = false, clockwiseRoundRect = fal
     right: Math.round((rectangle ? lo : hi) * px),
     top: y,
     bottom: y,
-    half: wx % 2 === 1 && !rectangle
+    half: wx % 2 === 1 && !rectangle,
+    halfRect: wx % 2 === 1 && rectangle
   };
 }
+function insideFramePenTooWide(rCtx, box) {
+  if ((rCtx.state.penStyle & 15) !== PS_INSIDEFRAME || !isAxisBox(box) || hasWorldRotation(rCtx)) {
+    return false;
+  }
+  const m = gdiDeviceMatrix(rCtx);
+  const px = gdiDevicePixelX(rCtx);
+  const py = gdiDevicePixelY(rCtx);
+  const widthX = Math.abs(rCtx.state.penWidth * m[0]) / px * 16;
+  const widthY = Math.abs(rCtx.state.penWidth * m[3]) / py * 16;
+  if (Math.max(widthX, widthY) < 24) {
+    return false;
+  }
+  return Math.abs(box.exx) / px < Math.round(widthX) || Math.abs(box.eyy) / py < Math.round(widthY);
+}
 function insetFixBox(box, inset) {
   const sx = box.exx < 0 ? -1 : 1;
   const sy = box.eyy < 0 ? -1 : 1;
@@ -30966,11 +31055,15 @@ function insetFixBox(box, inset) {
     exx: box.exx - sx * (inset.left + inset.right),
     exy: 0,
     eyx: 0,
-    eyy: box.eyy - sy * (inset.top + inset.bottom)
+    eyy: box.eyy - sy * (inset.top + inset.bottom),
+    framed: true
   };
   if (inset.half && sx > 0) {
     framed.halfX = true;
   }
+  if (inset.halfRect && sx > 0) {
+    framed.halfXRect = true;
+  }
   return framed;
 }
 function sameEllipseRay(l, t, r, b, sx, sy, ex, ey) {
@@ -31053,7 +31146,7 @@ function handleRectangle(rCtx, dataOff, recSize) {
     const r = view.getInt32(dataOff + 8, true);
     const b = view.getInt32(dataOff + 12, true);
     const unframed = uprightFixBox(rCtx, l, t, r, b);
-    const inset = insideFrameInset(rCtx, unframed, true);
+    const inset = insideFrameInset(rCtx, unframed, true, rCtx.state.arcDirection === 2);
     const box = inset ? insetFixBox(unframed, inset) : unframed;
     const clockwise = rCtx.state.arcDirection === 2;
     if (!inPath) {
@@ -31239,6 +31332,13 @@ function handleRoundRect(rCtx, dataOff, recSize) {
       gmh(rCtx, cornerH) / 2,
       null
     );
+    if (inset) {
+      const fullW = Math.abs((r - l) * devM[0]) * 16;
+      const fullH = Math.abs((b - t) * devM[3]) * 16;
+      if (fullW > 0 && fullH > 0) {
+        framed.cornerExact = [Math.min(cornerFixW, fullW) * Math.abs(framed.exx) / fullW, Math.min(cornerFixH, fullH) * Math.abs(framed.eyy) / fullH];
+      }
+    }
     const raster = (box = framed) => roundRectRasterPath(box, cw, ch, clockwise, cornerW === 0 || cornerH === 0);
     if (inPath) {
       const box = framed;
@@ -31292,7 +31392,7 @@ function handleEllipse(rCtx, dataOff, recSize) {
     const b = view.getInt32(dataOff + 12, true);
     const clockwise = rCtx.state.arcDirection === 2;
     const unframed = uprightFixBox(rCtx, l, t, r, b);
-    const inset = insideFrameInset(rCtx, unframed);
+    const inset = insideFrameInset(rCtx, unframed, false, rCtx.state.arcDirection === 2);
     const framed = inset ? insetFixBox(unframed, inset) : unframed;
     const params = inset ? { cx: (framed.ax + framed.exx / 2) / 16, cy: (framed.ay + framed.eyy / 2) / 16, rx: Math.abs(framed.exx) / 32, ry: Math.abs(framed.eyy) / 32, rotation: 0 } : 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),
@@ -31342,7 +31442,10 @@ function handleArcFamily(rCtx, recType, dataOff, recSize) {
     const endAngle = fullEllipse ? startAngle + (clockwise ? 2 : -2) * Math.PI : Math.atan2((endY - cyA) / (ry || 1), (endX - cxA) / (rx || 1));
     const rotated = hasWorldRotation(rCtx);
     const unframed = fixBox(rCtx, l, t, r, b);
-    const inset = insideFrameInset(rCtx, unframed);
+    if (recType !== EMR_ARCTO && insideFramePenTooWide(rCtx, unframed)) {
+      return true;
+    }
+    const inset = insideFrameInset(rCtx, unframed, false, rCtx.state.arcDirection === 2);
     const framed = inset ? insetFixBox(unframed, inset) : unframed;
     const params = inset ? { cx: (framed.ax + framed.exx / 2) / 16, cy: (framed.ay + framed.eyy / 2) / 16, rx: Math.abs(framed.exx) / 32, ry: Math.abs(framed.eyy) / 32, rotation: 0 } : rotated ? gdiEllipseParams(rCtx, cxA, cyA, rx, ry) : {
       cx: gmx(rCtx, cxA),
@@ -31373,20 +31476,25 @@ function handleArcFamily(rCtx, recType, dataOff, recSize) {
       }
     };
     const kind = isArcTo ? "arcto" : recType === EMR_PIE ? "pie" : recType === EMR_CHORD ? "chord" : "arc";
-    const radialOnBox = (p) => {
+    const devM = gdiDeviceMatrix(rCtx);
+    const rawFix = (x, y) => [(devM[0] * x + devM[2] * y + devM[4]) * 16, (devM[1] * x + devM[3] * y + devM[5]) * 16];
+    const radialOnBox = (p, raw) => {
       if (!inset) {
         return p;
       }
-      const kx = unframed.exx !== 0 ? framed.exx / unframed.exx : 1;
-      const ky = unframed.eyy !== 0 ? framed.eyy / unframed.eyy : 1;
-      return [framed.ax + framed.exx / 2 + (p[0] - (unframed.ax + unframed.exx / 2)) * kx, framed.ay + framed.eyy / 2 + (p[1] - (unframed.ay + unframed.eyy / 2)) * ky];
+      const [rl, rt] = rawFix(l, t);
+      const [rr, rb] = rawFix(r, b);
+      const kx = rr !== rl ? framed.exx / (rr - rl) : 1;
+      const ky = rb !== rt ? framed.eyy / (rb - rt) : 1;
+      const snap = (v) => Math.abs(v) < 1e-6 ? 0 : v;
+      return [framed.ax + framed.exx / 2 + snap(raw[0] - (rl + rr) / 2) * kx, framed.ay + framed.eyy / 2 + snap(raw[1] - (rt + rb) / 2) * ky];
     };
     const rasterArgs = (immediate = false) => ({
       box: inset ? framed : immediate && needsFill ? curvedFixBox(rCtx, l, t, r, b) : unframed,
-      s: radialOnBox(fixPoint(rCtx, startX, startY)),
+      s: radialOnBox(fixPoint(rCtx, startX, startY), rawFix(startX, startY)),
       // Device FIX rounding can separate distinct radial points on the
       // same logical ray. Preserve their proven endpoint identity.
-      e: fullEllipse ? radialOnBox(fixPoint(rCtx, startX, startY)) : radialOnBox(fixPoint(rCtx, endX, endY)),
+      e: fullEllipse ? radialOnBox(fixPoint(rCtx, startX, startY), rawFix(startX, startY)) : radialOnBox(fixPoint(rCtx, endX, endY), rawFix(endX, endY)),
       from: currentFix(rCtx)
     });
     if (inPath) {
@@ -39683,6 +39791,7 @@ function compatBox(p, l, t, r, b, opts = {}) {
   if ((p.rCtx.state.penStyle & 15) === PS_INSIDEFRAME2) {
     const w = Math.round(penDeviceWidth(p.rCtx) / p.kx);
     if (w > 1) {
+      const whole = { ...box };
       const matrix = gdiDeviceMatrix(p.rCtx);
       const wx = Math.round(Math.abs(p.rCtx.state.penWidth * matrix[0]) / p.kx * 16);
       const wy = Math.round(Math.abs(p.rCtx.state.penWidth * matrix[3]) / p.ky * 16);
@@ -39696,14 +39805,21 @@ function compatBox(p, l, t, r, b, opts = {}) {
       if (half) {
         box.halfX = true;
       }
+      if (opts.clampEmpty && (box.x1 < box.x0 || box.y1 < box.y0)) {
+        return { x0: whole.x0, y0: whole.y0, x1: whole.x1 + Math.round(ux), y1: whole.y1 + Math.round(uy) };
+      }
     }
   }
   return box;
 }
-function fixBoxOf(box) {
-  const fix = axisBox(box.x0, box.y0, Math.max(box.x0, box.x1), Math.max(box.y0, box.y1));
+function fixBoxOf(box, cornerExact, keepInverted = false) {
+  const fix = keepInverted ? axisBox(box.x0, box.y0, box.x1, box.y1) : axisBox(box.x0, box.y0, Math.max(box.x0, box.x1), Math.max(box.y0, box.y1));
   if (box.halfX) {
     fix.halfX = true;
+    fix.halfXCompat = true;
+  }
+  if (cornerExact) {
+    fix.cornerExact = cornerExact;
   }
   return fix;
 }
@@ -39767,7 +39883,8 @@ function compatCorner(p, w, h, box, logical) {
     const width2 = box.x1 - box.x0, height2 = box.y1 - box.y0;
     const fullW2 = Math.abs((logical[2] - logical[0]) * m[0]) * 16 || width2;
     const fullH2 = Math.abs((logical[3] - logical[1]) * m[3]) * 16 || height2;
-    return [Math.floor(Math.min(Math.abs(w * m[0]) * 16, fullW2) * width2 / fullW2), Math.floor(Math.min(Math.abs(h * m[3]) * 16, fullH2) * height2 / fullH2)];
+    const cornerW = Math.min(Math.abs(w * m[0]) * 16, fullW2) * width2 / fullW2;
+    return [Math.floor(cornerW), Math.floor(Math.min(Math.abs(h * m[3]) * 16, fullH2) * height2 / fullH2), [cornerW, Math.min(Math.abs(h * m[3]) * 16, fullH2) * height2 / fullH2]];
   }
   const width = box.x1 - box.x0, height = box.y1 - box.y0;
   const fullW = Math.abs((logical[2] - logical[0]) * m[0]) * 16 || width + ux;
@@ -39776,11 +39893,11 @@ function compatCorner(p, w, h, box, logical) {
   return penIsCosmetic(p.rCtx) && !penIsNull(p) ? scaled2 : [Math.floor(scaled2[0]), Math.floor(scaled2[1])];
 }
 function wmfRoundRect(p, l, t, r, b, w, h) {
-  const box = compatBox(p, l, t, r, b, { curved: true, half: true });
+  const box = compatBox(p, l, t, r, b, { curved: true, half: true, clampEmpty: true });
   if (box.x1 < box.x0 || box.y1 < box.y0) {
     return;
   }
-  const [cw, ch] = compatCorner(p, w, h, box, [l, t, r, b]);
+  const [cw, ch, half] = compatCorner(p, w, h, box, [l, t, r, b]);
   const cr = canvasRect(box);
   paintGdiShape(p.rCtx, {
     build: (c) => {
@@ -39805,14 +39922,14 @@ function wmfRoundRect(p, l, t, r, b, w, h) {
       c.ellipse(cr.x + ex, cr.y + ey, ex, ey, 0, 2 * q, 3 * q);
       c.closePath();
     },
-    raster: () => roundRectRasterPath(fixBoxOf(box), cw, ch, clockwiseOf(p), w === 0 || h === 0, !penIsNull(p) && penIsCosmetic(p.rCtx)),
+    raster: () => roundRectRasterPath(fixBoxOf(box, half), cw, ch, clockwiseOf(p), w === 0 || h === 0, !penIsNull(p) && penIsCosmetic(p.rCtx)),
     roundPen: true,
     fill: true,
     stroke: true
   });
 }
 function wmfEllipse(p, l, t, r, b) {
-  const box = compatBox(p, l, t, r, b, { curved: true, half: true });
+  const box = compatBox(p, l, t, r, b, { curved: true, half: true, clampEmpty: true });
   if (box.x1 < box.x0 || box.y1 < box.y0) {
     return;
   }
@@ -39828,9 +39945,9 @@ function wmfEllipse(p, l, t, r, b) {
     stroke: true
   });
 }
-function compatArc(p, kind, l, t, r, b, xs, ys, xe, ye) {
-  const box = compatBox(p, l, t, r, b, { curved: kind === "chord" || kind === "pie", roundFrame: true });
-  if (box.x1 < box.x0 || box.y1 < box.y0) {
+function compatArc(p, kind, l, t, r, b, xs, ys, xe, ye, keepInverted = false) {
+  const box = compatBox(p, l, t, r, b, { curved: kind === "chord" || kind === "pie", roundFrame: true, half: true });
+  if (box.y1 < box.y0 || !keepInverted && box.x1 < box.x0) {
     return null;
   }
   const m = gdiDeviceMatrix(p.rCtx);