emf-converter 4.8.3 → 4.8.5

package/dist/browser.mjs

@@ -11704,6 +11704,11 @@ function ellipsePoints(box, cwControls) {
   P(hCtl, full);
   P(full, rightLower);
   P(full, vMidHi);
+  if (box.halfX) {
+    for (const k of [0, 1, 2, 3, 4, 5, 12]) {
+      out[2 * k]++;
+    }
+  }
   return out;
 }
 function ellipseBeziers(l, t, r, b) {
@@ -11773,76 +11778,15 @@ function roundRectCorners(l, t, r, b, cw, ch, compatible = false, clockwise = fa
   ];
 }
 var TRIG_STEP = 2 * Math.PI / 128;
-var TRIG_NODES = [
-  1,
-  0.99879566,
-  0.99518639,
-  0.98917961,
-  0.98079146,
-  0.97003981,
-  0.95695228,
-  0.94155978,
-  0.92389844,
-  0.90401145,
-  0.88194619,
-  0.85775575,
-  0.83149879,
-  0.80323775,
-  0.77303903,
-  0.74098864,
-  0.70710648,
-  0.67151859,
-  0.63435836,
-  0.59565849,
-  0.55552672,
-  0.51405765,
-  0.47135039,
-  0.42750875,
-  0.38263811,
-  0.33684632,
-  0.29024443,
-  0.24294646,
-  0.19505974,
-  0.14670808,
-  0.0980012,
-  0.04906089,
-  0
-];
-var TRIG_TABLE = (() => {
-  const cos = [];
-  const sin = [];
-  for (let k = 0; k <= 128; k++) {
-    const q = k >> 5;
-    const i = k & 31;
-    const c = TRIG_NODES[i];
-    const s = TRIG_NODES[32 - i];
-    if (k === 128) {
-      cos.push(1);
-      sin.push(0);
-      continue;
-    }
-    cos.push([c, -s, -c, s][q]);
-    sin.push([s, c, -s, -c][q]);
-  }
-  return { cos, sin };
-})();
-function tableTrig(table) {
-  return (a) => {
-    let b = a % (2 * Math.PI);
-    if (b < 0) {
-      b += 2 * Math.PI;
-    }
-    const x = b / TRIG_STEP;
-    const i = Math.min(127, Math.floor(x));
-    const f = x - i;
-    return table[i] * (1 - f) + table[i + 1] * f;
-  };
-}
-var tableCos = tableTrig(TRIG_TABLE.cos);
-var tableSin = tableTrig(TRIG_TABLE.sin);
+var tableCos = (angle) => polygonTrig(angle)[0];
+var tableSin = (angle) => polygonTrig(angle)[1];
 function angleArcPieces(startDeg, sweepDeg) {
   const out = [];
   const arc = (from, to) => {
+    if (Math.abs(to - from) < 90) {
+      out.push({ from, to, first: true });
+      return;
+    }
     const lo = Math.min(from, to);
     const hi = Math.max(from, to);
     const pieces = Math.floor(hi / 90) - Math.floor(lo / 90) + 1;
@@ -11891,7 +11835,8 @@ function angleArcFix(box, startDeg, sweepDeg) {
   const E = ellipseBeziers(l, t, l + w, t + h);
   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))];
+  const startUnit = Math.abs(sweepDeg) <= 3 ? [Math.cos(start), Math.sin(start)] : polygonTrig(start);
+  const out = [Math.round(cx + w / 2 * startUnit[0]), Math.round(cy - h / 2 * startUnit[1])];
   for (const p of angleArcPieces(startDeg, sweepDeg)) {
     const span = p.to - p.from;
     if (!p.first && Math.abs(span) === 90 && p.from % 90 === 0) {
@@ -11904,43 +11849,80 @@ function angleArcFix(box, startDeg, sweepDeg) {
       }
       continue;
     }
-    for (const v of circularArcBezier(cx, cy, w / 2, h / 2, p.from, p.to)) {
-      out.push(Math.round(v));
+    const piece = unitPiece(p.from * Math.PI / 180, p.to * Math.PI / 180, Math.abs(sweepDeg) <= 3);
+    for (let i = 0; i < 6; i += 2) {
+      out.push(Math.round(cx + w / 2 * piece.ctrl[i]), Math.round(cy - h / 2 * piece.ctrl[i + 1]));
     }
   }
   return out;
 }
 var SMALL_SWEEP = 3 * Math.PI / 180;
