emf-converter 4.6.10 → 4.8.0

package/dist/browser.js

@@ -11775,19 +11775,73 @@ function roundRectCorners(l, t, r, b, cw, ch, compatible = false, clockwise = fa
   ];
 }
 var TRIG_STEP = 2 * Math.PI / 128;
-function tableTrig(fn) {
+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 i = Math.floor(b / TRIG_STEP);
-    const f = b / TRIG_STEP - i;
-    return fn(i * TRIG_STEP) * (1 - f) + fn((i + 1) * TRIG_STEP) * f;
+    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(Math.cos);
-var tableSin = tableTrig(Math.sin);
+var tableCos = tableTrig(TRIG_TABLE.cos);
+var tableSin = tableTrig(TRIG_TABLE.sin);
 function angleArcPieces(startDeg, sweepDeg) {
   const out = [];
   const arc = (from, to) => {
@@ -11858,6 +11912,38 @@ function angleArcFix(box, startDeg, sweepDeg) {
   }
   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);
+  } 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])]
+  };
+}
 function arcBeziers(l, t, r, b, xs, ys, xe, ye, clockwise) {
   const w = r - l;
   const h = b - t;
@@ -11896,6 +11982,21 @@ 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 k = 4 / 3 * Math.tan((e - a) / 4);
     out.push(
       Math.round(px(a) - k * rx * tableSin(a)),
@@ -11990,6 +12091,10 @@ var GdiRasterPath = class {
     };
     const t0 = tangent(x0, y0, c1x, c1y, c2x, c2y, x3, y3);
     const t1 = tangent(c2x, c2y, x3, y3, x3, y3, x3, y3) ?? tangent(c1x, c1y, x3, y3, x3, y3, x3, y3) ?? tangent(x0, y0, x3, y3, x3, y3, x3, y3);
+    f.curveSegs ?? (f.curveSegs = /* @__PURE__ */ new Set());
+    for (let k = first; k <= last; k++) {
+      f.curveSegs.add(k);
+    }
     f.tangents ?? (f.tangents = /* @__PURE__ */ new Map());
     if (t0) f.tangents.set(first, t0);
     if (t1) f.tangents.set(last, t1);
@@ -12023,7 +12128,7 @@ var GdiRasterPath = class {
   /** Appends every figure of `other`. */
   append(other) {
     for (const f of other.figures) {
-      this.figures.push({ pts: f.pts.slice(), closed: f.closed, tangents: f.tangents && new Map(f.tangents), roundWiden: f.roundWiden });
+      this.figures.push({ pts: f.pts.slice(), closed: f.closed, tangents: f.tangents && new Map(f.tangents), curveSegs: f.curveSegs && new Set(f.curveSegs), roundWiden: f.roundWiden });
     }
     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]);
@@ -16440,23 +16545,241 @@ function applyTint(src, hue, amount) {
 function applyRedEyeCorrection(src, width, height, areas) {
   const out = new Uint8ClampedArray(src);
   for (const a of areas) {
-    const x0 = clamp(a.left, 0, width);
-    const x1 = clamp(a.right, 0, width);
-    const y0 = clamp(a.top, 0, height);
-    const y1 = clamp(a.bottom, 0, height);
-    for (let y = y0; y < y1; y++) {
-      for (let x = x0; x < x1; x++) {
-        const i = (y * width + x) * 4;
-        const r = out[i];
-        const g = out[i + 1];
-        const b = out[i + 2];
-        if (r >= 2 * g && r >= 2 * b && r > 64) {
-          out[i] = Math.round((g + b) / 2);
+    correctRedEyeArea(out, width, clamp(a.left, 0, width), clamp(a.top, 0, height), clamp(a.right, 0, width), clamp(a.bottom, 0, height));
+  }
+  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) {
+  const w = x1 - x0;
+  const h = y1 - y0;
+  const count = w * h;
+  const redness = new Float64Array(count);
+  const dark = new Float64Array(count);
+  let sx = 0;
+  let sy = 0;
+  let sw = 0;
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      const i = ((y0 + y) * stride + x0 + x) * 4;
+      const r = out[i];
+      const g = out[i + 1];
+      const b = out[i + 2];
+      const k = y * w + x;
+      dark[k] = Math.min(g, b);
+      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;
         }
       }
     }
   }
-  return out;
+  if (sw === 0) {
+    if (!redness.some((v) => v > 0)) {
+      return;
+    }
+    sx = w / 2;
+    sy = h / 2;
+    sw = 1;
+  }
+  const cx = sx / sw;
+  const cy = sy / sw;
+  const radius = Math.min(cx, cy) - 0.5;
+  if (!(radius > 0)) {
+    return;
+  }
+  const sector = new Uint8Array(count);
+  const distance = new Float64Array(count);
+  const sectorSum = new Float64Array(RED_EYE_SECTORS);
+  const sectorDark = new Float64Array(RED_EYE_SECTORS);
+  const sectorCount = new Float64Array(RED_EYE_SECTORS);
+  const degrees = 180 / Math.PI;
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      const dx = x + 0.5 - cx;
+      const dy = y + 0.5 - cy;
+      const k = y * w + x;
+      const d = Math.hypot(dx, dy);
+      distance[k] = d;
+      let angle = Math.atan2(dy, dx) * degrees;
+      if (angle < 0) {
+        angle += 360;
+      }
+      const s = Math.min(RED_EYE_SECTORS - 1, Math.floor(angle / 6));
+      sector[k] = s;
+      if (d < radius) {
+        sectorSum[s] += redness[k];
+        sectorDark[s] += dark[k];
+        sectorCount[s]++;
+      }
+    }
+  }
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      const k = y * w + x;
+      const v = redness[k];
+      if (v <= 0 || distance[k] >= radius) {
+        continue;
+      }
+      const s = sector[k];
+      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 rest = (1 - falloff) * mean;
+      if (rest >= v) {
+        continue;
+      }
+      const removed = v - rest;
+      const i = ((y0 + y) * stride + x0 + x) * 4;
+      out[i] = Math.round(out[i] - (1 - RED_EYE_GREEN_SHARE) * removed);
+      out[i + 1] = Math.round(out[i + 1] + RED_EYE_GREEN_SHARE * removed);
+      out[i + 2] = Math.round(out[i + 2] + RED_EYE_GREEN_SHARE * removed);
+    }
+  }
 }
 function blurKernel(radius) {
   const taps = Math.ceil(radius);
@@ -16488,8 +16811,8 @@ function mirror(p, n) {
 function gdipBlur(src, w, h, radius, vRow = 0, vZeroAbove = false, verticalRows = Math.ceil(h / w)) {
   const k = blurKernel(radius);
   const taps = (k.length - 1) / 2;
-  const horizontalIndex = taps >= w ? (x) => Math.max(0, Math.min(w - 1, x)) : (x) => mirror(x, w);
-  const verticalIndex = taps >= h ? (y) => Math.max(0, Math.min(h - 1, y)) : (y) => mirror(y, h);
+  const horizontalIndex = (taps | 1) >= w ? (x) => Math.max(0, Math.min(w - 1, x)) : (x) => mirror(x, w);
+  const verticalIndex = (taps | 1) >= h ? (y) => Math.max(0, Math.min(h - 1, y)) : (y) => mirror(y, h);
   const out = new Float64Array(w * h * 4);
   for (let y = 0; y < h; y++) {
     const row2 = y * w * 4;
@@ -16500,11 +16823,12 @@ function gdipBlur(src, w, h, radius, vRow = 0, vZeroAbove = false, verticalRows
       let s3 = 0;
       for (let j = -taps; j <= taps; j++) {
         const p = row2 + horizontalIndex(x + j) * 4;
-        const kw = k[j + taps] * 256;
-        s0 += Math.round(kw * src[p]);
-        s1 += Math.round(kw * src[p + 1]);
-        s2 += Math.round(kw * src[p + 2]);
-        s3 += Math.round(kw * src[p + 3]);
+        const kw = j === 0 ? k[taps] * 128 : k[j + taps] * 256;
+        const times = j === 0 ? 2 : 1;
+        s0 += times * Math.round(kw * src[p]);
+        s1 += times * Math.round(kw * src[p + 1]);
+        s2 += times * Math.round(kw * src[p + 2]);
+        s3 += times * Math.round(kw * src[p + 3]);
       }
       const o = row2 + x * 4;
       out[o] = Math.floor((s0 + 128) / 256);
@@ -16524,8 +16848,10 @@ function gdipBlur(src, w, h, radius, vRow = 0, vZeroAbove = false, verticalRows
           continue;
         }
         const base = verticalIndex(yy) * w * 4;
+        const kw = j === 0 ? k[taps] * 128 : k[j + taps] * 256;
+        const times = j === 0 ? 2 : 1;
         for (let i = 0; i < w * 4; i++) {
-          col[i] += Math.round(k[j + taps] * horizontal[base + i] * 256) / 256;
+          col[i] += times * Math.round(kw * horizontal[base + i]) / 256;
         }
       }
       out.set(col, row2 * w * 4);
@@ -16540,10 +16866,12 @@ function blurAxis(length, lanes, factor, k, edgeLength, get, put, span = { start
   const inner = Math.ceil(span.size / factor);
   const n = inner + 2 * span.pad;
   const taps = (k.length - 1) / 2;
-  const index = taps >= edgeLength ? (i) => clamp(i, 0, n - 1) : (i) => mirror(i, n);
+  const index = (taps | 1) >= edgeLength ? (i) => clamp(i, 0, n - 1) : (i) => mirror(i, n);
   const reduced = new Float64Array(n);
   const filtered = new Float64Array(n);
   const k256 = k.map((w) => w * 256);
+  const half = k256[taps] / 2;
+  k256[taps] = 0;
   for (let lane = 0; lane < lanes; lane++) for (let c = 0; c < 4; c++) {
     for (let b = span.pad; b < span.pad + inner; b++) {
       const from = span.start + (b - span.pad) * factor;
@@ -16557,33 +16885,48 @@ function blurAxis(length, lanes, factor, k, edgeLength, get, put, span = { start
       if (b >= taps && b + taps < n) {
         for (let j = 0; j < k256.length; j++) sum += Math.round(k256[j] * reduced[b - taps + j]);
       } else {
-        for (let j = 0; j < k256.length; j++) sum += Math.round(k256[j] * reduced[index(b - taps + j)]);
+        for (let j = 0; j < k256.length; j++) {
+          const at = b - taps + j;
+          sum += Math.round(k256[j] * (span.zeroOutside && (at < 0 || at >= n) ? 0 : reduced[index(at)]));
+        }
       }
+      sum += 2 * Math.round(half * reduced[b]);
       filtered[b] = Math.floor((sum + 128) / 256);
     }
+    const lone = inner === 1 && span.pad > 0;
+    const skipped2 = inner === 1 && span.size - Math.ceil(factor / 2) === 1 ? span.start + span.size - 1 : -1;
     for (let i = 0; i < length; i++) {
-      const p = (i - span.start + 0.5) / factor - 0.5 + span.pad;
-      const a = clamp(Math.floor(p), 0, Math.max(0, n - 2));
+      if (i === skipped2) {
+        if (span.pad > 0) put(i, lane, c, 0);
+        continue;
+      }
+      const p = (i - span.start + 0.5) / factor - 0.5;
+      if (lone) {
+        const distance = Math.abs(i - span.start - (Math.min(span.size, factor / 2) - 0.5)) / factor;
+        put(i, lane, c, clamp(Math.floor((1 + distance) * filtered[span.pad] + 1e-9), 0, 255));
+        continue;
+      }
+      const a = clamp(Math.floor(p), 0, Math.max(0, inner - 2));
       const t = p - a;
-      put(i, lane, c, clamp(Math.floor((1 - t) * filtered[a] + t * filtered[Math.min(n - 1, a + 1)] + 1e-9), 0, 255));
+      put(i, lane, c, clamp(Math.floor((1 - t) * filtered[span.pad + a] + t * filtered[span.pad + Math.min(inner - 1, a + 1)] + 1e-9), 0, 255));
     }
   }
 }
-function effectBlur(src, width, height, radius, region) {
+function effectBlur(src, width, height, radius, region, expanded = false) {
   const factor = blurReduction(radius);
   if (factor === 1) {
     return gdipBlur(src, width, height, radius);
   }
   const k = blurKernel(radius / factor);
   const pad = region ? Math.ceil(Math.ceil(radius) / factor) : 0;
-  const spanX = region ? { start: region.x, size: region.w, pad } : void 0;
-  const spanY = region ? { start: region.y, size: region.h, pad } : void 0;
-  const rows = new Uint8Array(src.length);
-  blurAxis(width, height, factor, k, Math.floor(width / factor), (i, lane, c) => src[(lane * width + i) * 4 + c], (i, lane, c, v) => {
+  const spanX = region ? { start: region.x, size: region.w, pad, zeroOutside: true } : expanded ? { start: 0, size: width, pad: 0, zeroOutside: true } : void 0;
+  const spanY = region ? { start: region.y, size: region.h, pad, zeroOutside: true } : expanded ? { start: 0, size: height, pad: 0, zeroOutside: true } : void 0;
+  const rows = new Uint8Array(src);
+  blurAxis(width, height, factor, k, Math.ceil(width / factor), (i, lane, c) => src[(lane * width + i) * 4 + c], (i, lane, c, v) => {
     rows[(lane * width + i) * 4 + c] = v;
   }, spanX);
-  const out = new Float64Array(src.length);
-  blurAxis(height, width, factor, k, Math.floor(height / factor), (i, lane, c) => rows[(i * width + lane) * 4 + c], (i, lane, c, v) => {
+  const out = Float64Array.from(rows);
+  blurAxis(height, width, factor, k, Math.ceil(height / factor), (i, lane, c) => rows[(i * width + lane) * 4 + c], (i, lane, c, v) => {
     out[(i * width + lane) * 4 + c] = v;
   }, spanY);
   return out;
@@ -16671,7 +17014,7 @@ function expandedBlur(rgba, width, height, radius, x0, y0, x1, y1, cropped) {
     const gy1 = Math.min(height, y1 + r);
     copyBlock(rgba, width, gx0, gy0, gx1 - gx0, gy1 - gy0, buf, bw, gx0 - (x0 - r), gy0 - (y0 - r));
   }
-  const blurred = blurReduction(radius) > 1 ? effectBlur(buf, bw, bh, radius, cropped ? { x: r, y: r, w: x1 - x0, h: y1 - y0 } : void 0) : gdipBlur(buf, bw, bh, radius, cropped ? r : 0, cropped, Math.ceil((y1 - y0) / (x1 - x0)));
+  const blurred = blurReduction(radius) > 1 ? effectBlur(buf, bw, bh, radius, cropped ? { x: r, y: r, w: x1 - x0, h: y1 - y0 } : void 0, true) : gdipBlur(buf, bw, bh, radius, cropped ? r : 0, cropped, Math.ceil((y1 - y0) / (x1 - x0)));
   const w = x1 - x0;
   const out = new Uint8ClampedArray(w * (y1 - y0) * 4);
   for (let y = 0; y < y1 - y0; y++) {
@@ -28736,118 +29079,19 @@ var HOBBY = [
   [[8, -48], [-8, -48], [-24, -40], [-40, -24], [-48, -8], [-48, 8], [-40, 24], [-24, 40], [-8, 48], [8, 48], [24, 40], [40, 24], [48, 8], [48, -8], [40, -24], [24, -40]]
 ];
 var HOBBY_LIMIT = 104;
-var FLAT_SECTOR_BIAS = {
-  7: [9, "cf..", "edededEdcDcdcd"],
-  8: [9, "dFee", "ededededbdbdbd"],
-  9: [9, "df..", "ddddddddbDbdbd"],
-  10: [9, "de..", "dededeDebEbebE"],
-  11: [9, "ce..", "eeeeeeEececece"],
-  12: [13, "ce..", "eeeeeeeeeeeececEcecece"],
-  13: [17, "ce..", "eeeeededdddddeDebebebdbdcdcdce"],
-  14: [17, "df..", "ddedeeeededeeeedcDcebebecececd"],
-  15: [17, "dF..", "ddedeeeeeeeedeDdbdbecececececd"],
-  16: [17, "ce..", "eeeededededeeeeececebebebebece"],
-  17: [17, "df..", "ddedededededdeddbdbebdbdbdbdcd"],
-  18: [17, "de..", "deeededeededeeEdcDcecdcdbebece"],
-  19: [17, "cf..", "ededeeeedddddeDebEbecdcdbebecd"],
-  20: [17, "ce..", "eeeeddddeeeeddDdbdbdcecebdbdce"],
-  21: [17, "dF..", "ddddededededddDdbdbdcdcdcdcdbd"],
-  22: [17, "ce..", "eeeededeeeeedeDebebececebebece"],
-  23: [17, "cf..", "edededededededEdcDcdcdcdcdcdcD"],
-  24: [17, "dF..", "ddddddddddddddDdbdbdbdbdbdbdbd"],
-  25: [17, "cE..", "eeeeededededeeEecEcecdcdcdcdce"],
-  26: [17, "cf..", "ededdedeededdedebEbecdcdbebecd"],
-  27: [17, "de..", "dedeededdedeededcDcdbebecdcdbe"],
-  28: [17, "cf..", "ededddddeeeedeDebEbebebecdcdcd"],
-  29: [17, "ce..", "eeeeeeeededededebebebebececece"],
-  30: [17, "dF..", "dddddedeeeeeedEdcdcdcecebebebd"],
-  31: [17, "de..", "dedeededededdeDebebecdcdcdcdbe"],
-  32: [17, "cf..", "ededdededdddeeeecEcebdbdbebecd"],
-  33: [17, "de..", "dedeeeeeededddDdbdbdcdcdcecebe"],
-  34: [17, "de..", "dedeeeeeddddedEdcdcdbdbdcecebe"],
-  35: [17, "cf..", "ededededdededeDebebebebecdcdcd"],
-  36: [17, "deee", "eeeeeeeeddddddDdcdcdcdcDbebebe"],
-  37: [17, "dF..", "dddddededededdDdbdbdcecececebd"],
-  38: [17, "ce..", "eeeeddddddddeeEececebdbdbdbdce"],
-  39: [17, "cF..", "ededddddddddededcdcdbdbDbdbdcd"],
-  40: [17, "de..", "dededededdddddddbdbdbdbdbebebe"],
-  41: [17, "ce..", "eeeeeeeeeeeeeeEececececececece"],
-  42: [17, "cf..", "ededeeeedddddedebebebdbdcececd"],
-  43: [17, "df..", "ddddeeeededeedEdcdcdbebececebd"],
-  44: [17, "cF..", "ededdedeededdeDebebecdcdbebecd"],
-  45: [17, "ce..", "eeeededededeeeeecEcebebebebece"],
-  46: [17, "dF..", "ddddededddddedEdcDcdcdcdbdbdbd"],
-  47: [17, "ce..", "dedededededededececececececece"],
-  48: [25, "cf..", "ededeeeeeeeeededeeeeeeEecececececdcdcececececd"],
-  49: [25, "cF..", "ededddddededeeeeededdeDebebecdcdcececdcdbdbdcd"],
-  50: [25, "ce..", "eeeeddddededdededededeDebebebebebEbecdcdbdbdce"],
-  51: [25, "ce..", "eeeeededddddeeeededeeeEececebebececebdbdcdcdce"],
-  52: [25, "ce..", "eeeededededeededededeeEecececdcdcdcdbebebebece"],
-  53: [25, "dF..", "ddedeeeedddddddddedeeeEdcdcebebebdbDbdbdcececd"],
-  54: [25, "dF..", "ddedddddededededdddddEDdbdbebdbdcdcdcdcdbdbdcd"],
-  55: [25, "dF..", "ddeddedeeeeeeeeedededeDdbdbebebebebebebebebecd"],
-  56: [25, "dE..", "deeeeeeeededeeeededeeEedcdcebebecececdcdcecece"],
-  57: [25, "de..", "deeedddddddddedeededeeEdcDcecDcdcececdcdbdbDce"],
-  58: [25, "dF..", "ddedddddeeeedddddedeeeEdcdcebebebdbdcecebdbdcd"],
-  59: [33, "cF..", "ededdedeededddddeeeeeeeedddddeDebebebdbdcecececebdbdcdcdbebecd"],
-  60: [33, "cf..", "ededeeeeededededddddeeeeeeeedeDebebececececebdbdcdcdcdcdcececd"],
-  61: [33, "ce..", "eeeeeeeeddddeeeeeeeeddddeeeeeeeececececebdbdcecececebdbdcecece"],
-  62: [33, "ce..", "eeeeddddeeeeededededeeeeddddeeEecEcebdbdcececdcdcdcdcecebdbdce"],
-  63: [33, "cf..", "ededededeeeededededeeeeeeeeeeeEececececececebebEbebecececdcdcd"],
-  64: [33, "cF..", "ededeeeedddddedeeeeededeeeeedeDebebececebebececebebebdbdcececd"],
-  65: [33, "df..", "ddedededededddddddddeeeeeeeedeDdbdbececececebdbdbdbdcdcdcdcdcd"],
-  66: [33, "de..", "deeeededdedeeeeedddddededddddeDdbdbebdbdbebecdcdbebebebecdcdce"],
-  67: [33, "de..", "deeeddddddddededdddddededdddeeEdcDcebdbdbebebdbdcdcdbdbdbdbdce"],
-  68: [33, "dE..", "deeeeeeeeeeeeeeeddddeeeeeeeeeeEdcdcececececebdbdcecececececece"],
-  69: [33, "df..", "ddedededdedeeeeeddddededededdeDdbdbecdcdcdcdbdbdcecebebecdcdcd"],
-  70: [33, "dF..", "ddeddddddddddddddededededddddeDdbdbebdbdbebebebebdbdbdbdbdbDcd"],
-  71: [33, "ce..", "eeeeddddeeeededeeeeededeededdeDebebecdcdbebececebebececebdbdce"],
-  72: [33, "ce..", "eeeededededeededededddddddddeeEececebdbdbdbdcdcdcdcdbebebebece"],
-  73: [33, "ce..", "eeeeededededddddededdedeeeeeeeEececececebebecdcdbdbdcdcDcdcdce"],
-  74: [33, "cf..", "ededddddededededededdededddddeDebebebdbdbebecdcDcdcdcdcdbdbdcd"],
-  75: [33, "cF..", "ededdededededdddddddeeeedddddeDebebebdbdcececdcdcdcdbebebebecd"],
-  76: [33, "ce..", "eeeeeeeeeeeeeeeeeeeededeeeeedeDebebececebebecececececececececE"],
-  77: [33, "ce..", "eeeeeeeedededddddededdddedededEdcDcdcdcdbdbdbebebdbdbebececece"],
-  78: [33, "de..", "dedeededdedededeeeeeeeeededeedEdcdcdbebececececebebebebecdcdbe"],
-  79: [33, "dF..", "ddddddddededdededdddeeeeedededEdcDcdcdcdcecebdbdbebecdcdbdbdbd"],
-  80: [33, "dF..", "dddddededdddeeeeddddddddededddDdbdbdcdcdbdbdbdbDcecebdbdbebEbd"],
-  81: [33, "de..", "dedeeeeeeeeededeededeeeedededdDdbdbdbebecececdcdbebececececebe"],
-  82: [33, "de..", "dedeededdedeededdedededeedededEdcdcdcdcdbebebebecdcdbebecdcDbe"],
-  83: [33, "de..", "dededededddddededdddeeeededeeeEececebebececebdbdbebebdbdbebebe"],
-  84: [33, "cF..", "ededddddeeeeddddeeeeeeeeededeeEecececdcdcecebebecdcdcecebdbdcd"],
-  85: [33, "cf..", "ededdddddededddddddddedeeeeedeDebebececebebebdbdbdbdbebebdbdcd"],
-  86: [33, "ce..", "eeeeededddddeeeeeeeedededededeDebebebebebebebebebebebdbdcdcdce"],
-  87: [33, "ce..", "eeeeddddeeeeddddddddeeeeddddeeeececebdbdcecebdbDbdbdcecebdbdce"],
-  88: [33, "ce..", "eeeedededdddeeeeededededededeeeecececdcdcdcdcdcdcecebdbdbebece"],
-  89: [33, "cF..", "ededeeeeddddddddededdedededeeeEecEcebebEbebecdcdbdbdbdbdcececd"],
-  90: [33, "dF..", "ddddededeeeeededeeeedededededdDdbdbdbebebEbecececdcdcececdcdbd"],
-  91: [33, "df..", "ddddeeeededededeededdddddededdDdbdbdbebebdbdcdcdbebebebececebd"],
-  92: [33, "de..", "dedededeededdddddededededdddedEdcdcdbdbdbebebebebdbdcdcdbebebe"],
-  93: [33, "de..", "dededddddddddedeededeeeeeeeeededcdcdcececececdcdbebebdbdbdbdbe"],
-  94: [33, "dF..", "ddddeeeeddddeeeeddddeeeededeedEdcDcdbebececebdbDcecebdbdcecebd"],
-  95: [33, "df..", "ddddddddededeeeedddddededdddddDdbdbDbdbdbebecdcdbebecdcdbdbdbd"],
-  96: [33, "cf..", "ededeeeededeeeeedededdddeeeedeDebebececebdbdbebececebebecececd"],
-  97: [33, "ce..", "eeeedededededededdddeeeedddddeDebebebdbdcEcebdbdbebebEbebebece"],
-  98: [33, "ce..", "eeeeededededeeeeeeeededededeeeEececebebebebecececececdcdcdcdce"],
-  99: [33, "cf..", "ededededddddddddddddededdedeeeEececebebecdcdbdbdbdbdbdbdcdcdcd"],
-  100: [33, "cf..", "ededdedeeeeededededeeeeeededdeDebebecdcdcecebebebebececebebecd"]
-};
-function sectorBias(code) {
-  return code >= 97 ? (code - 97) / 2 - 1.5 : (code - 65) / 2 - 1.5 - 1 / 64;
+function oddEdgeAdjustment(odd, firstEdge) {
+  return odd ? firstEdge ? 0.5 : -0.5 : 0;
 }
-var VERTICAL_STEP_EARLY = "120002002002002002202200200200200220220020000022222220000002222220000002222220000";
-var VERTICAL_STEP_FIRST = 7;
-function verticalSideOffset(width) {
-  if (width < HOBBY_LIMIT || width > 1400) {
-    return void 0;
+function floorDivision(a, b) {
+  if (Number.isSafeInteger(a) && Number.isSafeInteger(b)) {
+    return Math.floor(a / b);
   }
-  let m = VERTICAL_STEP_FIRST;
-  for (let i = 1; i < VERTICAL_STEP_EARLY.length; i++) {
-    if (width >= 16 * (i + VERTICAL_STEP_FIRST) - 7 - +VERTICAL_STEP_EARLY[i]) {
-      m = i + VERTICAL_STEP_FIRST;
-    }
+  const A = BigInt(Math.round(a)), B = BigInt(Math.round(b));
+  let q = A / B;
+  if (A % B !== 0n && A < 0n !== B < 0n) {
+    q -= 1n;
   }
-  return 8 * m;
+  return Number(q);
 }
 var penCache = /* @__PURE__ */ new Map();
 function penPolygon(width) {
@@ -28919,6 +29163,9 @@ function perpendicularVectors(width, dx0, dy0) {
       best = i;
     }
   }
+  if (flip && best === 0 && nx * pen[n - 1][0] + ny * pen[n - 1][1] === bh) {
+    best = n - 1;
+  }
   const P = pen[(best + n - 1) % n];
   const N = pen[(best + 1) % n];
   const D = pen[best];
@@ -28927,20 +29174,19 @@ function perpendicularVectors(width, dx0, dy0) {
   const [B, hB, hS] = hP >= hN ? [P, hP, hN] : [N, hN, hP];
   const den = 2 * (bh - hB + (bh - hS));
   const w = den === 0 ? 0 : (hB - hS) / den;
-  const r = (v) => 8 * Math.floor((v + 4) / 8);
   const x = D[0] + (B[0] - D[0]) * w, y = D[1] + (B[1] - D[1]) * w;
-  let cx = 0.5 * Math.sign(dy), cy = 0.5 * Math.sign(dx);
-  const table = width % 16 === 0 ? FLAT_SECTOR_BIAS[width / 16] : void 0;
-  if (table) {
-    const key = best * 2 + (hP >= hN ? 0 : 1);
-    const pair = key === 0 ? table[1].slice(0, 2) : key >= table[0] ? table[2].slice((key - table[0]) * 2, (key - table[0]) * 2 + 2) : "..";
-    if (pair[0] !== ".") {
-      cx = sectorBias(pair.charCodeAt(0));
-      cy = sectorBias(pair.charCodeAt(1));
-    }
-  }
-  const side = dx === 0 ? verticalSideOffset(width) : void 0;
-  const vx = side === void 0 ? r(x + cx) : -side, vy = r(y + cy);
+  const signs = [dx === 0 ? 0 : Math.sign(dy), Math.sign(dx)];
+  const firstEdge = best === 0 && hP >= hN;
+  const num = hB - hS;
+  const rounded = [0, 1].map((c) => {
+    const bias2 = signs[c] + 2 * oddEdgeAdjustment(Math.abs(B[c] - D[c]) % 2 === 1, firstEdge);
+    if (den === 0) {
+      return 8 * (c === 1 && dy < 0 ? Math.ceil((D[c] + bias2 / 2 + 4) / 8) - 1 : Math.floor((D[c] + bias2 / 2 + 4) / 8));
+    }
+    const top = D[c] * den + (B[c] - D[c]) * num;
+    return 8 * floorDivision(2 * top + den * (bias2 + 8) - (c === 1 && dy < 0 ? 1 : 0), 16 * den);
+  });
+  const vx = rounded[0], vy = rounded[1];
   return { v: flip ? [-vx, -vy] : [vx, vy], ray: flip ? [-x, -y] : [x, y] };
 }
 function squareExtension(width, dx, dy) {
@@ -28970,7 +29216,6 @@ var Outliner = class {
     this.n = this.pen.length;
     this.rr = opts.cap === "round" && opts.join === "round";
     this.originalRoundJoinSides = opts.join === "round" && opts.cap !== "flat";
-    this.roundJoinSides = !!opts.roundCurveJoins || this.originalRoundJoinSides;
     this.maxX = Math.max(...this.pen.map((q) => Math.abs(q[0])));
   }
   /**
@@ -28978,14 +29223,14 @@ var Outliner = class {
    * `drawDir` (a curve's end tangent) only picks the draw vertices, the
    * perpendicular following the chord (measured on Bezier ends).
    */
-  seg(a, b, dir, drawDir) {
+  seg(a, b, dir, drawDir, curve = false) {
     const dx = dir ? dir[0] : b[0] - a[0];
     const dy = dir ? dir[1] : b[1] - a[1];
     const d = drawDir ?? [dx, dy];
     const [L, R] = drawVertices(this.pen, d[0], d[1]);
-    const perpendicular = this.opts.roundCurveJoins && drawDir ? drawDir : [dx, dy];
+    const perpendicular = curve && drawDir ? drawDir : [dx, dy];
     const vectors = perpendicularVectors(this.opts.width, perpendicular[0], perpendicular[1]);
-    return { dx, dy, L, R, v: vectors.v, vRaw: vectors.ray, e: squareExtension(this.opts.width, dx, dy), curveEnd: !!drawDir };
+    return { dx, dy, L, R, v: vectors.v, vRaw: vectors.ray, e: squareExtension(this.opts.width, perpendicular[0], perpendicular[1]), curveEnd: !!drawDir, tangentLength: drawDir ? drawDir[0] * drawDir[0] + drawDir[1] * drawDir[1] : 0, curve };
   }
   push(p, v) {
     this.pts.push([p[0] + v[0], p[1] + v[1]]);
@@ -29020,7 +29265,7 @@ var Outliner = class {
    * vertex exactly on `A`'s ray is included when `startIncl`, one on `B`'s
    * ray when `endIncl`.
    */
-  wedge(p, A, B, startIncl, endIncl) {
+  wedge(p, A, B, startIncl, endIncl, tail = -1) {
     const TWO = Math.PI * 2;
     const aA = Math.atan2(A[1], A[0]);
     const angleOf = (Q) => {
@@ -29051,13 +29296,21 @@ var Outliner = class {
       }
     }
     list.sort((x, y) => x[0] - y[0]);
+    if (tail >= 0 && !list.some(([, k]) => k === tail)) {
+      list.push([Infinity, tail]);
+    }
     for (const [, k] of list) {
       this.penAt(p, k);
     }
   }
+  /** The pen's extreme-x vertex `k` that a steep segment `s` rests on, or -1 when the rule does not apply. */
+  extremeTail(applies, k, s) {
+    const q = this.pen[k];
+    return applies && Math.abs(s.dy) > Math.abs(s.dx) && Math.abs(q[0]) === this.maxX && q[1] === 0 ? k : -1;
+  }
   /** Side offset of segment `s` at a join. */
   joinSide(s, side) {
-    if (this.roundJoinSides) {
+    if (this.originalRoundJoinSides || s.curve) {
       const q = this.pen[side === "L" ? s.L : s.R];
       return [halfPixel(q[0]), halfPixel(q[1])];
     }
@@ -29105,32 +29358,36 @@ var Outliner = class {
    */
   join(p, a, b, side, outer) {
     const { cap, width, miterLimit } = this.opts;
-    const join = this.opts.roundCurveJoins ? "round" : this.opts.join;
+    const curveJoin = a.curve && b.curve;
+    const join = curveJoin ? "round" : this.opts.join;
+    const roundSides = this.originalRoundJoinSides || curveJoin;
     let sa = this.joinSide(a, side);
     let sb = this.joinSide(b, side);
     const rayA = side === "R" ? a.vRaw : [-a.vRaw[0], -a.vRaw[1]];
     const rayB = side === "R" ? b.vRaw : [-b.vRaw[0], -b.vRaw[1]];
-    if (this.opts.roundCurveJoins && !this.originalRoundJoinSides && a.curveEnd && b.curveEnd) {
-      sa = side === "R" ? a.v : [-a.v[0], -a.v[1]];
-      sb = side === "R" ? b.v : [-b.v[0], -b.v[1]];
+    if (curveJoin && !this.originalRoundJoinSides && a.curveEnd && b.curveEnd) {
+      const t = a.tangentLength >= b.tangentLength ? a : b;
+      sa = sb = side === "R" ? t.v : [-t.v[0], -t.v[1]];
     }
     const Da = side === "R" ? a.R : a.L;
     const Db = side === "R" ? b.R : b.L;
-    if (this.roundJoinSides && (Da === Db || this.opts.roundCurveJoins && sa[0] === sb[0] && sa[1] === sb[1])) {
+    if (roundSides && (Da === Db || curveJoin && sa[0] === sb[0] && sa[1] === sb[1])) {
       this.push(p, sa);
       return;
     }
     this.push(p, sa);
     if (outer) {
       if (join === "round") {
-        if (this.roundJoinSides) {
+        if (roundSides) {
           const q = this.pen[Db];
           const steep = Math.abs(b.dy) > Math.abs(b.dx);
           const incl = side === "L" && steep && Math.abs(q[0]) === this.maxX && q[0] * q[1] <= 0;
           this.walk(p, Da, Db, false, incl);
         } else {
           const anti = sa[0] === -sb[0] && sa[1] === -sb[1];
-          this.wedge(p, rayA, rayB, !anti, !anti);
+          if (Da !== Db || anti) {
+            this.wedge(p, rayA, rayB, !anti, false, this.extremeTail(side === "L" && !anti, Db, b));
+          }
         }
       } else if (join === "miter") {
         const m = miterPoint(sa, [a.dx, a.dy], sb, [b.dx, b.dy], width, miterLimit, side);
@@ -29140,14 +29397,16 @@ var Outliner = class {
       }
     } else {
       this.pts.push([p[0], p[1]]);
-      if (this.opts.roundCurveJoins && !this.originalRoundJoinSides) {
+      if (curveJoin && !this.originalRoundJoinSides) {
         this.push(p, sb);
         this.push(p, sa);
         this.pts.push([p[0], p[1]]);
       }
-      if (join === "round" && cap === "flat" && !this.opts.roundCurveJoins) {
+      if (join === "round" && cap === "flat" && !curveJoin) {
         this.push(p, sb);
-        this.wedge(p, rayB, rayA, false, false);
+        if (Da !== Db) {
+          this.wedge(p, rayB, rayA, false, false, this.extremeTail(side === "L", Da, a));
+        }
         this.push(p, sa);
         this.pts.push([p[0], p[1]]);
       }
@@ -29180,17 +29439,17 @@ var Outliner = class {
    * lets a single point stand for a zero-length dash along `dirs[0]`;
    * `draws` (curve end tangents) picks draw vertices only.
    */
-  open(P, dirs, draws) {
+  open(P, dirs, draws, curves) {
     if (P.length < 2 && !dirs?.[0]) {
       this.dot(P[0]);
       return;
     }
     const segs2 = [];
     for (let i = 0; i + 1 < P.length; i++) {
-      segs2.push(this.seg(P[i], P[i + 1], dirs?.[i], draws?.[i]));
+      segs2.push(this.seg(P[i], P[i + 1], dirs?.[i], draws?.[i], curves?.[i]));
     }
     if (segs2.length === 0) {
-      const s = this.seg(P[0], P[0], dirs?.[0], draws?.[0]);
+      const s = this.seg(P[0], P[0], dirs?.[0], draws?.[0], curves?.[0]);
       this.cap(P[0], s, true);
       this.cap(P[0], s, false);
       this.flush();
@@ -29221,11 +29480,11 @@ var Outliner = class {
     this.flush();
   }
   /** Outlines a closed polygon (distinct consecutive points, not repeating the first). */
-  closed(P, draws) {
+  closed(P, draws, curves) {
     const m = P.length;
     const segs2 = [];
     for (let i = 0; i < m; i++) {
-      segs2.push(this.seg(P[i], P[(i + 1) % m], void 0, draws?.[i]));
+      segs2.push(this.seg(P[i], P[(i + 1) % m], void 0, draws?.[i], curves?.[i]));
     }
     for (let j = 1; j <= m; j++) {
       const i = j % m;
@@ -29317,9 +29576,10 @@ function widenPath(path, opts) {
   const out = [];
   const dashed = !!opts.dashes && opts.dashes.length > 0;
   for (const fig of path.figures) {
-    const outliner = new Outliner(fig.roundWiden ? { ...opts, roundCurveJoins: true } : opts, out);
+    const outliner = new Outliner(opts, out);
     let P = [];
     const dirs = [];
+    const curves = [];
     for (let i = 0; i + 1 < fig.pts.length; i += 2) {
       const q = [fig.pts[i], fig.pts[i + 1]];
       const last = P[P.length - 1];
@@ -29328,6 +29588,7 @@ function widenPath(path, opts) {
       }
       if (last) {
         dirs.push(fig.tangents?.get(i / 2 - 1));
+        curves.push(!!fig.roundWiden || !!fig.curveSegs?.has(i / 2 - 1));
       }
       P.push(q);
     }
@@ -29354,14 +29615,14 @@ function widenPath(path, opts) {
             pdraws.push(piece.draws[i - 1]);
           }
         }
-        outliner.open(pts, pdirs.length > 0 ? pdirs : [piece.dirs[0]], pdirs.length > 0 ? pdraws : [piece.draws[0]]);
+        outliner.open(pts, pdirs.length > 0 ? pdirs : [piece.dirs[0]], pdirs.length > 0 ? pdraws : [piece.draws[0]], pts.map(() => !!fig.roundWiden));
       }
     } else if (closed && P.length >= 3) {
-      outliner.closed(P, dirs);
+      outliner.closed(P, dirs, curves);
     } else if (closed && P.length === 2) {
       outliner.open([P[0], P[1], P[0]]);
     } else {
-      outliner.open(P, void 0, dirs);
+      outliner.open(P, void 0, dirs, curves);
     }
   }
   return out;
@@ -31106,6 +31367,10 @@ function hasIlluminant(ca) {
   return illuminantCube(ca.illuminant) !== null;
 }
 var PALETTE = Array.from({ length: 32 }, (_, n) => Math.round(n * 255 / 31));
+function exactPaletteLevel(v) {
+  const n = Math.round(v * 31 / 255);
+  return PALETTE[n] === v ? 255 * n / 31 : v;
+}
 function paletteIndex(v) {
   const x = clamp012(v) * 255;
   let n = Math.min(30, Math.floor(x * 31 / 255));
@@ -31191,6 +31456,7 @@ function invert3(m) {
 }
 var clamp012 = (v) => v < 0 ? 0 : v > 1 ? 1 : v;
 var clamp255 = (v) => v < 0 ? 0 : v > 255 ? 255 : v;
+var roundHalfUp = (v) => Math.floor(v + 0.5 + 1e-7);
 function adjustChroma(r, g, b, scale, angle) {
   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;
@@ -31242,7 +31508,7 @@ function colorAdjustmentMapper(ca) {
     if (negative) {
       v = 255 - clamp255(v);
     }
-    return Math.round(clamp255(v));
+    return roundHalfUp(clamp255(v));
   };
   if (!illuminant && !chroma) {
     const tables = [0, 1, 2].map((channel) => Uint8Array.from({ length: 256 }, (_, i) => curve(i, channel)));
@@ -31255,7 +31521,11 @@ function colorAdjustmentMapper(ca) {
       c = [mapped[0] * 255, mapped[1] * 255, mapped[2] * 255];
     }
     if (chroma) {
+      if (!illuminant) {
+        c = c.map(exactPaletteLevel);
+      }
       c = adjustChroma(clamp255(c[0]), clamp255(c[1]), clamp255(c[2]), scale, angle);
+      c = c.map(roundHalfUp);
     }
     return curve(c[0], 0) << 16 | curve(c[1], 1) << 8 | curve(c[2], 2);
   };
@@ -31289,27 +31559,6 @@ function colorAdjustRgb(rgbs, ca) {
     rgbs[i + 2] = v & 255;
   }
 }
-function applyColorAdjustment(pixels, ca) {
-  if (!ca || isIdentityColorAdjustment(ca)) {
-    return;
-  }
-  const map = colorAdjustmentMapper(ca);
-  const d = pixels.data;
-  const cache2 = /* @__PURE__ */ new Map();
-  for (let i = 0; i + 3 < d.length; i += 4) {
-    const rgb2 = d[i] << 16 | d[i + 1] << 8 | d[i + 2];
-    let v = cache2.get(rgb2);
-    if (v === void 0) {
-      v = map(rgb2);
-      if (cache2.size < 65536) {
-        cache2.set(rgb2, v);
-      }
-    }
-    d[i] = v >> 16 & 255;
-    d[i + 1] = v >> 8 & 255;
-    d[i + 2] = v & 255;
-  }
-}
 
 // src/emf-gdi-halftone-dither.ts
 var THRESHOLDS = [
@@ -31468,22 +31717,22 @@ function halftoneAxis(start, srcLen, dstLen, reverse) {
   if (reverse) taps.reverse();
   return taps;
 }
+var REDUCE_BITS = 13;
 function halftoneReduceTaps(srcLen, dstLen, reverse) {
   if (dstLen >= srcLen) return halftoneAxis(0, srcLen, dstLen, reverse);
+  const shares = 2 ** REDUCE_BITS;
+  const scale = FIX / shares;
   const taps = [];
   for (let i = 0; i < dstLen; i++) {
     const from = i * srcLen;
     const to = (i + 1) * srcLen;
     const run = [];
-    let rest = 0;
     for (let k = Math.floor(from / dstLen); k * dstLen < to; k++) {
-      const overlap = Math.min(to, (k + 1) * dstLen) - Math.max(from, k * dstLen);
-      if (overlap <= 0) continue;
-      const w = Math.ceil(overlap * FIX / srcLen);
-      run.push([k, w]);
-      if (run.length > 1) rest += w;
+      const lo = Math.max(from, k * dstLen) - from;
+      const hi = Math.min(to, (k + 1) * dstLen) - from;
+      if (hi <= lo) continue;
+      run.push([k, (Math.floor(hi * shares / srcLen) - Math.floor(lo * shares / srcLen)) * scale]);
     }
-    if (run.length > 1) run[0][1] = FIX - rest;
     taps.push(run);
   }
   if (reverse) taps.reverse();
@@ -31557,7 +31806,7 @@ function halftoneEnlargeTaps(src, dst) {
 }
 function ditherPixels(px, w, h, dither, flipX, flipY, phaseX, phaseY) {
   for (let y = 0; y < h; y++) {
-    const yy = phaseY ? phaseY[y] : flipY ? h - 1 - y : y;
+    const yy = phaseY ? phaseY[y] : y;
     for (let x = 0; x < w; x++) {
       const xx = phaseX ? phaseX[x] : x;
       const threshold = ditherThreshold(dither.startX, dither.startY, xx, yy);
@@ -31568,82 +31817,64 @@ function ditherPixels(px, w, h, dither, flipX, flipY, phaseX, phaseY) {
     }
   }
 }
-var SPECKLE_OVERSHOOT = 4;
 function halftoneDespeckle(px, w, h) {
+  if (w < 2 || h < 2) {
+    return;
+  }
   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;
-  const loneX = w > 2 && w % 2 === 1 ? w - 1 : -1;
-  const loneY = h > 2 && h % 2 === 1 ? h - 1 : -1;
-  const mirror2 = (i, n, d) => {
-    const j = i + d;
-    return j < 0 || j >= n ? i - d : j;
+  const index = (x, y) => {
+    const mx = x < 0 ? -x : x >= w ? 2 * (w - 1) - x : x;
+    const my = y < 0 ? -y : y >= h ? 2 * (h - 1) - y : y;
+    return (Math.max(0, Math.min(h - 1, my)) * w + Math.max(0, Math.min(w - 1, mx))) * 3;
   };
-  const vBlur = (x, y, c) => at(x, mirror2(y, h, -1), c) + 2 * at(x, y, c) + at(x, mirror2(y, h, 1), c) + 2 >> 2;
-  const hBlur = (x, y, c) => at(mirror2(x, w, -1), y, c) + 2 * at(x, y, c) + at(mirror2(x, w, 1), y, c) + 2 >> 2;
-  const differs = (x0, y0, x1, y1) => at(x0, y0, 0) !== at(x1, y1, 0) || at(x0, y0, 1) !== at(x1, y1, 1) || at(x0, y0, 2) !== at(x1, y1, 2);
-  const loneColumn = (y) => loneX > 0 && differs(loneX, y, loneX - 1, y);
-  const loneRow = (x) => loneY > 0 && differs(x, loneY, x, loneY - 1);
-  const loneColumnValue = (y, c) => y === loneY && loneRow(loneX) ? at(loneX, y - 1, c) + 3 * at(loneX, y, c) + 2 >> 2 : vBlur(loneX, y, c);
-  const loneRowValue = (x, c) => x === loneX && loneColumn(loneY) ? at(x - 1, loneY, c) + 3 * at(x, loneY, c) + 2 >> 2 : hBlur(x, loneY, c);
-  const speckled = (x, y) => {
-    const up = mirror2(y, h, -1);
-    const down = mirror2(y, h, 1);
-    const left = mirror2(x, w, -1);
-    const right = mirror2(x, w, 1);
-    let hClip = 0;
-    let vClip = 0;
-    let alternating = 0;
-    for (let c = 0; c < 3; c++) {
-      const v = at(x, y, c);
-      const axial = Math.max(
-        Math.abs(v - at(left, y, c)),
-        Math.abs(v - at(right, y, c)),
-        Math.abs(v - at(x, up, c)),
-        Math.abs(v - at(x, down, c))
-      );
-      const diagonal = Math.min(
-        Math.abs(v - at(left, up, c)),
-        Math.abs(v - at(right, up, c)),
-        Math.abs(v - at(left, down, c)),
-        Math.abs(v - at(right, down, c))
-      );
-      if (diagonal < axial) alternating++;
-      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++;
+  const same = (i, j) => src[i] === src[j] && src[i + 1] === src[j + 1] && src[i + 2] === src[j + 2];
+  const stride = w + 1;
+  const flags = new Uint8Array(stride * (h + 1));
+  for (let y = -1; y < h; y++) {
+    for (let x = -1; x < w; x++) {
+      const a = index(x, y);
+      const b = index(x + 1, y);
+      const c = index(x, y + 1);
+      const d = index(x + 1, y + 1);
+      flags[(y + 1) * stride + x + 1] = same(a, d) && same(b, c) && !same(a, b) ? 1 : 0;
+    }
+  }
+  const checker = (x, y) => flags[(y + 1) * stride + x + 1] === 1;
+  for (let y = 0; y < h - 1; y++) {
+    for (let x = 0; x < w - 1; x++) {
+      if (!checker(x, y)) {
+        continue;
       }
-    }
-    return hClip >= 2 && vClip >= 2 && alternating >= 2;
-  };
-  for (let y = 0; y < h; y++) {
-    for (let x = 0; x < w; x++) {
-      if (!speckled(x, y)) {
+      const ia = index(x, y);
+      const ib = index(x + 1, y);
+      const members = [
+        [x, y, 1, 1, true],
+        [x + 1, y + 1, -1, -1, true],
+        [x + 1, y, -1, 1, false],
+        [x, y + 1, 1, -1, false]
+      ];
+      if (checker(x - 1, y) && checker(x + 1, y) || checker(x, y - 1) && checker(x, y + 1)) {
+        for (const [mx, my] of members) {
+          const o = (my * w + mx) * 3;
+          for (let c = 0; c < 3; c++) {
+            px[o + c] = src[ia + c] + src[ib + c] + 1 >> 1;
+          }
+        }
         continue;
       }
-      const left = mirror2(x, w, -1);
-      const right = mirror2(x, w, 1);
-      const up = mirror2(y, h, -1);
-      const down = mirror2(y, h, 1);
-      const lonelyColumn = x === loneX && loneColumn(y);
-      const lonelyRow = y === loneY && loneRow(x);
-      const nearLoneX = x === loneX - 1 && loneX > 0 && loneColumn(y) && !speckled(loneX, y);
-      const nearLoneY = y === loneY - 1 && loneY > 0 && loneRow(x) && !speckled(x, loneY);
-      const cornerRepeats = lonelyColumn && lonelyRow && (!speckled(x, y - 1) || !speckled(x - 1, y));
-      for (let c = 0; c < 3; c++) {
-        const v = at(x, y, c);
-        let r;
-        if (lonelyColumn && lonelyRow) {
-          r = cornerRepeats ? at(left, y, c) + 3 * v + 2 >> 2 : hBlur(x, y, c);
-        } else {
-          let sum = lonelyColumn ? at(x, up, c) + 2 * v + at(x, down, c) : at(left, y, c) + 2 * v + at(right, y, c);
-          if (nearLoneX) sum += loneColumnValue(y, c) - at(loneX, y, c);
-          if (nearLoneY) sum += loneRowValue(x, c) - at(x, loneY, c);
-          r = sum + 2 >> 2;
+      const brighter = 4 * (src[ia] - src[ib]) + 8 * (src[ia + 1] - src[ib + 1]) + (src[ia + 2] - src[ib + 2]);
+      for (const [mx, my, sx, sy, isA] of members) {
+        if (isA ? brighter < 0 : brighter >= 0) {
+          continue;
+        }
+        const o = (my * w + mx) * 3;
+        const t1 = index(mx + sx, my);
+        const t2 = index(mx, my + sy);
+        const t3 = index(mx + 2 * sx, my);
+        const t4 = index(mx, my + 2 * sy);
+        for (let c = 0; c < 3; c++) {
+          px[o + c] = 12 * px[o + c] + src[t1 + c] + src[t2 + c] + src[t3 + c] + src[t4 + c] + 8 >> 4;
         }
-        px[(y * w + x) * 3 + c] = r;
       }
     }
   }
@@ -31662,11 +31893,33 @@ function halftoneSharpen(px, w, h) {
     }
   }
 }
+function halftonePairDespeckle(px, w, h, rows) {
+  const n = rows ? w : h;
+  const at = (k, side) => (rows ? side * w + k : k * w + side) * 3;
+  const same = (i, j) => px[i] === px[j] && px[i + 1] === px[j + 1] && px[i + 2] === px[j + 2];
+  const checker = (k) => k >= 0 && k + 1 < n && same(at(k, 0), at(k + 1, 1)) && same(at(k, 1), at(k + 1, 0)) && !same(at(k, 0), at(k, 1));
+  const mean = Array.from({ length: n }, (_, k) => checker(k - 1) || checker(k));
+  for (let k = 0; k < n; k++) {
+    if (!mean[k]) continue;
+    const first = at(k, 0);
+    const last = at(k, 1);
+    for (let c = 0; c < 3; c++) px[first + c] = px[last + c] = px[first + c] + px[last + c] + 1 >> 1;
+  }
+}
+function halftoneKeepLast(px, w, h, rows) {
+  const n = rows ? w : h;
+  const out = new Int32Array(n * 3);
+  for (let k = 0; k < n; k++) {
+    const last = (rows ? w + k : k * w + 1) * 3;
+    for (let c = 0; c < 3; c++) out[k * 3 + c] = px[last + c];
+  }
+  return out;
+}
 function stretchHalftone(src, sx, sy, sw, sh, dw, dh, adjust, adjustAfterSampling = false, directDib = false, dither, curves) {
   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));
+  let SW = Math.round(Math.abs(sw));
+  let 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;
@@ -31675,7 +31928,7 @@ function stretchHalftone(src, sx, sy, sw, sh, dw, dh, adjust, adjustAfterSamplin
   if (W === 0 || H === 0 || SW === 0 || SH === 0) {
     return { width: W, height: H, data };
   }
-  const rect = new Int32Array(SW * SH * 3);
+  let rect = new Int32Array(SW * SH * 3);
   for (let y = 0; y < SH; y++) {
     const yy = y0 + y;
     for (let x = 0; x < SW; x++) {
@@ -31690,19 +31943,40 @@ function stretchHalftone(src, sx, sy, sw, sh, dw, dh, adjust, adjustAfterSamplin
       rect[o + 2] = src.data[i + 2];
     }
   }
+  const pairRows = SH === 2 && H === 1 && W > SW && (!adjust || adjustAfterSampling || !!dither);
+  const pairColumns = SW === 2 && W === 1 && H > SH && (!adjust || adjustAfterSampling || !!dither);
+  if (pairRows || pairColumns) {
+    if (!directDib) halftonePairDespeckle(rect, SW, SH, pairRows);
+    if (pairRows && W >= 2 * SW) {
+      rect = halftoneKeepLast(rect, SW, SH, true);
+      SH = 1;
+    } else if (pairColumns && H >= 2 * SH) {
+      rect = halftoneKeepLast(rect, SW, SH, false);
+      SW = 1;
+    }
+  }
   const enlarging = W >= SW && H >= SH && (W > SW || H > SH);
   const reducing = W < SW && H < SH;
   const mixed = W > SW && H < SH || W < SW && H > SH;
   const dithered = !!dither && !!adjust && !adjustAfterSampling;
   const nearestMixed = mixed && (!adjust || adjustAfterSampling || dithered) && (W < SW && W * 2 > SW || H < SH && H * 2 > SH);
   const nativeMixed = mixed && (!adjust || adjustAfterSampling || dithered) && (W > SW && H * 2 <= SH || H > SH && W * 2 <= SW);
-  if ((enlarging || nearestMixed) && !directDib) {
+  if ((enlarging || nearestMixed) && !directDib && !pairRows && !pairColumns) {
     halftoneDespeckle(rect, SW, SH);
   }
   const reducedEven = W < SW ? SW % 2 === 0 && H % SH === 0 : SH % 2 === 0 && W % SW === 0;
   const ditherAtSource = dithered && (W >= SW && H >= SH || nativeMixed && reducedEven);
   if (ditherAtSource) {
-    ditherPixels(rect, SW, SH, dither, false, flipY);
+    ditherPixels(
+      rect,
+      SW,
+      SH,
+      dither,
+      false,
+      false,
+      void 0,
+      flipY ? Int32Array.from({ length: SH }, (_, j) => H - 1 - j) : void 0
+    );
   }
   if (adjust && !adjustAfterSampling && (!dithered || ditherAtSource)) {
     adjust(rect);
@@ -31818,17 +32092,13 @@ function stretchHalftone(src, sx, sy, sw, sh, dw, dh, adjust, adjustAfterSamplin
     }
   }
   if (dithered && !ditherAtSource) {
-    const phase = (n, src2, dst, selectSource) => Int32Array.from({ length: n }, (_, i) => dst > src2 ? Math.floor(i * src2 / dst) : selectSource ? Math.max(0, Math.min(src2 - 1, Math.floor(((i + 1) * 2 * src2 - dst) / (2 * dst)))) : i);
-    ditherPixels(
-      out,
-      W,
-      H,
-      dither,
-      false,
-      false,
-      nearestMixed ? phase(W, SW, W, true) : void 0,
-      nearestMixed ? phase(H, SH, H, false) : void 0
-    );
+    const phase = (n, src2, dst, selectSource) => Int32Array.from({ length: n }, (_, i) => dst > src2 ? Math.max(0, Math.ceil((2 * i + 1) * src2 / (2 * dst)) - 1) : selectSource ? Math.max(0, Math.min(src2 - 1, Math.floor(((i + 1) * 2 * src2 - dst) / (2 * dst)))) : i);
+    const sourcePhase = nearestMixed && W * H > SW * SH;
+    let phaseX = sourcePhase ? phase(W, SW, W, true) : void 0;
+    let phaseY = sourcePhase ? phase(H, SH, H, false) : void 0;
+    if (phaseX && flipX) phaseX = phaseX.slice().reverse();
+    if (phaseY && flipY && H > SH) phaseY = phaseY.slice().reverse().map((v) => H - 1 - v);
+    ditherPixels(out, W, H, dither, false, false, phaseX, phaseY);
     adjust(out);
   }
   if (adjust && adjustAfterSampling) adjust(out);
@@ -31891,7 +32161,7 @@ function drawSourceMapped(target, decoded, req, offsetX, offsetY, mode, brushOrg
   canvasDrawImage(target, tile.canvas, Math.round(dLeft), Math.round(dTop), px.width, px.height);
   target.restore();
 }
-function decodeSource(rCtx, req) {
+function decodeSource(rCtx, req, rotated = false) {
   if (!req.source) {
     return null;
   }
@@ -31906,6 +32176,9 @@ function decodeSource(rCtx, req) {
     return null;
   }
   const ca = rCtx.state.colorAdjustment;
+  if (req.stretch && rCtx.state.stretchBltMode === HALFTONE && rCtx.halftoneRotatedAdjusts === void 0) {
+    rCtx.halftoneRotatedAdjusts = !rotated && !!ca;
+  }
   const halftone = req.stretch && rCtx.state.stretchBltMode === HALFTONE && ca;
   const channelOnly = isChannelOnlyColorAdjustment(ca);
   const split = halftone && !channelOnly ? splitColorAdjustment(ca) : void 0;
@@ -32053,6 +32326,7 @@ function executeRotatedBlit(rCtx, logDx, logDy, logDw, logDh, rop, source, sx, s
   let src = null;
   let srcX = sx;
   let srcY = sy;
+  let adjustTexel;
   if (operands.usesS) {
     const decoded = decodeSource(rCtx, {
       plan: { kind: "ternary", index, operands },
@@ -32067,13 +32341,30 @@ function executeRotatedBlit(rCtx, logDx, logDy, logDw, logDh, rop, source, sx, s
       sh,
       dibOrigin,
       stretch
-    });
+    }, true);
     if (!decoded) {
       return;
     }
     src = decoded.decoded.pixels;
-    if (decoded.decoded.adjust) {
-      applyColorAdjustment(src, rCtx.state.colorAdjustment);
+    if (decoded.decoded.adjust && rCtx.halftoneRotatedAdjusts) {
+      const { adjust, adjustAfterSampling, curves } = decoded.decoded;
+      const startX = ditherStartX(0, rCtx.state.brushOrgX);
+      const startY = ditherStartY(0, rCtx.state.brushOrgY);
+      const triple = new Int32Array(3);
+      adjustTexel = (rgb2, x, y) => {
+        triple[0] = rgb2 >> 16 & 255;
+        triple[1] = rgb2 >> 8 & 255;
+        triple[2] = rgb2 & 255;
+        if (!adjustAfterSampling) {
+          const t = ditherThreshold(startX, startY, x, y);
+          for (let c = 0; c < 3; c++) {
+            triple[c] = ditherQuantize(triple[c], t);
+          }
+        }
+        adjust(triple);
+        curves?.(triple);
+        return triple[0] << 16 | triple[1] << 8 | triple[2];
+      };
     }
     srcX = decoded.req.sx;
     srcY = decoded.req.sy;
@@ -32097,7 +32388,10 @@ function executeRotatedBlit(rCtx, logDx, logDy, logDw, logDh, rop, source, sx, s
     sw,
     sh,
     (ix, iy, x, y, d) => {
-      const s = operands.usesS ? texel(ix, iy) : 0;
+      let s = operands.usesS ? texel(ix, iy) : 0;
+      if (adjustTexel && operands.usesS) {
+        s = adjustTexel(s, x, y);
+      }
       const p = typeof pattern === "function" ? pattern(x, y) : pattern;
       return evalRop3(index, p, s, d);
     }
@@ -32152,6 +32446,19 @@ function alignMirroredDest(rCtx, req) {
     dy: req.dh < 0 ? req.dy + pxY : req.dy
   };
 }
+function executePlgBltAsStretch(rCtx, dx, dy, dw, dh, source, r) {
+  executeBlit(rCtx, {
+    plan: classifyRop3(13369376),
+    dx,
+    dy,
+    dw,
+    dh,
+    source,
+    ...r,
+    dibOrigin: "top-left",
+    stretch: true
+  });
+}
 function executeBlit(rCtx, request) {
   const { ctx } = rCtx;
   const req = alignMirroredDest(rCtx, request);
@@ -32654,6 +32961,18 @@ function handlePlgBlt(rCtx, offset, dataOff, recSize) {
   if (b[1] === a[1] && q[0] === a[0]) {
     const W = Math.round(Math.abs(b[0] - a[0]) / 16);
     const H = Math.round(Math.abs(q[1] - a[1]) / 16);
+    if (!mask && rCtx.state.stretchBltMode === HALFTONE && W > 0 && H > 0) {
+      executePlgBltAsStretch(
+        rCtx,
+        Math.round(a[0] / 16),
+        Math.round(a[1] / 16),
+        b[0] < a[0] ? -W : W,
+        q[1] < a[1] ? -H : H,
+        sourceOf(offset, view.getUint32(dataOff + 88, true), view.getUint32(dataOff + 92, true), view.getUint32(dataOff + 96, true), view.getUint32(dataOff + 100, true), view.getUint32(dataOff + 84, true)),
+        r
+      );
+      return;
+    }
     const left = Math.round(a[0] / 16) + (b[0] < a[0] ? 1 - W : 0);
     const top = Math.round(a[1] / 16) + (q[1] < a[1] ? 1 - H : 0);
     const aw = Math.abs(r.sw);
@@ -32674,6 +32993,9 @@ function handlePlgBlt(rCtx, offset, dataOff, recSize) {
     });
     return;
   }
+  if (rCtx.state.stretchBltMode === HALFTONE && rCtx.halftoneRotatedAdjusts === void 0) {
+    rCtx.halftoneRotatedAdjusts = false;
+  }
   paintParallelogram(rCtx, a, b, q, r.sw, r.sh, (ix, iy) => texel(ix, iy));
 }
 function readBand(rCtx, offset, offBmi, cbBmi, offBits, cbBits, usage, scans) {
@@ -34802,6 +35124,7 @@ function flattenBracketPath(rCtx) {
   }
   for (const f of rCtx.rasterPath.figures) {
     delete f.tangents;
+    delete f.curveSegs;
     delete f.roundWiden;
   }
   syncPathCmds(rCtx);
@@ -38893,7 +39216,7 @@ function wmfRectangle(p, l, t, r, b) {
     axisRect: { interior: rectInterior(p, box) }
   });
 }
-function compatCorner(p, w, h, box) {
+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);
@@ -38901,24 +39224,21 @@ function compatCorner(p, w, h, box) {
   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;
-    const width = box.x1 - box.x0, height = box.y1 - box.y0;
-    return [Math.floor(Math.min(cw, width + penWidth) * width / (width + penWidth)), Math.floor(Math.min(ch, height + penWidth) * height / (height + penWidth))];
-  }
-  if (!penIsNull(p) && penIsCosmetic(p.rCtx)) {
-    const width = box.x1 - box.x0, height = box.y1 - box.y0;
-    return [Math.min(cw, width + ux) * width / (width + ux), Math.min(ch, height + uy) * height / (height + uy)];
+    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))];
   }
-  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)];
+  const width = box.x1 - box.x0, height = box.y1 - box.y0;
+  const fullW = Math.abs((logical[2] - logical[0]) * m[0]) * 16 || width + ux;
+  const fullH = Math.abs((logical[3] - logical[1]) * m[3]) * 16 || height + uy;
+  const scaled2 = [Math.min(Math.abs(w * m[0]) * 16, fullW) * width / fullW, Math.min(Math.abs(h * m[3]) * 16, fullH) * height / fullH];
+  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 });
   if (box.x1 < box.x0 || box.y1 < box.y0) {
     return;
   }
-  const [cw, ch] = compatCorner(p, w, h, box);
+  const [cw, ch] = compatCorner(p, w, h, box, [l, t, r, b]);
   const cr = canvasRect(box);
   paintGdiShape(p.rCtx, {
     build: (c) => {
@@ -38971,10 +39291,14 @@ function compatArc(p, kind, l, t, r, b, xs, ys, xe, ye) {
   if (box.x1 < box.x0 || box.y1 < box.y0) {
     return null;
   }
-  const raw = compatBox(p, l, t, r, b, { exclusive: false });
+  const m = gdiDeviceMatrix(p.rCtx);
+  const deviceFix = (x, y) => [(m[0] * x + m[2] * y + m[4]) * 16, (m[1] * x + m[3] * y + m[5]) * 16];
+  const [ax, ay] = deviceFix(l, t);
+  const [bx, by] = deviceFix(r, b);
+  const raw = { x0: Math.min(ax, bx), x1: Math.max(ax, bx), y0: Math.min(ay, by), y1: Math.max(ay, by) };
   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);
+    const [fx, fy] = deviceFix(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) };