emf-converter 4.8.20 → 4.9.0

package/dist/index.js

@@ -11662,11 +11662,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) {
@@ -11682,10 +11691,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;
@@ -11927,7 +11936,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;
@@ -11947,11 +11956,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;
@@ -11973,10 +11996,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 {
@@ -29615,7 +29644,7 @@ var Outliner = class {
     this.flush();
   }
 };
-function dashPieces(P, tangents, curveFlags, pattern, shorten, wholePixelVectors) {
+function dashPieces(P, tangents, curveFlags, pattern, shorten, wholePixelVectors, metric) {
   const out = [];
   const dashes = [];
   for (let i = 0; i < pattern.length; i += 2) {
@@ -29635,8 +29664,8 @@ function dashPieces(P, tangents, curveFlags, pattern, shorten, wholePixelVectors
     const [x0, y0] = P[i];
     const [x1, y1] = P[i + 1];
     const dir = [x1 - x0, y1 - y0];
-    const real = Math.hypot(dir[0], dir[1]);
-    const len = wholePixelVectors ? Math.hypot(Math.floor(dir[0] / 16), Math.floor(dir[1] / 16)) * 16 : Math.hypot(dir[0], dir[1]);
+    const real = metric ? Math.hypot(dir[0] / metric[0], dir[1] / metric[1]) : Math.hypot(dir[0], dir[1]);
+    const len = metric ? real : wholePixelVectors ? Math.hypot(Math.floor(dir[0] / 16), Math.floor(dir[1] / 16)) * 16 : Math.hypot(dir[0], dir[1]);
     if (len === 0) {
       if (on && cur) {
         cur.pts.push(P[i + 1]);
@@ -29709,10 +29738,10 @@ function widenPath(path, opts) {
     }
     if (dashed) {
       const run = closed ? [...P, P[0]] : P;
-      const shorten = opts.cap === "flat" || opts.shortenDashes === false ? 0 : opts.width;
+      const shorten = opts.cap === "flat" || opts.shortenDashes === false ? 0 : opts.dashMetric ? opts.width / opts.dashMetric[0] : opts.width;
       const runTangents = closed ? [...dirs, void 0] : dirs;
       const runCurves = closed ? [...curves, !!fig.roundWiden] : curves;
-      for (const piece of dashPieces(run, runTangents, runCurves, opts.dashes, shorten, !!opts.wholePixelDashVectors)) {
+      for (const piece of dashPieces(run, runTangents, runCurves, opts.dashes, shorten, !!opts.wholePixelDashVectors, opts.dashMetric)) {
         const pts = [piece.pts[0]];
         const pdirs = [];
         const pdraws = [];
@@ -29794,6 +29823,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]);
@@ -29840,8 +29873,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;
@@ -29884,7 +29958,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]));
@@ -29898,7 +29972,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") {
@@ -29934,8 +30008,9 @@ function penWidenOptions(rCtx, opts = {}) {
   const widthPx = rCtx.wholeDevicePixels && (flags & 15) === 6 ? state.penWidth * Math.sqrt(Math.abs(matrix[0] * matrix[3] - matrix[1] * matrix[2])) : penDeviceWidth(rCtx);
   const capBits = flags & 3840;
   const joinBits = flags & 61440;
-  const dashes = state.penExtended ? geometricStyle(flags, widthPx, state.penUserStyle, widthPx / (state.penWidth || 1)) : null;
-  const ellipse = !dashes && !rCtx.wholeDevicePixels && state.penWidth * Math.abs(matrix[0]) * 16 >= 1 && state.penWidth * Math.abs(matrix[3]) * 16 >= 1 && Math.abs(matrix[1]) < 1e-6 && Math.abs(matrix[2]) < 1e-6 && Math.abs(Math.abs(matrix[0]) - Math.abs(matrix[3])) > 1e-6;
+  const ellipse = !rCtx.wholeDevicePixels && state.penWidth * Math.abs(matrix[0]) * 16 >= 1 && state.penWidth * Math.abs(matrix[3]) * 16 >= 1 && Math.abs(matrix[1]) < 1e-6 && Math.abs(matrix[2]) < 1e-6 && Math.abs(Math.abs(matrix[0]) - Math.abs(matrix[3])) > 1e-6;
+  const dashes = state.penExtended ? ellipse ? geometricStyle(flags, state.penWidth, state.penUserStyle, 1) : geometricStyle(flags, widthPx, state.penUserStyle, widthPx / (state.penWidth || 1)) : null;
+  const dashMetric = ellipse && dashes ? [Math.abs(matrix[0]), Math.abs(matrix[3])] : void 0;
   return {
     width: Math.round((ellipse ? state.penWidth * Math.abs(matrix[0]) : widthPx) * 16),
     ...ellipse ? { height: Math.round(state.penWidth * Math.abs(matrix[3]) * 16) } : {},
@@ -29943,6 +30018,7 @@ function penWidenOptions(rCtx, opts = {}) {
     join: opts.roundPen ? "round" : opts.rectangle && !state.penExtended ? "miter" : !state.penExtended || joinBits === 0 ? "round" : joinBits === 4096 ? "bevel" : "miter",
     miterLimit: state.miterLimit ?? 10,
     dashes: dashes ? dashes.map((v) => v * 16) : null,
+    ...dashMetric ? { dashMetric } : {},
     shortenDashes: (flags & 15) !== 7,
     // One logical unit per device pixel, unrotated: GDI measures dash
     // segments in whole pixels.
@@ -30955,9 +31031,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;
@@ -30967,11 +31058,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) {
@@ -31054,7 +31149,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) {
@@ -31240,6 +31335,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;
@@ -31293,7 +31395,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),
@@ -31343,7 +31445,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),
@@ -31374,20 +31479,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) {
@@ -39684,6 +39794,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);
@@ -39697,14 +39808,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;
 }
@@ -39768,7 +39886,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;
@@ -39777,11 +39896,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) => {
@@ -39806,14 +39925,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;
   }
@@ -39829,9 +39948,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);