emf-converter 4.3.1 → 4.3.3

package/dist/index.mjs

@@ -1735,7 +1735,21 @@ var KAPPA = 0.5522847498307936;
 function axisBox(l, t, r, b) {
   return { ax: l, ay: t, exx: r - l, exy: 0, eyx: 0, eyy: b - t };
 }
-function ellipseBeziersBox(box) {
+function ellipseBeziersBox(box, clockwise = false) {
+  if (!clockwise) {
+    return ellipsePoints(box, false);
+  }
+  const e = clockwiseEllipseBeziersBox(box);
+  const out = [];
+  for (let i = e.length - 2; i >= 0; i -= 2) {
+    out.push(e[i], e[i + 1]);
+  }
+  return out;
+}
+function clockwiseEllipseBeziersBox(box) {
+  return ellipsePoints(box, true);
+}
+function ellipsePoints(box, cwControls) {
   const half = (v, up) => up ? Math.ceil(v / 2) : Math.floor(v / 2);
   const hMidLo = (v) => half(v, false);
   const hMidHi = (v) => half(v, true);
@@ -1745,6 +1759,11 @@ function ellipseBeziersBox(box) {
   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 leftUpper = cwControls ? (v) => vMidLo(v) - vDist(v) : vCtl;
+  const leftLower = cwControls ? (v) => vMidLo(v) + vDist(v) : vCtlR;
+  const rightLower = cwControls ? (v) => vMidHi(v) + vDist(v) : vCtlR;
   const zero = () => 0;
   const full = (v) => v;
   const { ax, ay, exx, exy, eyx, eyy } = box;
@@ -1753,17 +1772,17 @@ function ellipseBeziersBox(box) {
     out.push(ax + gx(exx) + gy(eyx), ay + gx(exy) + gy(eyy));
   };
   P(full, vMidHi);
-  P(full, vCtl);
+  P(full, rightUpper);
   P(hCtl, zero);
   P(hMidLo, zero);
   P(hCtl2, zero);
-  P(zero, vCtl);
+  P(zero, leftUpper);
   P(zero, vMidLo);
-  P(zero, vCtlR);
+  P(zero, leftLower);
   P(hCtl2, full);
   P(hMidHi, full);
   P(hCtl, full);
-  P(full, vCtlR);
+  P(full, rightLower);
   P(full, vMidHi);
   return out;
 }
@@ -1780,8 +1799,12 @@ function flattenBezierPath(pts) {
 function roundRectCorners(l, t, r, b, cw, ch) {
   const w = r - l;
   const h = b - t;
-  const ew = Math.min(Math.abs(cw), w);
-  const eh = Math.min(Math.abs(ch), h);
+  let ew = Math.min(Math.abs(cw), w);
+  let eh = Math.min(Math.abs(ch), h);
+  if (ew === 0 || eh === 0) {
+    ew = 0;
+    eh = 0;
+  }
   const hy = Math.floor(h / 2) - Math.floor((h - eh) / 2);
   const topX = Math.floor(r - ew / 2);
   const hx = r - topX;
@@ -1890,12 +1913,7 @@ function angleArcFix(box, startDeg, sweepDeg) {
   const cx = l + w / 2;
   const cy = t + h / 2;
   const E = ellipseBeziers(l, t, l + w, t + h);
-  const Ecw = E.slice();
-  const d = Math.ceil(KAPPA * Math.floor(h / 2));
-  Ecw[3] = Ecw[1] - d;
-  Ecw[11] = Ecw[13] - d;
-  Ecw[15] = Ecw[13] + d;
-  Ecw[23] = Ecw[1] + d;
+  const Ecw = clockwiseEllipseBeziersBox(axisBox(l, t, l + w, t + h));
   const start = startDeg * Math.PI / 180;
   const out = [Math.round(cx + w / 2 * tableCos(start)), Math.round(cy - h / 2 * tableSin(start))];
   for (const p of angleArcPieces(startDeg, sweepDeg)) {
@@ -1937,15 +1955,7 @@ function arcBeziers(l, t, r, b, xs, ys, xe, ye, clockwise) {
   }
   const px = (a2) => cx + rx * tableCos(a2);
   const py = (a2) => cy - ry * tableSin(a2);
-  const E = ellipseBeziers(l, t, r, b);
-  if (clockwise) {
-    const fh = Math.floor((b - t) / 2);
-    const d = Math.ceil(KAPPA * fh);
-    E[3] = E[1] - d;
-    E[11] = E[13] - d;
-    E[15] = E[13] + d;
-    E[23] = E[1] + d;
-  }
+  const E = clockwise ? clockwiseEllipseBeziersBox(axisBox(l, t, r, b)) : ellipseBeziers(l, t, r, b);
   const out = [Math.round(px(a0)), Math.round(py(a0))];
   let a = a0;
   for (let guard = 0; guard < 8 && (s > 0 ? a < a1 - 1e-12 : a > a1 + 1e-12); guard++) {
@@ -1978,12 +1988,45 @@ function arcBeziers(l, t, r, b, xs, ys, xe, ye, clockwise) {
 var GdiRasterPath = class {
   constructor() {
     this.figures = [];
+    /**
+     * The path as `GetPath` reports it, before flattening: FIX points
+     * (`[x0, y0, ...]`) and their `PT_*` types (`PT_MOVETO` 6, `PT_LINETO`
+     * 2, `PT_BEZIERTO` 4, `PT_CLOSEFIGURE` 1 or-ed onto a figure's last
+     * point). Used to check the geometry against Windows' own paths.
+     */
+    this.getPath = { pts: [], types: [] };
     this.current = null;
   }
   /** Starts a new figure at (`x`, `y`). */
   moveTo(x, y) {
     this.current = { pts: [x, y], closed: false };
     this.figures.push(this.current);
+    this.log(x, y, 6);
+  }
+  /**
+   * Starts a new figure at the current position (`x`, `y`) unless the open
+   * figure already ends there. GDI opens a new figure for a drawing call
+   * that continues from the current position (`LineTo`, `PolylineTo`,
+   * `ArcTo`, ...) when the path is empty, its last figure is closed, or
+   * the current position has moved away from the path's last point (a
+   * `MoveTo`, or a call such as `Polyline`, `Arc` or `PolyPolygon` that
+   * adds to the path without moving the current position; Windows'
+   * `GetPath`, Wine `gdi32/tests/path.c`, `test_all_functions`).
+   */
+  continueAt(x, y) {
+    const f = this.current;
+    if (f && f.pts[f.pts.length - 2] === x && f.pts[f.pts.length - 1] === y) {
+      return;
+    }
+    this.moveTo(x, y);
+  }
+  /** True when a figure is open (not closed and not ended by an appended path). */
+  hasOpenFigure() {
+    return this.current !== null;
+  }
+  log(x, y, type) {
+    this.getPath.pts.push(x, y);
+    this.getPath.types.push(type);
   }
   /** Adds a line to (`x`, `y`), starting a figure there when none is open. */
   lineTo(x, y) {
@@ -1992,6 +2035,7 @@ var GdiRasterPath = class {
       this.moveTo(last ? last[0] : x, last ? last[1] : y);
     }
     this.current.pts.push(x, y);
+    this.log(x, y, 2);
   }
   /** Adds a cubic Bezier from the current point. */
   bezierTo(c1x, c1y, c2x, c2y, x, y) {
@@ -2001,6 +2045,9 @@ var GdiRasterPath = class {
     }
     const p = this.current.pts;
     this.flattenInto(p[p.length - 2], p[p.length - 1], c1x, c1y, c2x, c2y, x, y);
+    this.log(c1x, c1y, 4);
+    this.log(c2x, c2y, 4);
+    this.log(x, y, 4);
   }
   /** Flattens one Bezier onto the open figure, recording its end tangents. */
   flattenInto(x0, y0, c1x, c1y, c2x, c2y, x3, y3) {
@@ -2035,6 +2082,9 @@ var GdiRasterPath = class {
     }
     for (let i = 2; i + 5 < pts.length; i += 6) {
       this.flattenInto(pts[i - 2], pts[i - 1], pts[i], pts[i + 1], pts[i + 2], pts[i + 3], pts[i + 4], pts[i + 5]);
+      for (let k = i; k < i + 6; k += 2) {
+        this.log(pts[k], pts[k + 1], 4);
+      }
     }
   }
   /** Closes the open figure (the next drawing call starts a new one). */
@@ -2042,6 +2092,8 @@ var GdiRasterPath = class {
     if (this.current) {
       this.current.closed = true;
       this.current = null;
+      const t = this.getPath.types;
+      t[t.length - 1] |= 1;
     }
   }
   /** Appends every figure of `other`. */
@@ -2049,6 +2101,9 @@ var GdiRasterPath = class {
     for (const f of other.figures) {
       this.figures.push({ pts: f.pts.slice(), closed: f.closed, tangents: f.tangents && new Map(f.tangents) });
     }
+    for (let i = 0; i < other.getPath.types.length; i++) {
+      this.log(other.getPath.pts[2 * i], other.getPath.pts[2 * i + 1], other.getPath.types[i]);
+    }
     this.current = null;
   }
   lastPoint() {
@@ -12645,7 +12700,10 @@ function dashFigure(pts, closed, pen) {
   for (let i = 0; i + 1 < path.length; i++) {
     const a = path[i];
     const b = path[i + 1];
-    let segLen = Math.hypot(b.x - a.x, b.y - a.y);
+    const m = pen.dashMetric;
+    const vx = b.x - a.x;
+    const vy = b.y - a.y;
+    let segLen = m ? Math.hypot(m[0] * vx + m[2] * vy, m[1] * vx + m[3] * vy) : Math.hypot(vx, vy);
     let t0 = 0;
     while (segLen - t0 > remaining + 1e-9) {
       t0 += remaining;
@@ -12673,6 +12731,26 @@ function dashFigure(pts, closed, pen) {
   }
   return out.filter((d) => d.pts.length > 1);
 }
+var ARROW_ANCHOR = 20;
+function arrowAnchor(pp, atEnd, half) {
+  const w = 2 * half;
+  const tip = atEnd ? pp[pp.length - 1] : pp[0];
+  const next = atEnd ? pp[pp.length - 2] : pp[1];
+  const len = Math.hypot(next.x - tip.x, next.y - tip.y);
+  const ux = (next.x - tip.x) / len;
+  const uy = (next.y - tip.y) / len;
+  const depth = 2 * w;
+  const across = 2 * w / Math.sqrt(3);
+  const base = { x: tip.x + ux * depth, y: tip.y + uy * depth };
+  if (len > depth) {
+    if (atEnd) {
+      pp[pp.length - 1] = base;
+    } else {
+      pp[0] = base;
+    }
+  }
+  return [tip, { x: base.x - uy * across, y: base.y + ux * across }, { x: base.x + uy * across, y: base.y - ux * across }];
+}
 var MIN_DASH = 1 / 256;
 function signedArea(pts) {
   let a = 0;
@@ -12723,6 +12801,19 @@ function widenFigures(figures, pen) {
       if (pp.length < 2) {
         continue;
       }
+      const arrows = [];
+      let startCapOverride = null;
+      let endCapOverride = null;
+      if (!pieceClosed && !(pen.dash && closed)) {
+        if (piece.first && pen.startCap === ARROW_ANCHOR) {
+          arrows.push(arrowAnchor(pp, false, h));
+          startCapOverride = 0;
+        }
+        if (piece.last && pen.endCap === ARROW_ANCHOR) {
+          arrows.push(arrowAnchor(pp, true, h));
+          endCapOverride = 0;
+        }
+      }
       for (const [o1, o2] of bands) {
         if (pieceClosed) {
           polys.push(sidePoints(pp, true, o2, pen));
@@ -12733,11 +12824,16 @@ function widenFigures(figures, pen) {
         const right = sidePoints(pp, false, o1, pen).reverse();
         const fEnd = frame(pp[pp.length - 2], pp[pp.length - 1]);
         const f0 = frame(pp[1], pp[0]);
-        const endCap = piece.last && !(pen.dash && closed) ? pen.endCap : pen.dashCap;
-        const startCap = piece.first && !(pen.dash && closed) ? pen.startCap : pen.dashCap;
+        const endCap = endCapOverride ?? (piece.last && !(pen.dash && closed) ? pen.endCap : pen.dashCap);
+        const startCap = startCapOverride ?? (piece.first && !(pen.dash && closed) ? pen.startCap : pen.dashCap);
         const capEnd = capPoints(pp[pp.length - 1], fEnd, o1, o2, endCap, h);
         const capStart = capPoints(pp[0], f0, -o2, -o1, startCap, h);
-        polys.push([...left.slice(0, -1), ...capEnd, ...right.slice(1, -1), ...capStart]);
+        const poly = [...left.slice(0, -1), ...capEnd, ...right.slice(1, -1), ...capStart];
+        polys.push(poly);
+        const sign = Math.sign(signedArea(poly));
+        for (const arrow of arrows) {
+          polys.push(Math.sign(signedArea(arrow)) === sign ? arrow : arrow.slice().reverse());
+        }
       }
     }
   }
@@ -16651,8 +16747,11 @@ function boxCorners(box) {
   const { ax, ay, exx, exy, eyx, eyy } = box;
   return [ax + exx, ay + exy, ax, ay, ax + eyx, ay + eyy, ax + exx + eyx, ay + exy + eyy];
 }
-function rectRasterPath(box) {
-  const c = boxCorners(box);
+function flipBox(box) {
+  return { ax: box.ax + box.eyx, ay: box.ay + box.eyy, exx: box.exx, exy: box.exy, eyx: -box.eyx, eyy: -box.eyy };
+}
+function rectRasterPath(box, clockwise = false) {
+  const c = boxCorners(clockwise ? flipBox(box) : box);
   const path = new GdiRasterPath();
   path.moveTo(c[0], c[1]);
   path.lineTo(c[2], c[3]);
@@ -16661,9 +16760,9 @@ function rectRasterPath(box) {
   path.closeFigure();
   return path;
 }
-function ellipseRasterPath(box) {
+function ellipseRasterPath(box, clockwise = false) {
   const path = new GdiRasterPath();
-  path.addBeziers(ellipseBeziersBox(box), true);
+  path.addBeziers(ellipseBeziersBox(box, clockwise), true);
   path.closeFigure();
   return path;
 }
@@ -16689,13 +16788,16 @@ function boxFrame(box) {
   const h = Math.round(Math.hypot(box.eyx, box.eyy));
   return { l: 0, t: 0, r: w, b: h };
 }
-function roundRectRasterPath(box, cw, ch) {
+function roundRectRasterPath(box, cw, ch, clockwise = false, rectangle = false) {
+  if (rectangle) {
+    return rectRasterPath(box, clockwise);
+  }
   const f = boxFrame(box);
   const q = roundRectCorners(f.l, f.t, f.r, f.b, cw, ch);
   const map = frameMapper(box, f.l, f.t, f.r - f.l, f.b - f.t);
   const pts = [];
   for (let i = 0; i < q.length; i += 2) {
-    pts.push(...map(q[i], q[i + 1]));
+    pts.push(...map(q[i], clockwise ? f.t + f.b - q[i + 1] : q[i + 1]));
   }
   const path = new GdiRasterPath();
   for (let c = 0; c < 4; c++) {
@@ -16738,7 +16840,7 @@ function arcRasterPath(box, s, e, clockwise, kind, from, path = new GdiRasterPat
     pts.push(...map(bz[i], bz[i + 1]));
   }
   if (kind === "arcto" && from) {
-    path.lineTo(from[0], from[1]);
+    path.continueAt(from[0], from[1]);
     path.addBeziers(pts, false);
   } else {
     path.addBeziers(pts, true);
@@ -19458,6 +19560,15 @@ function rasterPathOf(rCtx) {
   rCtx.rasterPath ?? (rCtx.rasterPath = new GdiRasterPath());
   return rCtx.rasterPath;
 }
+function continueFigure(rCtx) {
+  const path = rasterPathOf(rCtx);
+  const [x, y] = currentFix(rCtx);
+  const before = path.figures.length;
+  path.continueAt(x, y);
+  if (path.figures.length !== before) {
+    gdiPathRecorder(rCtx).moveTo(x / 16, y / 16);
+  }
+}
 function lineStyleOf(rCtx) {
   rCtx.lineStyle ?? (rCtx.lineStyle = { pos: 0 });
   return rCtx.lineStyle;
@@ -19473,6 +19584,9 @@ function currentFix(rCtx) {
   }
   return fixPoint(rCtx, state.curX, state.curY);
 }
+function uprightFixBox(rCtx, l, t, r, b) {
+  return fixBox(rCtx, Math.min(l, r), Math.min(t, b), Math.max(l, r), Math.max(t, b));
+}
 function fixExtent(rCtx, v, axis) {
   const m = gdiDeviceMatrix(rCtx);
   const k = axis === 0 ? Math.hypot(m[0], m[1]) : Math.hypot(m[2], m[3]);
@@ -19515,6 +19629,7 @@ function handleLineTo(rCtx, dataOff, recSize) {
     const to = rotated ? gmapPoint(rCtx, lx, ly) : { x: gmx(rCtx, lx), y: gmy(rCtx, ly) };
     const fixTo = fixPoint(rCtx, lx, ly);
     if (inPath) {
+      continueFigure(rCtx);
       gdiPathRecorder(rCtx).lineTo(to.x, to.y);
       rasterPathOf(rCtx).lineTo(fixTo[0], fixTo[1]);
     } else {
@@ -19549,7 +19664,8 @@ function handleRectangle(rCtx, dataOff, recSize) {
     const t = view.getInt32(dataOff + 4, true);
     const r = view.getInt32(dataOff + 8, true);
     const b = view.getInt32(dataOff + 12, true);
-    const box = fixBox(rCtx, l, t, r, b);
+    const box = uprightFixBox(rCtx, l, t, r, b);
+    const clockwise = rCtx.state.arcDirection === 2;
     if (!inPath) {
       resetLineStyle(rCtx);
     }
@@ -19568,14 +19684,14 @@ function handleRectangle(rCtx, dataOff, recSize) {
       };
       if (inPath) {
         appendRect(gdiPathRecorder(rCtx));
-        rasterPathOf(rCtx).append(rectRasterPath(box));
+        rasterPathOf(rCtx).append(rectRasterPath(box, clockwise));
       } else {
         paintGdiShape(rCtx, {
           build: (c) => {
             c.beginPath();
             appendRect(c);
           },
-          raster: () => rectRasterPath(box),
+          raster: () => rectRasterPath(box, clockwise),
           rectangle: true,
           fill: true,
           stroke: true,
@@ -19590,14 +19706,14 @@ function handleRectangle(rCtx, dataOff, recSize) {
     const h = gmh(rCtx, b - t);
     if (inPath) {
       gdiPathRecorder(rCtx).rect(x, y, w, h);
-      rasterPathOf(rCtx).append(rectRasterPath(box));
+      rasterPathOf(rCtx).append(rectRasterPath(box, clockwise));
     } else if (needsPathBasedRectangle(rCtx)) {
       paintGdiShape(rCtx, {
         build: (c) => {
           c.beginPath();
           c.rect(x, y, w, h);
         },
-        raster: () => rectRasterPath(box),
+        raster: () => rectRasterPath(box, clockwise),
         rectangle: true,
         fill: true,
         stroke: true,
@@ -19710,7 +19826,8 @@ function handleRoundRect(rCtx, dataOff, recSize) {
       gmh(rCtx, cornerH) / 2,
       null
     );
-    const raster = (box = fixBox(rCtx, l, t, r, b)) => roundRectRasterPath(box, fixExtent(rCtx, cornerW, 0), fixExtent(rCtx, cornerH, 1));
+    const clockwise = rCtx.state.arcDirection === 2;
+    const raster = (box = uprightFixBox(rCtx, l, t, r, b)) => roundRectRasterPath(box, fixExtent(rCtx, cornerW, 0), fixExtent(rCtx, cornerH, 1), clockwise, cornerW === 0 || cornerH === 0);
     if (inPath) {
       drawRoundRect(gdiPathRecorder(rCtx));
       rasterPathOf(rCtx).append(raster());
@@ -19721,7 +19838,7 @@ function handleRoundRect(rCtx, dataOff, recSize) {
           c.beginPath();
           drawRoundRect(c);
         },
-        raster: () => raster(curvedFixBox(rCtx, l, t, r, b)),
+        raster: () => raster(curvedFixBox(rCtx, l, t, r, b, true)),
         roundPen: true,
         fill: true,
         stroke: true
@@ -19730,8 +19847,8 @@ function handleRoundRect(rCtx, dataOff, recSize) {
   }
   return true;
 }
-function curvedFixBox(rCtx, l, t, r, b) {
-  const box = fixBox(rCtx, l, t, r, b);
+function curvedFixBox(rCtx, l, t, r, b, upright = false) {
+  const box = upright ? uprightFixBox(rCtx, l, t, r, b) : fixBox(rCtx, l, t, r, b);
   if (rCtx.state.penStyle !== 5) {
     return box;
   }
@@ -19757,6 +19874,7 @@ function handleEllipse(rCtx, dataOff, recSize) {
     const t = view.getInt32(dataOff + 4, true);
     const r = view.getInt32(dataOff + 8, true);
     const b = view.getInt32(dataOff + 12, true);
+    const clockwise = rCtx.state.arcDirection === 2;
     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),
@@ -19766,7 +19884,7 @@ function handleEllipse(rCtx, dataOff, recSize) {
     };
     if (inPath) {
       gdiPathRecorder(rCtx).ellipse(params.cx, params.cy, params.rx, params.ry, params.rotation, 0, Math.PI * 2);
-      rasterPathOf(rCtx).append(ellipseRasterPath(fixBox(rCtx, l, t, r, b)));
+      rasterPathOf(rCtx).append(ellipseRasterPath(uprightFixBox(rCtx, l, t, r, b), clockwise));
     } else {
       resetLineStyle(rCtx);
       paintGdiShape(rCtx, {
@@ -19774,7 +19892,7 @@ function handleEllipse(rCtx, dataOff, recSize) {
           c.beginPath();
           c.ellipse(params.cx, params.cy, params.rx, params.ry, params.rotation, 0, Math.PI * 2);
         },
-        raster: () => ellipseRasterPath(curvedFixBox(rCtx, l, t, r, b)),
+        raster: () => ellipseRasterPath(curvedFixBox(rCtx, l, t, r, b, true), clockwise),
         roundPen: true,
         fill: true,
         stroke: true
@@ -19832,6 +19950,9 @@ function handleArcFamily(rCtx, recType, dataOff, recSize) {
       from: currentFix(rCtx)
     });
     if (inPath) {
+      if (isArcTo) {
+        continueFigure(rCtx);
+      }
       build(gdiPathRecorder(rCtx));
       const a = rasterArgs();
       arcRasterPath(a.box, a.s, a.e, clockwise, kind, a.from, rasterPathOf(rCtx));
@@ -19908,9 +20029,7 @@ function handleAngleArc(rCtx, dataOff, recSize) {
   }
   const e = [fixPts[fixPts.length - 2], fixPts[fixPts.length - 1]];
   const buildRaster = (path, from) => {
-    if (from) {
-      path.moveTo(from[0], from[1]);
-    }
+    path.continueAt(from[0], from[1]);
     path.addBeziers(fixPts, false);
   };
   const params = gdiEllipseParams(rCtx, cx, cy, radius, radius);
@@ -19924,9 +20043,9 @@ function handleAngleArc(rCtx, dataOff, recSize) {
     c.ellipse(params.cx, params.cy, params.rx, params.ry, params.rotation, -a0, clockwise ? -a0 + span : -a0 - span, !clockwise);
   };
   if (inPath) {
-    const rec = gdiPathRecorder(rCtx);
-    buildCanvas(rec);
-    buildRaster(rasterPathOf(rCtx), rasterPathOf(rCtx).figures.length === 0 ? currentFix(rCtx) : null);
+    continueFigure(rCtx);
+    buildCanvas(gdiPathRecorder(rCtx));
+    buildRaster(rasterPathOf(rCtx), currentFix(rCtx));
   } else {
     resetLineStyle(rCtx);
     const from = currentFix(rCtx);
@@ -20005,50 +20124,111 @@ function readColorAdjustment(view, off) {
 function isIdentityColorAdjustment(ca) {
   return !ca || ca.flags === 0 && ca.redGamma === 1e4 && ca.greenGamma === 1e4 && ca.blueGamma === 1e4 && ca.referenceBlack === 0 && ca.referenceWhite === 1e4 && ca.contrast === 0 && ca.brightness === 0 && ca.colorfulness === 0 && ca.redGreenTint === 0;
 }
-function colorfulnessScale(c) {
-  return c > 0 ? 1 + 2 * c / 100 : 1 + c / 100;
+var CONTRAST_GAIN = 1.88;
+var BRIGHTNESS_GAIN = 78.5;
+var COLORFULNESS_GAIN = 1.335;
+var TINT_RADIANS = -1.135;
+var RGB_TO_XYZ = [
+  [0.4124, 0.3576, 0.1805],
+  [0.2126, 0.7152, 0.0722],
+  [0.0193, 0.1192, 0.9505]
+];
+var XYZ_TO_RGB = invert3(RGB_TO_XYZ);
+var WHITE = RGB_TO_XYZ.map((row) => row[0] + row[1] + row[2]);
+var WHITE_D = WHITE[0] + 15 * WHITE[1] + 3 * WHITE[2];
+var WHITE_U = 4 * WHITE[0] / WHITE_D;
+var WHITE_V = 9 * WHITE[1] / WHITE_D;
+function invert3(m) {
+  const [[a, b, c], [d, e, f], [g, h, i]] = m;
+  const A = e * i - f * h;
+  const B = f * g - d * i;
+  const C = d * h - e * g;
+  const det = a * A + b * B + c * C;
+  return [
+    [A / det, (c * h - b * i) / det, (b * f - c * e) / det],
+    [B / det, (a * i - c * g) / det, (c * d - a * f) / det],
+    [C / det, (b * g - a * h) / det, (a * e - b * d) / det]
+  ];
+}
+function lightness(t) {
+  return t > 8856e-6 ? 116 * Math.cbrt(t) - 16 : 903.3 * t;
+}
+function fromLightness(l) {
+  return l > 8 ? ((l + 16) / 116) ** 3 : l / 903.3;
 }
 var clamp012 = (v) => v < 0 ? 0 : v > 1 ? 1 : v;
 function colorAdjustmentMapper(ca) {
   const black = ca.referenceBlack / 1e4;
   const span = Math.max(1e-6, ca.referenceWhite / 1e4 - black);
   const gammas = [ca.redGamma / 1e4, ca.greenGamma / 1e4, ca.blueGamma / 1e4];
-  const curves = gammas.map((gamma) => {
+  const negative = (ca.flags & CA_NEGATIVE) !== 0;
+  const linear = gammas.map((gamma) => {
     const table = new Float64Array(256);
     for (let i = 0; i < 256; i++) {
-      let v = clamp012((i / 255 - black) / span);
-      v = Math.pow(v, gamma);
-      table[i] = ca.flags & CA_NEGATIVE ? 1 - v : v;
+      const v = negative ? 1 - i / 255 : i / 255;
+      table[i] = clamp012((v - black) / span) ** gamma;
     }
     return table;
   });
-  const chroma = colorfulnessScale(ca.colorfulness);
-  const contrast = 1 + ca.contrast / 100;
-  const brightness = 0.8 * ca.brightness / 100;
-  const tint = 0.3 * ca.redGreenTint / 100;
+  const chroma = ca.colorfulness < 0 ? 1 + ca.colorfulness / 100 : 1 + COLORFULNESS_GAIN * ca.colorfulness / 100;
+  const angle = TINT_RADIANS * ca.redGreenTint / 100;
+  const cos = Math.cos(angle) * chroma;
+  const sin = Math.sin(angle) * chroma;
+  const slope = Math.exp(CONTRAST_GAIN * ca.contrast / 100);
+  const offset = 50 - 50 * slope + BRIGHTNESS_GAIN * ca.brightness / 100;
   const log = (ca.flags & CA_LOG_FILTER) !== 0;
-  const out = (v) => {
-    v = clamp012(v);
+  const colour = ca.colorfulness !== 0 || ca.redGreenTint !== 0;
+  const out = (v, c) => {
+    v = clamp012(fromLightness(slope * lightness(clamp012(v)) + offset)) ** (1 / gammas[c]);
     if (log) {
       v = Math.log10(1 + 9 * v);
     }
     return Math.round(v * 255);
   };
   return (rgb2) => {
-    const r = curves[0][rgb2 >> 16 & 255];
-    const g = curves[1][rgb2 >> 8 & 255];
-    const b = curves[2][rgb2 & 255];
-    let y = 0.299 * r + 0.587 * g + 0.114 * b;
-    let cr = (r - y) * chroma;
-    const cb = (b - y) * chroma;
-    y = (y - 0.5) * contrast + 0.5 + brightness;
-    cr += tint;
-    const r2 = y + cr;
-    const b2 = y + cb;
-    const g2 = (y - 0.299 * r2 - 0.114 * b2) / 0.587;
-    return out(r2) << 16 | out(g2) << 8 | out(b2);
+    let r = linear[0][rgb2 >> 16 & 255];
+    let g = linear[1][rgb2 >> 8 & 255];
+    let b = linear[2][rgb2 & 255];
+    if (colour) {
+      const x = RGB_TO_XYZ[0][0] * r + RGB_TO_XYZ[0][1] * g + RGB_TO_XYZ[0][2] * b;
+      const y = RGB_TO_XYZ[1][0] * r + RGB_TO_XYZ[1][1] * g + RGB_TO_XYZ[1][2] * b;
+      const z = RGB_TO_XYZ[2][0] * r + RGB_TO_XYZ[2][1] * g + RGB_TO_XYZ[2][2] * b;
+      const d = x + 15 * y + 3 * z;
+      if (d > 1e-12 && y > 1e-12) {
+        const du = 4 * x / d - WHITE_U;
+        const dv = 9 * y / d - WHITE_V;
+        const u = WHITE_U + du * cos - dv * sin;
+        const v = Math.max(1e-6, WHITE_V + du * sin + dv * cos);
+        const x2 = y * 9 * u / (4 * v);
+        const z2 = y * (12 - 3 * u - 20 * v) / (4 * v);
+        r = XYZ_TO_RGB[0][0] * x2 + XYZ_TO_RGB[0][1] * y + XYZ_TO_RGB[0][2] * z2;
+        g = XYZ_TO_RGB[1][0] * x2 + XYZ_TO_RGB[1][1] * y + XYZ_TO_RGB[1][2] * z2;
+        b = XYZ_TO_RGB[2][0] * x2 + XYZ_TO_RGB[2][1] * y + XYZ_TO_RGB[2][2] * z2;
+      }
+    }
+    return out(r, 0) << 16 | out(g, 1) << 8 | out(b, 2);
   };
 }
+function colorAdjustRgb(rgbs, ca) {
+  if (!ca || isIdentityColorAdjustment(ca)) {
+    return;
+  }
+  const map = colorAdjustmentMapper(ca);
+  const cache = /* @__PURE__ */ new Map();
+  for (let i = 0; i + 2 < rgbs.length; i += 3) {
+    const rgb2 = rgbs[i] << 16 | rgbs[i + 1] << 8 | rgbs[i + 2];
+    let v = cache.get(rgb2);
+    if (v === void 0) {
+      v = map(rgb2);
+      if (cache.size < 65536) {
+        cache.set(rgb2, v);
+      }
+    }
+    rgbs[i] = v >> 16 & 255;
+    rgbs[i + 1] = v >> 8 & 255;
+    rgbs[i + 2] = v & 255;
+  }
+}
 function applyColorAdjustment(pixels, ca) {
   if (!ca || isIdentityColorAdjustment(ca)) {
     return;
@@ -20143,64 +20323,160 @@ function stretchGdi(src, sx, sy, sw, sh, dw, dh, mode) {
   }
   return { width: W, height: H, data };
 }
-function axisBoxWeights(srcStart, srcLen, dstLen, reverse) {
-  const out = [];
+var FIX = 65536;
+function halftoneNearest(i, srcLen, dstLen) {
+  const num = (2 * i + 1) * srcLen;
+  const den = 2 * dstLen;
+  let k = Math.floor(num / den);
+  if (k * den === num) {
+    k--;
+  }
+  return Math.max(0, Math.min(srcLen - 1, k));
+}
+function halftoneAxis(start, srcLen, dstLen, reverse) {
+  const taps = [];
   if (dstLen <= 0 || srcLen <= 0) {
-    return out;
+    return taps;
   }
-  const at = (k) => reverse ? srcStart + srcLen - 1 - k : srcStart + k;
+  const at = (k) => reverse ? start + srcLen - 1 - k : start + k;
+  if (dstLen >= srcLen) {
+    for (let i = 0; i < dstLen; i++) {
+      taps.push([[at(halftoneNearest(i, srcLen, dstLen)), 1]]);
+    }
+    return taps;
+  }
+  const step = Math.ceil(srcLen * FIX / dstLen);
   for (let i = 0; i < dstLen; i++) {
-    const a = i * srcLen;
-    const b = (i + 1) * srcLen;
-    const taps = [];
-    for (let k = Math.floor(a / dstLen); k * dstLen < b; k++) {
-      const overlap = Math.min(b, (k + 1) * dstLen) - Math.max(a, k * dstLen);
+    const a = i * step;
+    const b = (i + 1) * step;
+    const run = [];
+    for (let k = Math.floor(a / FIX); k * FIX < b && k < srcLen; k++) {
+      const overlap = Math.min(b, (k + 1) * FIX) - Math.max(a, k * FIX);
       if (overlap > 0) {
-        taps.push([at(k), overlap / srcLen]);
+        run.push([at(k), overlap]);
+      }
+    }
+    taps.push(run);
+  }
+  return taps;
+}
+var SPECKLE_OVERSHOOT = 4;
+function halftoneDespeckle(px, w, h) {
+  const src = px.slice();
+  const at = (x, y, c) => src[(y * w + x) * 3 + c];
+  const over = (v) => v < -SPECKLE_OVERSHOOT * 4 || v > (255 + SPECKLE_OVERSHOOT) * 4;
+  for (let y = 0; y < h; y++) {
+    const up = y > 0 ? y - 1 : Math.min(h - 1, y + 1);
+    const down = y < h - 1 ? y + 1 : Math.max(0, y - 1);
+    for (let x = 0; x < w; x++) {
+      const left = x > 0 ? x - 1 : Math.min(w - 1, x + 1);
+      const right = x < w - 1 ? x + 1 : Math.max(0, x - 1);
+      let hClip = 0;
+      let vClip = 0;
+      for (let c = 0; c < 3; c++) {
+        const v = at(x, y, c);
+        if (over(6 * v - at(left, y, c) - at(right, y, c))) {
+          hClip++;
+        }
+        if (over(6 * v - at(x, up, c) - at(x, down, c))) {
+          vClip++;
+        }
+      }
+      if (hClip < 2 || vClip < 2) {
+        continue;
+      }
+      for (let c = 0; c < 3; c++) {
+        px[(y * w + x) * 3 + c] = at(left, y, c) + 2 * at(x, y, c) + at(right, y, c) + 2 >> 2;
       }
     }
-    out.push(taps);
   }
-  return out;
 }
-function stretchHalftone(src, sx, sy, sw, sh, dw, dh) {
+function halftoneSharpen(px, w, h) {
+  const src = px.slice();
+  const at = (x, y, c) => src[(Math.max(0, Math.min(h - 1, y)) * w + Math.max(0, Math.min(w - 1, x))) * 3 + c];
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      for (let c = 0; c < 3; c++) {
+        const v = at(x, y, c);
+        const sum = at(x - 1, y, c) + at(x + 1, y, c) + at(x, y - 1, c) + at(x, y + 1, c);
+        const out = v + Math.floor((4 * v - sum) / 8);
+        px[(y * w + x) * 3 + c] = out < 0 ? 0 : out > 255 ? 255 : out;
+      }
+    }
+  }
+}
+function stretchHalftone(src, sx, sy, sw, sh, dw, dh, adjust) {
   const W = Math.max(0, Math.round(Math.abs(dw)));
   const H = Math.max(0, Math.round(Math.abs(dh)));
+  const SW = Math.round(Math.abs(sw));
+  const SH = Math.round(Math.abs(sh));
+  const x0 = Math.round(Math.min(sx, sx + sw));
+  const y0 = Math.round(Math.min(sy, sy + sh));
   const flipX = dw < 0 !== sw < 0;
   const flipY = dh < 0 !== sh < 0;
-  const cols = axisBoxWeights(Math.round(Math.min(sx, sx + sw)), Math.round(Math.abs(sw)), W, flipX);
-  const rows = axisBoxWeights(Math.round(Math.min(sy, sy + sh)), Math.round(Math.abs(sh)), H, flipY);
   const data = new Uint8ClampedArray(W * H * 4);
-  const s = src.data;
+  if (W === 0 || H === 0 || SW === 0 || SH === 0) {
+    return { width: W, height: H, data };
+  }
+  const rect = new Int32Array(SW * SH * 3);
+  for (let y = 0; y < SH; y++) {
+    const yy = y0 + y;
+    for (let x = 0; x < SW; x++) {
+      const xx = x0 + x;
+      if (yy < 0 || yy >= src.height || xx < 0 || xx >= src.width) {
+        continue;
+      }
+      const i = (yy * src.width + xx) * 4;
+      const o = (y * SW + x) * 3;
+      rect[o] = src.data[i];
+      rect[o + 1] = src.data[i + 1];
+      rect[o + 2] = src.data[i + 2];
+    }
+  }
+  const enlarging = W >= SW && H >= SH && (W > SW || H > SH);
+  const reducing = W < SW && H < SH;
+  if (enlarging) {
+    halftoneDespeckle(rect, SW, SH);
+  }
+  if (adjust) {
+    adjust(rect);
+  }
+  const cols = halftoneAxis(0, SW, W, flipX);
+  const rows = halftoneAxis(0, SH, H, flipY);
+  const out = new Int32Array(W * H * 3);
   for (let y = 0; y < H; y++) {
-    const ys = rows[y] ?? [];
+    const ys = rows[y];
     for (let x = 0; x < W; x++) {
-      const xs = cols[x] ?? [];
+      const xs = cols[x];
       let r = 0;
       let g = 0;
       let b = 0;
+      let total = 0;
       for (const [yy, wy] of ys) {
-        if (yy < 0 || yy >= src.height) {
-          continue;
-        }
         for (const [xx, wx] of xs) {
-          if (xx < 0 || xx >= src.width) {
-            continue;
-          }
           const w = wx * wy;
-          const i = (yy * src.width + xx) * 4;
-          r += s[i] * w;
-          g += s[i + 1] * w;
-          b += s[i + 2] * w;
+          total += w;
+          const i = (yy * SW + xx) * 3;
+          r += rect[i] * w;
+          g += rect[i + 1] * w;
+          b += rect[i + 2] * w;
         }
       }
-      const o = (y * W + x) * 4;
-      data[o] = Math.floor(r + 1e-6);
-      data[o + 1] = Math.floor(g + 1e-6);
-      data[o + 2] = Math.floor(b + 1e-6);
-      data[o + 3] = 255;
+      const o = (y * W + x) * 3;
+      out[o] = Math.floor((2 * r + total) / (2 * total));
+      out[o + 1] = Math.floor((2 * g + total) / (2 * total));
+      out[o + 2] = Math.floor((2 * b + total) / (2 * total));
     }
   }
+  if (reducing) {
+    halftoneSharpen(out, W, H);
+  }
+  for (let i = 0, o = 0; i < W * H; i++, o += 3) {
+    data[i * 4] = out[o];
+    data[i * 4 + 1] = out[o + 1];
+    data[i * 4 + 2] = out[o + 2];
+    data[i * 4 + 3] = 255;
+  }
   return { width: W, height: H, data };
 }
 
@@ -20226,7 +20502,7 @@ function patternOperand(rCtx, brush) {
 function drawSourceMapped(target, decoded, req, offsetX, offsetY, mode) {
   const dLeft = Math.min(req.dx, req.dx + req.dw) - offsetX;
   const dTop = Math.min(req.dy, req.dy + req.dh) - offsetY;
-  const px = mode === HALFTONE ? stretchHalftone(decoded.pixels, req.sx, req.sy, req.sw, req.sh, req.dw, req.dh) : stretchGdi(decoded.pixels, req.sx, req.sy, req.sw, req.sh, req.dw, req.dh, mode);
+  const px = mode === HALFTONE ? stretchHalftone(decoded.pixels, req.sx, req.sy, req.sw, req.sh, req.dw, req.dh, decoded.adjust) : stretchGdi(decoded.pixels, req.sx, req.sy, req.sw, req.sh, req.dw, req.dh, mode);
   if (px.width === 0 || px.height === 0) {
     return;
   }
@@ -20254,15 +20530,14 @@ function decodeSource(rCtx, req) {
   if (!image) {
     return null;
   }
-  if (req.stretch && rCtx.state.stretchBltMode === HALFTONE) {
-    applyColorAdjustment(image, rCtx.state.colorAdjustment);
-  }
+  const ca = rCtx.state.colorAdjustment;
+  const adjust = req.stretch && rCtx.state.stretchBltMode === HALFTONE && ca ? (rgb2) => colorAdjustRgb(rgb2, ca) : void 0;
   let { sy } = req;
   if (req.dibOrigin === "bottom-left" && rCtx.view.getInt32(req.source.bmi + 8, true) > 0) {
     sy = image.height - sy - req.sh;
   }
   return {
-    decoded: { pixels: image },
+    decoded: { pixels: image, adjust },
     req: { ...req, sy }
   };
 }
@@ -20418,6 +20693,9 @@ function executeRotatedBlit(rCtx, logDx, logDy, logDw, logDh, rop, source, sx, s
       return;
     }
     src = decoded.decoded.pixels;
+    if (decoded.decoded.adjust) {
+      applyColorAdjustment(src, rCtx.state.colorAdjustment);
+    }
     srcX = decoded.req.sx;
     srcY = decoded.req.sy;
   }
@@ -22773,9 +23051,12 @@ function handlePoly(rCtx, recType, count, readPt, kinds) {
     }
   };
   if (inPath) {
+    if (isTo) {
+      continueFigure(rCtx);
+    }
     build(gdiPathRecorder(rCtx));
     rCtx.rasterPath ?? (rCtx.rasterPath = new GdiRasterPath());
-    buildRaster(rCtx.rasterPath, isTo && rCtx.rasterPath.figures.length === 0 ? currentFix(rCtx) : null);
+    buildRaster(rCtx.rasterPath, null);
   } else {
     const from = isTo ? currentFix(rCtx) : null;
     const start = isTo ? gmapPoint(rCtx, state.curX, state.curY) : null;
@@ -22798,10 +23079,11 @@ function handlePoly(rCtx, recType, count, readPt, kinds) {
       fillRule: state.polyFillMode === 2 ? "nonzero" : "evenodd"
     });
   }
-  if (count > 0) {
+  if (isTo && count > 0) {
     const [x, y] = readPt(count - 1);
     state.curX = x;
     state.curY = y;
+    rCtx.curFix = void 0;
   }
 }
 function handlePoly32(rCtx, recType, offset, dataOff, recSize) {
@@ -22906,9 +23188,11 @@ function handlePolyDraw(rCtx, offset, dataOff, recSize, pointSize) {
   };
   const startsWithMove = (typeAt(0) & ~PT_CLOSEFIGURE) === PT_MOVETO;
   if (inPath) {
+    if (!startsWithMove) {
+      continueFigure(rCtx);
+    }
     rCtx.rasterPath ?? (rCtx.rasterPath = new GdiRasterPath());
-    const fresh = rCtx.rasterPath.figures.length === 0;
-    walk2(gdiPathRecorder(rCtx), rCtx.rasterPath, !startsWithMove && fresh ? currentFix(rCtx) : null, null);
+    walk2(gdiPathRecorder(rCtx), rCtx.rasterPath, null, null);
   } else {
     const from = startsWithMove ? null : currentFix(rCtx);
     const fromPx = startsWithMove ? null : gmapPoint(rCtx, state.curX, state.curY);
@@ -23879,12 +24163,12 @@ function hslToRgb(h, s, l) {
   const [r, g, b] = hp < 1 ? [c, x, 0] : hp < 2 ? [x, c, 0] : hp < 3 ? [0, c, x] : hp < 4 ? [0, x, c] : hp < 5 ? [x, 0, c] : [c, 0, x];
   return [r + m, g + m, b + m];
 }
-function applyHueSaturationLightness(src, hue, saturation, lightness) {
+function applyHueSaturationLightness(src, hue, saturation, lightness2) {
   const out = new Uint8ClampedArray(src);
   const push = (v, t) => t >= 0 ? v + (1 - v) * (t / 100) : v * (1 + t / 100);
   for (let i = 0; i < src.length; i += 4) {
     const [h, s, l] = rgbToHsl(src[i] / 255, src[i + 1] / 255, src[i + 2] / 255);
-    const [r, g, b] = hslToRgb(h + hue, push(s, saturation), push(l, lightness));
+    const [r, g, b] = hslToRgb(h + hue, push(s, saturation), push(l, lightness2));
     out[i] = Math.round(r * 255);
     out[i + 1] = Math.round(g * 255);
     out[i + 2] = Math.round(b * 255);
@@ -24575,6 +24859,7 @@ function strokePlusGeometry(rCtx, pen, buildPath, points, closedFigure = false)
     }
   };
   if (pen) {
+    const nibDashed = !!nib && penDashArray(pen).length > 0;
     applyPlusPenStyle(ctx, pen, widthScale);
     const mode = plusRasterMode(rCtx);
     let sampler = pen.brush && !isSvgContext(ctx) ? brushSampler(rCtx, pen.brush) : null;
@@ -24589,7 +24874,7 @@ function strokePlusGeometry(rCtx, pen, buildPath, points, closedFigure = false)
       if (mode !== "canvas" && size && strokeGdiplus(rCtx, pen, nib, sampler, buildPath, device, size, mode, closedFigure)) {
         return;
       }
-      const outline = hasCustomCap(pen) ? penOutlineWorld(rCtx, pen, nib, buildPath, closedFigure) : null;
+      const outline = hasCustomCap(pen) || nibDashed ? penOutlineWorld(rCtx, pen, nib, buildPath, closedFigure) : null;
       let box = null;
       if (size && outline) {
         box = deviceBounds(outline.flat(), device, size, 2);
@@ -24619,7 +24904,7 @@ function strokePlusGeometry(rCtx, pen, buildPath, points, closedFigure = false)
       }
     }
     const paint = pen.brush ? brushPaint2(rCtx, pen.brush) : pen.color;
-    if ((hasCustomCap(pen) || nib && typeof paint !== "string") && fillPenOutline(rCtx, pen, nib, paint, buildPath, closedFigure)) {
+    if ((hasCustomCap(pen) || nibDashed || nib && typeof paint !== "string") && fillPenOutline(rCtx, pen, nib, paint, buildPath, closedFigure)) {
       return;
     }
     ctx.strokeStyle = paint;
@@ -24641,7 +24926,9 @@ function resolvePenTransform(pen) {
     return { pen: { ...plain, width: pen.width === 0 ? 1 : pen.width }, nib: null };
   }
   if (Math.abs(sx - sy) <= 1e-6 * sx && Math.abs(dot) <= 1e-6 * sx * sy) {
-    return { pen: { ...plain, width: pen.width * sx }, nib: null };
+    const pattern = pen.dashStyle === 5 ? pen.dashPattern : DASH_PATTERNS[pen.dashStyle];
+    const dashed = pattern && pattern.length > 0 ? { dashStyle: 5, dashPattern: pattern.map((v) => v / sx), dashOffset: (pen.dashOffset ?? 0) / sx } : {};
+    return { pen: { ...plain, ...dashed, width: pen.width * sx }, nib: null };
   }
   return { pen: plain, nib: [a, b, c, d, 0, 0] };
 }
@@ -24666,7 +24953,7 @@ function penFrame(device, nib) {
     toDevice: mulMatrix(full, [1 / unit, 0, 0, 1 / unit, 0, 0])
   };
 }
-function framePen(pen, unit) {
+function framePen(pen, unit, nib = null) {
   const dash = penDashArray(pen).map((v) => v * unit);
   return {
     half: (pen.width || 1) * unit / 2,
@@ -24677,6 +24964,7 @@ function framePen(pen, unit) {
     dashCap: pen.dashCap ?? 0,
     dash: dash.length > 0 ? dash : null,
     dashOffset: (pen.dashOffset ?? 0) * (pen.width || 1) * unit,
+    dashMetric: nib ? [nib[0], nib[1], nib[2], nib[3]] : void 0,
     compound: pen.compound ?? null,
     inset: pen.alignment === 1
   };
@@ -24704,7 +24992,7 @@ function strokeGdiplus(rCtx, pen, nib, sampler, buildPath, device, size, mode, c
     figures = figures.map((f) => ({ ...f, closed: true }));
   }
   const width = (pen.width || 1) * frame2.unit;
-  const devicePen = framePen(pen, frame2.unit);
+  const devicePen = framePen(pen, frame2.unit, nib);
   const antialias = mode === "gdiplus-aa";
   const toFix = (poly) => {
     const m = frame2.toDevice;
@@ -24796,7 +25084,7 @@ function penOutlineWorld(rCtx, pen, nib, buildPath, closedFigure) {
     figures = figures.map((f) => ({ ...f, closed: true }));
   }
   const width = (pen.width || 1) * frame2.unit;
-  const devicePen = framePen(pen, frame2.unit);
+  const devicePen = framePen(pen, frame2.unit, nib);
   const outline = hasCustomCap(pen) ? customCapOutline(figures, width, devicePen, pen) : widenFigures(figures, devicePen);
   const m = mulMatrix(deviceInv, frame2.toDevice);
   return outline.map((poly) => poly.map((p) => ({ x: m[0] * p.x + m[2] * p.y + m[4], y: m[1] * p.x + m[3] * p.y + m[5] })));
@@ -27364,7 +27652,8 @@ function wmfSetDibToDev(p, d, end) {
   const hv = new DataView(bmi.buffer);
   const fullH = hv.getInt32(8, true);
   hv.setInt32(8, fullH < 0 ? -scanCount : scanCount, true);
-  const [ox, oy] = deviceDest(p, dx, dy, 0, 0);
+  const [mx, oy] = deviceDest(p, dx, dy, 0, 0);
+  const ox = p.layout & 1 ? mx - w : mx;
   playStretchDibits(p, 13369376, ox, oy + (sy + h - hi), w, hi - lo, sx, lo - startScan, w, hi - lo, { bmi, bits: dib.bits }, true);
 }
 
@@ -27711,25 +28000,30 @@ function wmfRectangle(p, l, t, r, b) {
       c.beginPath();
       c.rect(cr.x, cr.y, cr.w, cr.h);
     },
-    raster: () => rectRasterPath(fixBoxOf(box)),
+    raster: () => rectRasterPath(fixBoxOf(box), clockwiseOf(p)),
     rectangle: true,
     fill: true,
     stroke: true,
     axisRect: { interior: rectInterior(p, box) }
   });
 }
+function compatCorner(p, w, h) {
+  const m = gdiDeviceMatrix(p.rCtx);
+  const cw = Math.round(Math.abs(w * m[0]) * 16);
+  const ch = Math.round(Math.abs(h * m[3]) * 16);
+  const ux = 16 * p.kx;
+  const uy = 16 * p.ky;
+  if (!penIsNull(p) && !penIsCosmetic(p.rCtx)) {
+    return [Math.round(Math.floor(cw / (2 * ux)) * 2 * ux), Math.round(Math.floor(ch / (2 * uy)) * 2 * uy)];
+  }
+  return [Math.round(Math.floor(Math.round(cw / ux) / 2) * 2 * ux), Math.round(Math.floor(Math.round(ch / uy) / 2) * 2 * uy)];
+}
 function wmfRoundRect(p, l, t, r, b, w, h) {
   const box = compatBox(p, l, t, r, b, { curved: true });
   if (box.x1 < box.x0 || box.y1 < box.y0) {
     return;
   }
-  const m = gdiDeviceMatrix(p.rCtx);
-  let cw = Math.round(Math.abs(w * m[0]) * 16);
-  let ch = Math.round(Math.abs(h * m[3]) * 16);
-  if (!penIsNull(p) && !penIsCosmetic(p.rCtx)) {
-    cw = Math.floor(cw / 32) * 32;
-    ch = Math.floor(ch / 32) * 32;
-  }
+  const [cw, ch] = compatCorner(p, w, h);
   const cr = canvasRect(box);
   paintGdiShape(p.rCtx, {
     build: (c) => {
@@ -27754,7 +28048,7 @@ 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),
+    raster: () => roundRectRasterPath(fixBoxOf(box), cw, ch, clockwiseOf(p), w === 0 || h === 0),
     roundPen: true,
     fill: true,
     stroke: true
@@ -27771,24 +28065,31 @@ function wmfEllipse(p, l, t, r, b) {
       c.beginPath();
       c.ellipse(cr.x + cr.w / 2, cr.y + cr.h / 2, cr.w / 2, cr.h / 2, 0, 0, Math.PI * 2);
     },
-    raster: () => ellipseRasterPath(fixBoxOf(box)),
+    raster: () => ellipseRasterPath(fixBoxOf(box), clockwiseOf(p)),
     roundPen: true,
     fill: true,
     stroke: true
   });
 }
-function wmfArcFamily(p, kind, l, t, r, b, xs, ys, xe, ye) {
-  const box = compatBox(p, l, t, r, b, { curved: kind !== "arc" });
+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" });
   if (box.x1 < box.x0 || box.y1 < box.y0) {
-    return;
+    return null;
   }
   const raw = compatBox(p, l, t, r, b, { exclusive: false });
-  const rdx = (box.x0 + box.x1 - raw.x0 - raw.x1) / 2;
-  const rdy = (box.y0 + box.y1 - raw.y0 - raw.y1) / 2;
-  const s0 = fixPoint(p.rCtx, xs, ys);
-  const e0 = fixPoint(p.rCtx, xe, ye);
-  const s = [s0[0] + rdx, s0[1] + rdy];
-  const e = [e0[0] + rdx, e0[1] + rdy];
+  const onBox = (v, r0, r1, b0, b1) => (b0 + b1) / 2 + (r1 !== r0 ? (v - (r0 + r1) / 2) * (b1 - b0) / (r1 - r0) : v - (r0 + r1) / 2);
+  const radial = (x, y) => {
+    const [fx, fy] = fixPoint(p.rCtx, x, y);
+    return [onBox(fx, raw.x0, raw.x1, box.x0, box.x1), onBox(fy, raw.y0, raw.y1, box.y0, box.y1)];
+  };
+  return { box, s: radial(xs, ys), e: radial(xe, ye) };
+}
+function wmfArcFamily(p, kind, l, t, r, b, xs, ys, xe, ye) {
+  const geom = compatArc(p, kind, l, t, r, b, xs, ys, xe, ye);
+  if (!geom) {
+    return;
+  }
+  const { box, s, e } = geom;
   const clockwise = p.rCtx.state.arcDirection === 2;
   const cr = canvasRect(box);
   const cx = cr.x + cr.w / 2;
@@ -27814,6 +28115,9 @@ function wmfArcFamily(p, kind, l, t, r, b, xs, ys, xe, ye) {
     stroke: true
   });
 }
+function clockwiseOf(p) {
+  return p.rCtx.state.arcDirection === 2;
+}
 function penIsNull(p) {
   return (p.rCtx.state.penStyle & 15) === PS_NULL3;
 }