-function anchoredPiece(boundary, free, rx, ry, cx, cy, smallArc) {
-  const sweep = Math.abs(free - boundary);
-  const small = smallArc;
-  const cos = small ? Math.cos : tableCos;
-  const sin = small ? Math.sin : tableSin;
-  const anchor = [Math.round(cx + rx * Math.cos(boundary)), Math.round(cy - ry * Math.sin(boundary))];
-  const point = [cx + rx * cos(free), cy - ry * sin(free)];
-  let t;
-  let kappa;
-  if (small) {
-    t = Math.tan(sweep / 2);
-    kappa = 2 / 3 * (1 - Math.tan(sweep / 4) ** 2);
+var POLYGON_NODES = (() => {
+  const cos = [];
+  const sin = [];
+  for (let k = 0; k <= 129; k++) {
+    cos.push(Math.cos(k * TRIG_STEP));
+    sin.push(Math.sin(k * TRIG_STEP));
+  }
+  for (let k = 0; k <= 128; k += 32) {
+    cos[k] = [1, 0, -1, 0, 1][k / 32];
+    sin[k] = [0, 1, 0, -1, 0][k / 32];
+  }
+  return { cos, sin };
+})();
+function polygonTrig(angle) {
+  let b = angle % (2 * Math.PI);
+  if (b < 0) {
+    b += 2 * Math.PI;
+  }
+  const x = b / TRIG_STEP;
+  const i = Math.min(127, Math.floor(x));
+  const f = x - i;
+  return [
+    POLYGON_NODES.cos[i] * (1 - f) + POLYGON_NODES.cos[i + 1] * f,
+    POLYGON_NODES.sin[i] * (1 - f) + POLYGON_NODES.sin[i + 1] * f
+  ];
+}
+var ATAN_KNOTS = Array.from({ length: 33 }, (_, j) => Math.atan(j / 32));
+function interpolatedAtan(t) {
+  const x = t * 32;
+  const j = Math.min(31, Math.floor(x));
+  return ATAN_KNOTS[j] + (ATAN_KNOTS[j + 1] - ATAN_KNOTS[j]) * (x - j);
+}
+function approximateArcAngle(x, y) {
+  const ax = Math.abs(x);
+  const ay = Math.abs(y);
+  if (ax === 0 && ay === 0) {
+    return 0;
+  }
+  const a = ay <= ax ? interpolatedAtan(ay / ax) : Math.PI / 2 - interpolatedAtan(ax / ay);
+  if (x >= 0) {
+    return y >= 0 ? a : 2 * Math.PI - a;
+  }
+  return y >= 0 ? Math.PI - a : Math.PI + a;
+}
+function unitPiece(from, to, small) {
+  const trig = small ? (a) => [Math.cos(a), Math.sin(a)] : polygonTrig;
+  const p0 = trig(from);
+  const p3 = trig(to);
+  const det = p0[0] * p3[1] - p0[1] * p3[0];
+  let ctrl;
+  if (Math.abs(det) < 1e-12) {
+    ctrl = [p0[0], p0[1], p3[0], p3[1], p3[0], p3[1]];
   } else {
-    const c = tableCos(sweep);
-    const sn = tableSin(sweep);
-    t = (1 - c) / sn;
-    const q = t / (1 + Math.sqrt(1 + t * t));
-    kappa = 2 / 3 * (1 - q * q);
-  }
-  const dir = free > boundary ? 1 : -1;
-  const tx = -Math.round(Math.sin(boundary));
-  const ty = -Math.round(Math.cos(boundary));
-  const length = tx !== 0 ? rx : ry;
-  const X = [anchor[0] + dir * tx * length * t, anchor[1] + dir * ty * length * t];
-  return {
-    anchor,
-    free: point,
-    cAnchor: [anchor[0] + kappa * (X[0] - anchor[0]), anchor[1] + kappa * (X[1] - anchor[1])],
-    cFree: [point[0] + kappa * (X[0] - point[0]), point[1] + kappa * (X[1] - point[1])]
-  };
+    const X = [(p3[1] - p0[1]) / det, (p0[0] - p3[0]) / det];
+    const c = polygonTrig(Math.abs(to - from) / 2)[0];
+    const kappa = 4 / 3 * c / (1 + c);
+    ctrl = [
+      p0[0] + kappa * (X[0] - p0[0]),
+      p0[1] + kappa * (X[1] - p0[1]),
+      p3[0] + kappa * (X[0] - p3[0]),
+      p3[1] + kappa * (X[1] - p3[1]),
+      p3[0],
+      p3[1]
+    ];
+  }
+  return { start: p0, ctrl };
 }
 function arcBeziers(l, t, r, b, xs, ys, xe, ye, clockwise) {
   const w = r - l;
@@ -11952,24 +11934,30 @@ function arcBeziers(l, t, r, b, xs, ys, xe, ye, clockwise) {
   const cy = t + Math.ceil(h / 2);
   const tcx = (l + r) / 2;
   const tcy = (t + b) / 2;
-  const angle = (x, y) => Math.atan2(-(y - tcy) / (h / 2 || 1), (x - tcx) / (w / 2 || 1));
+  const angle = (x, y) => approximateArcAngle((x - tcx) / (w / 2 || 1), -(y - tcy) / (h / 2 || 1));
   const a0 = angle(xs, ys);
   let a1 = angle(xe, ye);
+  const small = a1 !== a0 && Math.abs(a1 - a0) <= SMALL_SWEEP;
   const s = clockwise ? -1 : 1;
   if (s > 0) {
     while (a1 <= a0) a1 += 2 * Math.PI;
   } else {
     while (a1 >= a0) a1 -= 2 * Math.PI;
   }
-  const px = (a2) => cx + rx * tableCos(a2);
-  const py = (a2) => cy - ry * tableSin(a2);
+  const px = (u) => Math.round(cx + rx * u);
+  const py = (v) => Math.round(cy - ry * v);
   const E = clockwise ? clockwiseEllipseBeziersBox(axisBox(l, t, r, b)) : ellipseBeziers(l, t, r, b);
-  const out = [Math.round(px(a0)), Math.round(py(a0))];
+  const startUnit = small ? [Math.cos(a0), Math.sin(a0)] : polygonTrig(a0);
+  const out = [px(startUnit[0]), py(startUnit[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;
     const onBoundary = Math.abs(a / Q - Math.round(a / Q)) < 1e-9;
-    if (onBoundary && (s > 0 ? next <= a1 + 1e-12 : next >= a1 - 1e-12)) {
+    const reachesEnd = s > 0 ? next >= a1 - 1e-12 : next <= a1 + 1e-12;
+    const quadrantFrom = (Math.round(a / Q) % 4 + 4) % 4;
+    const quadrantTo = (Math.round(next / Q) % 4 + 4) % 4;
+    const generic = guard === 0 && (s > 0 ? quadrantFrom === 0 || quadrantFrom === 3 : quadrantFrom === 0 || quadrantFrom === 1) || reachesEnd && (s > 0 ? quadrantTo === 1 || quadrantTo === 2 : quadrantTo === 2 || quadrantTo === 3);
+    if (!generic && onBoundary && (s > 0 ? next <= a1 + 1e-12 : next >= a1 - 1e-12)) {
       const qi = (Math.round(Math.min(a, next) / Q) % 4 + 4) % 4 * 6;
       if (s > 0) {
         out.push(E[qi + 2], E[qi + 3], E[qi + 4], E[qi + 5], E[qi + 6], E[qi + 7]);
@@ -11980,30 +11968,10 @@ function arcBeziers(l, t, r, b, xs, ys, xe, ye, clockwise) {
       continue;
     }
     const e = s > 0 ? Math.min(next, a1) : Math.max(next, a1);
-    const endOnBoundary = Math.abs(e / Q - Math.round(e / Q)) < 1e-9;
-    if (onBoundary !== endOnBoundary) {
-      const piece = anchoredPiece(onBoundary ? a : e, onBoundary ? e : a, rx, ry, cx, cy, Math.abs(a1 - a0) <= SMALL_SWEEP);
-      if (onBoundary) {
-        out.push(...[piece.cAnchor, piece.cFree, piece.free].flatMap((q) => [Math.round(q[0]), Math.round(q[1])]));
-      } else {
-        if (out.length === 2) {
-          out[0] = Math.round(piece.free[0]);
-          out[1] = Math.round(piece.free[1]);
-        }
-        out.push(...[piece.cFree, piece.cAnchor, piece.anchor].flatMap((q) => [Math.round(q[0]), Math.round(q[1])]));
-      }
-      a = e;
-      continue;
+    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]));
     }
-    const k = 4 / 3 * Math.tan((e - a) / 4);
-    out.push(
-      Math.round(px(a) - k * rx * tableSin(a)),
-      Math.round(py(a) - k * ry * tableCos(a)),
-      Math.round(px(e) + k * rx * tableSin(e)),
-      Math.round(py(e) + k * ry * tableCos(e)),
-      Math.round(px(e)),
-      Math.round(py(e))
-    );
     a = e;
   }
   return out;
@@ -16808,14 +16776,21 @@ function blurKernel(radius) {
     k[0] = 1;
     return k;
   }
-  let sum = 0;
-  for (let i = -taps; i <= taps; i++) {
-    const w = Math.exp(-1.96 * i * i / (radius * radius));
-    k[i + taps] = w;
-    sum += w;
-  }
-  for (let i = 0; i < k.length; i++) {
-    k[i] /= sum;
+  const step = truncF32(truncF32(1.4) / Math.fround(radius));
+  const w = new Float64Array(taps + 1);
+  w[0] = 1;
+  let offset = 0;
+  let sum = 1;
+  for (let i = 1; i <= taps; i++) {
+    offset = truncF32(offset + step);
+    w[i] = truncF32(Math.exp(-truncF32(offset * offset)));
+    sum = truncF32(sum + truncF32(2 * w[i]));
+  }
+  const scale = truncF32(256 / sum);
+  for (let i = 0; i <= taps; i++) {
+    const weight = truncF32(w[i] * scale) / 256;
+    k[taps + i] = weight;
+    k[taps - i] = weight;
   }
   return k;
 }
@@ -29841,6 +29816,11 @@ function roundRectDeviceBeziers(box, cw, ch, clockwise = false, compatible = fal
   for (let i = 0; i < q.length; i += 2) {
     pts.push(...map(q[i], clockwise ? f.t + f.b - q[i + 1] : q[i + 1]));
   }
+  if (box.halfX && !clockwise) {
+    for (const k of [1, 2, 3, 4, 5, 6, 8, 15]) {
+      pts[2 * k]++;
+    }
+  }
   return pts;
 }
 function roundRectRasterPath(box, cw, ch, clockwise = false, rectangle = false, compatible = false) {
@@ -30922,6 +30902,51 @@ function fixExtent(rCtx, v, axis) {
   const k = axis === 0 ? Math.hypot(m[0], m[1]) : Math.hypot(m[2], m[3]);
   return Math.round(Math.abs(v) * k * 16);
 }
+var PS_INSIDEFRAME = 6;
+function insideFrameInset(rCtx, box, rectangle = false) {
+  if ((rCtx.state.penStyle & 15) !== PS_INSIDEFRAME || !isAxisBox(box) || hasWorldRotation(rCtx)) {
+    return null;
+  }
+  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 null;
+  }
+  const wx = Math.round(widthX);
+  const wy = Math.round(widthY);
+  if (Math.abs(box.exx) / px < wx || Math.abs(box.eyy) / py < wy) {
+    return null;
+  }
+  const lo = Math.floor(wx / 2);
+  const hi = Math.ceil(wx / 2);
+  const y = Math.round(Math.ceil(wy / 2) * py);
+  return {
+    left: Math.round((rectangle ? hi : lo) * px),
+    right: Math.round((rectangle ? lo : hi) * px),
+    top: y,
+    bottom: y,
+    half: wx % 2 === 1 && !rectangle
+  };
+}
+function insetFixBox(box, inset) {
+  const sx = box.exx < 0 ? -1 : 1;
+  const sy = box.eyy < 0 ? -1 : 1;
+  const framed = {
+    ax: box.ax + sx * inset.left,
+    ay: box.ay + sy * inset.top,
+    exx: box.exx - sx * (inset.left + inset.right),
+    exy: 0,
+    eyx: 0,
+    eyy: box.eyy - sy * (inset.top + inset.bottom)
+  };
+  if (inset.half && sx > 0) {
+    framed.halfX = true;
+  }
+  return framed;
+}
 function handleSetPixelV(rCtx, dataOff, recSize) {
   const { ctx, view } = rCtx;
   if (recSize >= 20) {
@@ -30994,7 +31019,9 @@ 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 = uprightFixBox(rCtx, l, t, r, b);
+    const unframed = uprightFixBox(rCtx, l, t, r, b);
+    const inset = insideFrameInset(rCtx, unframed, true);
+    const box = inset ? insetFixBox(unframed, inset) : unframed;
     const clockwise = rCtx.state.arcDirection === 2;
     if (!inPath) {
       resetLineStyle(rCtx);
@@ -31029,10 +31056,16 @@ function handleRectangle(rCtx, dataOff, recSize) {
       }
       return true;
     }
-    const x = gmx(rCtx, l);
-    const y = gmy(rCtx, t);
-    const w = gmw(rCtx, r - l);
-    const h = gmh(rCtx, b - t);
+    let x = gmx(rCtx, l);
+    let y = gmy(rCtx, t);
+    let w = gmw(rCtx, r - l);
+    let h = gmh(rCtx, b - t);
+    if (inset) {
+      x = Math.min(box.ax, box.ax + box.exx) / 16;
+      y = Math.min(box.ay, box.ay + box.eyy) / 16;
+      w = Math.abs(box.exx) / 16;
+      h = Math.abs(box.eyy) / 16;
+    }
     if (inPath) {
       recordRectangle(rCtx, box, clockwise);
     } else if (needsPathBasedRectangle(rCtx)) {
@@ -31144,7 +31177,26 @@ function handleRoundRect(rCtx, dataOff, recSize) {
     const b = view.getInt32(dataOff + 12, true);
     const cornerW = view.getInt32(dataOff + 16, true);
     const cornerH = view.getInt32(dataOff + 20, true);
-    const drawRoundRect = hasWorldRotation(rCtx) ? (c) => appendRoundRectPath(c, l, t, r, b, cornerW / 2, cornerH / 2, (x, y) => gmapPoint(rCtx, x, y)) : (c) => appendRoundRectPath(
+    const clockwise = rCtx.state.arcDirection === 2;
+    const unframed = uprightFixBox(rCtx, l, t, r, b);
+    const inset = insideFrameInset(rCtx, unframed);
+    const framed = inset ? insetFixBox(unframed, inset) : unframed;
+    const devM = gdiDeviceMatrix(rCtx);
+    const cornerFixW = inset ? Math.abs(cornerW * devM[0]) * 16 : fixExtent(rCtx, cornerW, 0);
+    const cornerFixH = inset ? Math.abs(cornerH * devM[3]) * 16 : fixExtent(rCtx, cornerH, 1);
+    const cornerOnFrame = (fix, size, framedSize) => inset && size !== 0 ? Math.floor(Math.min(fix, size) * framedSize / size) : fix;
+    const cw = cornerOnFrame(cornerFixW, Math.abs((r - l) * devM[0]) * 16, Math.abs(framed.exx));
+    const ch = cornerOnFrame(cornerFixH, Math.abs((b - t) * devM[3]) * 16, Math.abs(framed.eyy));
+    const drawRoundRect = inset ? (c) => appendRoundRectPath(
+      c,
+      Math.min(framed.ax, framed.ax + framed.exx) / 16,
+      Math.min(framed.ay, framed.ay + framed.eyy) / 16,
+      Math.max(framed.ax, framed.ax + framed.exx) / 16,
+      Math.max(framed.ay, framed.ay + framed.eyy) / 16,
+      cw / 32,
+      ch / 32,
+      null
+    ) : hasWorldRotation(rCtx) ? (c) => appendRoundRectPath(c, l, t, r, b, cornerW / 2, cornerH / 2, (x, y) => gmapPoint(rCtx, x, y)) : (c) => appendRoundRectPath(
       c,
       gmx(rCtx, l),
       gmy(rCtx, t),
@@ -31154,13 +31206,12 @@ function handleRoundRect(rCtx, dataOff, recSize) {
       gmh(rCtx, cornerH) / 2,
       null
     );
-    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);
+    const raster = (box = framed) => roundRectRasterPath(box, cw, ch, clockwise, cornerW === 0 || cornerH === 0);
     if (inPath) {
-      const box = uprightFixBox(rCtx, l, t, r, b);
+      const box = framed;
       if (cornerW === 0 || cornerH === 0) recordRectangle(rCtx, box, clockwise);
       else {
-        recordBezierShape(rCtx, roundRectDeviceBeziers(box, fixExtent(rCtx, cornerW, 0), fixExtent(rCtx, cornerH, 1), clockwise), 8);
+        recordBezierShape(rCtx, roundRectDeviceBeziers(box, cw, ch, clockwise), 8);
         rasterPathOf(rCtx).append(raster(box));
       }
     } else {
@@ -31170,7 +31221,7 @@ function handleRoundRect(rCtx, dataOff, recSize) {
           c.beginPath();
           drawRoundRect(c);
         },
-        raster: () => raster(curvedFixBox(rCtx, l, t, r, b, true)),
+        raster: () => raster(inset ? framed : curvedFixBox(rCtx, l, t, r, b, true)),
         roundPen: true,
         fill: true,
         stroke: true
@@ -31207,7 +31258,10 @@ function handleEllipse(rCtx, dataOff, recSize) {
     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) : {
+    const unframed = uprightFixBox(rCtx, l, t, r, b);
+    const inset = insideFrameInset(rCtx, unframed);
+    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),
       cy: gmy(rCtx, (t + b) / 2),
       rx: Math.abs(gmw(rCtx, r - l)) / 2,
@@ -31215,7 +31269,7 @@ function handleEllipse(rCtx, dataOff, recSize) {
       rotation: 0
     };
     if (inPath) {
-      const box = uprightFixBox(rCtx, l, t, r, b);
+      const box = framed;
       recordBezierShape(rCtx, ellipseBeziersBox(box, clockwise), 6);
       rasterPathOf(rCtx).append(ellipseRasterPath(box, clockwise));
     } else {
@@ -31225,7 +31279,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, true), clockwise),
+        raster: () => ellipseRasterPath(inset ? framed : curvedFixBox(rCtx, l, t, r, b, true), clockwise),
         roundPen: true,
         fill: true,
         stroke: true
@@ -31252,7 +31306,10 @@ function handleArcFamily(rCtx, recType, dataOff, recSize) {
     const startAngle = Math.atan2((startY - cyA) / (ry || 1), (startX - cxA) / (rx || 1));
     const endAngle = Math.atan2((endY - cyA) / (ry || 1), (endX - cxA) / (rx || 1));
     const rotated = hasWorldRotation(rCtx);
-    const params = rotated ? gdiEllipseParams(rCtx, cxA, cyA, rx, ry) : {
+    const unframed = fixBox(rCtx, l, t, r, b);
+    const inset = insideFrameInset(rCtx, unframed);
+    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),
       cy: gmy(rCtx, cyA),
       rx: Math.abs(gmw(rCtx, rx)),
@@ -31276,10 +31333,18 @@ function handleArcFamily(rCtx, recType, dataOff, recSize) {
       }
     };
     const kind = isArcTo ? "arcto" : recType === EMR_PIE ? "pie" : recType === EMR_CHORD ? "chord" : "arc";
+    const radialOnBox = (p) => {
+      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 rasterArgs = (immediate = false) => ({
-      box: immediate && needsFill ? curvedFixBox(rCtx, l, t, r, b) : fixBox(rCtx, l, t, r, b),
-      s: fixPoint(rCtx, startX, startY),
-      e: fixPoint(rCtx, endX, endY),
+      box: inset ? framed : immediate && needsFill ? curvedFixBox(rCtx, l, t, r, b) : unframed,
+      s: radialOnBox(fixPoint(rCtx, startX, startY)),
+      e: radialOnBox(fixPoint(rCtx, endX, endY)),
       from: currentFix(rCtx)
     });
     if (inPath) {
@@ -39314,7 +39379,7 @@ function wmfExtFloodFill(p, x, y, colorRef, type) {
 
 // src/wmf-shapes.ts
 var PS_NULL3 = 5;
-var PS_INSIDEFRAME = 6;
+var PS_INSIDEFRAME2 = 6;
 function compatBox(p, l, t, r, b, opts = {}) {
   const exclusive = opts.exclusive !== false;
   const a = fixPoint(p.rCtx, l, t);
@@ -39336,23 +39401,32 @@ function compatBox(p, l, t, r, b, opts = {}) {
     box.x1 -= Math.round(ux * 3 / 4);
     box.y1 -= Math.round(uy * 3 / 4);
   }
-  if ((p.rCtx.state.penStyle & 15) === PS_INSIDEFRAME) {
+  if ((p.rCtx.state.penStyle & 15) === PS_INSIDEFRAME2) {
     const w = Math.round(penDeviceWidth(p.rCtx) / p.kx);
     if (w > 1) {
       const matrix = gdiDeviceMatrix(p.rCtx);
-      const rawWidth = p.rCtx.state.penWidth * Math.sqrt(Math.abs(matrix[0] * matrix[3] - matrix[1] * matrix[2])) / p.kx;
+      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);
       box.x1 += Math.round(ux);
       box.y1 += Math.round(uy);
-      box.x0 += Math.round(rawWidth * ux / 2);
-      box.y0 += Math.round(rawWidth * uy / 2);
-      box.x1 -= Math.round(rawWidth * ux / 2);
-      box.y1 -= Math.round(rawWidth * uy / 2);
+      box.x0 += Math.round((opts.curved || opts.roundFrame ? Math.floor(wx / 2) : Math.ceil(wx / 2)) * ux / 16);
+      box.y0 += Math.round(Math.ceil(wy / 2) * uy / 16);
+      const half = !!opts.half && wx % 2 === 1;
+      box.x1 -= Math.round((half ? Math.ceil(wx / 2) : Math.floor(wx / 2)) * ux / 16);
+      box.y1 -= Math.round(Math.ceil(wy / 2) * uy / 16);
+      if (half) {
+        box.halfX = true;
+      }
     }
   }
   return box;
 }
 function fixBoxOf(box) {
-  return axisBox(box.x0, box.y0, Math.max(box.x0, box.x1), Math.max(box.y0, box.y1));
+  const fix = axisBox(box.x0, box.y0, Math.max(box.x0, box.x1), Math.max(box.y0, box.y1));
+  if (box.halfX) {
+    fix.halfX = true;
+  }
+  return fix;
 }
 function canvasRect(box) {
   return { x: box.x0 / 16, y: box.y0 / 16, w: Math.max(0, box.x1 - box.x0) / 16, h: Math.max(0, box.y1 - box.y0) / 16 };
@@ -39406,14 +39480,15 @@ function wmfRectangle(p, l, t, r, b) {
 }
 function compatCorner(p, w, h, box, logical) {
   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);
+  Math.round(Math.abs(w * m[0]) * 16);
+  Math.round(Math.abs(h * m[3]) * 16);
   const ux = 16 * p.kx;
   const uy = 16 * p.ky;
-  if ((p.rCtx.state.penStyle & 15) === PS_INSIDEFRAME && !penIsCosmetic(p.rCtx)) {
-    const penWidth = p.rCtx.state.penWidth * Math.sqrt(Math.abs(m[0] * m[3] - m[1] * m[2])) * 16;
+  if ((p.rCtx.state.penStyle & 15) === PS_INSIDEFRAME2 && !penIsCosmetic(p.rCtx)) {
     const width2 = box.x1 - box.x0, height2 = box.y1 - box.y0;
-    return [Math.floor(Math.min(cw, width2 + penWidth) * width2 / (width2 + penWidth)), Math.floor(Math.min(ch, height2 + penWidth) * height2 / (height2 + penWidth))];
+    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 width = box.x1 - box.x0, height = box.y1 - box.y0;
   const fullW = Math.abs((logical[2] - logical[0]) * m[0]) * 16 || width + ux;
@@ -39422,7 +39497,7 @@ 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 });
+  const box = compatBox(p, l, t, r, b, { curved: true, half: true });
   if (box.x1 < box.x0 || box.y1 < box.y0) {
     return;
   }
@@ -39458,7 +39533,7 @@ function wmfRoundRect(p, l, t, r, b, w, h) {
   });
 }
 function wmfEllipse(p, l, t, r, b) {
-  const box = compatBox(p, l, t, r, b, { curved: true });
+  const box = compatBox(p, l, t, r, b, { curved: true, half: true });
   if (box.x1 < box.x0 || box.y1 < box.y0) {
     return;
   }
@@ -39475,7 +39550,7 @@ function wmfEllipse(p, l, t, r, b) {
   });
 }
 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" });
+  const box = compatBox(p, l, t, r, b, { curved: kind === "chord" || kind === "pie", roundFrame: true });
   if (box.x1 < box.x0 || box.y1 < box.y0) {
     return null;
   }