emf-converter 4.8.4 → 4.8.6

package/dist/index.js

@@ -11707,6 +11707,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) {
@@ -11776,76 +11781,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;
@@ -11894,7 +11838,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) {
@@ -11907,43 +11852,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;
@@ -11955,24 +11937,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]);
@@ -11983,30 +11971,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;
@@ -16567,153 +16535,26 @@ function applyTint(src, hue, amount) {
 var TINT_FULL = 254;
 function applyRedEyeCorrection(src, width, height, areas) {
   const out = new Uint8ClampedArray(src);
+  const carry = { x: 0, y: 0 };
   for (const a of areas) {
-    correctRedEyeArea(out, width, clamp(a.left, 0, width), clamp(a.top, 0, height), clamp(a.right, 0, width), clamp(a.bottom, 0, height));
+    correctRedEyeArea(out, width, clamp(a.left, 0, width), clamp(a.top, 0, height), clamp(a.right, 0, width), clamp(a.bottom, 0, height), carry);
   }
   return out;
 }
-var RED_EYE_FALLOFF = new Float64Array(
-  [
-    24930,
-    24570,
-    24201,
-    23836,
-    23471,
-    23107,
-    22744,
-    22367,
-    21976,
-    21587,
-    21198,
-    20824,
-    20490,
-    20165,
-    19832,
-    19499,
-    19157,
-    18817,
-    18480,
-    18151,
-    17820,
-    17490,
-    17160,
-    16831,
-    16506,
-    16189,
-    15878,
-    15569,
-    15273,
-    14973,
-    14668,
-    14362,
-    14059,
-    13768,
-    13484,
-    13203,
-    12923,
-    12642,
-    12366,
-    12094,
-    11828,
-    11564,
-    11301,
-    11034,
-    10770,
-    10507,
-    10253,
-    10011,
-    9771,
-    9530,
-    9290,
-    9053,
-    8819,
-    8588,
-    8359,
-    8134,
-    7914,
-    7697,
-    7481,
-    7267,
-    7056,
-    6851,
-    6651,
-    6453,
-    6256,
-    6061,
-    5871,
-    5684,
-    5499,
-    5317,
-    5138,
-    4962,
-    4789,
-    4619,
-    4452,
-    4289,
-    4130,
-    3974,
-    3820,
-    3669,
-    3520,
-    3375,
-    3232,
-    3093,
-    2958,
-    2825,
-    2695,
-    2568,
-    2444,
-    2325,
-    2207,
-    2092,
-    1980,
-    1872,
-    1768,
-    1666,
-    1567,
-    1470,
-    1377,
-    1287,
-    1200,
-    1116,
-    1034,
-    956,
-    881,
-    808,
-    739,
-    674,
-    612,
-    541,
-    462,
-    381,
-    299,
-    220,
-    147,
-    85,
-    36,
-    3,
-    0
-  ].map((v) => v / 1e5)
-);
-function redEyeFalloff(u) {
-  const t = u * 128;
-  const i = Math.floor(t);
-  if (i >= RED_EYE_FALLOFF.length - 1) {
-    return 0;
-  }
-  return RED_EYE_FALLOFF[i] + (t - i) * (RED_EYE_FALLOFF[i + 1] - RED_EYE_FALLOFF[i]);
-}
 var RED_EYE_SECTORS = 60;
 var RED_EYE_BLUE_WEIGHT = 0.225;
-var RED_EYE_WEIGHT_CAP = 6;
-var RED_EYE_PURE_WEIGHT = RED_EYE_WEIGHT_CAP;
-var RED_EYE_DARK_STRENGTH = 0.49;
-var RED_EYE_DARK_RATIO = 0.6;
-var RED_EYE_GREEN_SHARE = 80 / 255;
-function correctRedEyeArea(out, stride, x0, y0, x1, y1) {
+var RED_EYE_PURE_WEIGHT = 1 / (1 + RED_EYE_BLUE_WEIGHT);
+var RED_EYE_CARRY = 0.81;
+var RED_EYE_GREEN_SHARE = 5 / 16;
+var RED_EYE_SPREAD_STEPS = [31.5, 50, 98.78];
+var RED_EYE_STRENGTHS = [0.25, 0.5, 0.661, 0.75];
+function correctRedEyeArea(out, stride, x0, y0, x1, y1, carry) {
   const w = x1 - x0;
   const h = y1 - y0;
   const count = w * h;
+  if (!(count > 0)) {
+    return;
+  }
   const redness = new Float64Array(count);
   const dark = new Float64Array(count);
   let sx = 0;
@@ -16726,34 +16567,44 @@ function correctRedEyeArea(out, stride, x0, y0, x1, y1) {
       const g = out[i + 1];
       const b = out[i + 2];
       const k = y * w + x;
-      dark[k] = Math.min(g, b);
+      const d = g + RED_EYE_BLUE_WEIGHT * b;
+      dark[k] = d;
       const v = r - Math.max(g, b);
       if (v > 0) {
         redness[k] = v;
-        const denominator = g + RED_EYE_BLUE_WEIGHT * b;
-        {
-          const weight = denominator >= 1 ? Math.min(RED_EYE_WEIGHT_CAP, v / denominator) : RED_EYE_PURE_WEIGHT;
-          sx += weight * (x + 0.5);
-          sy += weight * (y + 0.5);
-          sw += weight;
-        }
+        const weight = d >= 1 ? v / d : RED_EYE_PURE_WEIGHT;
+        sx += weight * (x + 0.5);
+        sy += weight * (y + 0.5);
+        sw += weight;
       }
     }
   }
   if (sw === 0) {
-    if (!redness.some((v) => v > 0)) {
-      return;
-    }
-    sx = w / 2;
-    sy = h / 2;
-    sw = 1;
+    return;
   }
-  const cx = sx / sw;
-  const cy = sy / sw;
-  const radius = Math.min(cx, cy) - 0.5;
+  let cx = (sx + RED_EYE_CARRY * carry.x) / sw;
+  let cy = (sy + RED_EYE_CARRY * carry.y) / sw;
+  carry.x = x0 + cx;
+  carry.y = y0 + cy;
+  if (Math.hypot(cx - w / 2, cy - h / 2) >= Math.max(Math.min(w, h) / 2, (w + h) / 6)) {
+    cx = w / 2;
+    cy = h / 2;
+  }
+  const ax = x0 + cx;
+  const ay = y0 + cy;
+  const edgeX = Math.round(cx) > w / 2 ? w - cx + 0.5 : cx - 0.5;
+  const edgeY = Math.round(cy) > h / 2 ? h - cy + 0.5 : cy - 0.5;
+  const radius = ax > ay ? Math.min(edgeX, ay - 0.5) : Math.min(edgeY, ax - 0.5);
   if (!(radius > 0)) {
     return;
   }
+  const sorted = Float64Array.from(dark).sort();
+  const spread = sorted[Math.floor(0.7 * count)] - sorted[Math.floor(0.3 * count)];
+  let level = 0;
+  while (level < RED_EYE_SPREAD_STEPS.length && spread >= RED_EYE_SPREAD_STEPS[level]) {
+    level++;
+  }
+  const strength = RED_EYE_STRENGTHS[level];
   const sector = new Uint8Array(count);
   const distance = new Float64Array(count);
   const sectorSum = new Float64Array(RED_EYE_SECTORS);
@@ -16791,7 +16642,8 @@ function correctRedEyeArea(out, stride, x0, y0, x1, y1) {
       const mean = sectorSum[s] / sectorCount[s];
       const meanDark = sectorDark[s] / sectorCount[s];
       const ratio = meanDark > 0 ? dark[k] / meanDark : 1;
-      const falloff = Math.max(redEyeFalloff(distance[k] / radius), RED_EYE_DARK_STRENGTH * Math.max(0, 1 - ratio / RED_EYE_DARK_RATIO));
+      const u = distance[k] / radius;
+      const falloff = Math.max(strength * (1 - u) * (1 - u), 0.5 * Math.max(0, 1 - ratio) ** 2);
       const rest = (1 - falloff) * mean;
       if (rest >= v) {
         continue;
@@ -29851,6 +29703,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) {
@@ -30932,6 +30789,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) {
@@ -31004,7 +30906,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);
@@ -31039,10 +30943,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)) {
@@ -31154,7 +31064,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),
@@ -31164,13 +31093,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 {
@@ -31180,7 +31108,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
@@ -31217,7 +31145,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,
@@ -31225,7 +31156,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 {
@@ -31235,7 +31166,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
@@ -31262,7 +31193,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)),
@@ -31286,10 +31220,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) {
@@ -39324,7 +39266,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);
@@ -39346,23 +39288,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 };
@@ -39416,14 +39367,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;
@@ -39432,7 +39384,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;
   }
@@ -39468,7 +39420,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;
   }
@@ -39485,7 +39437,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;
   }