emf-converter 4.17.0 → 4.18.0

package/dist/browser.js

@@ -10445,12 +10445,12 @@ function cmykPlanesToRgba(planes, width, height, ycck) {
   const fracOf = FRAC_OF;
   const strides = [N * N * N * 3, N * N * 3, N * 3, 3];
   const out = new Uint8Array(width * height * 4);
-  const fix = (x) => Math.floor(x * 65536 + 0.5);
+  const fix2 = (x) => Math.floor(x * 65536 + 0.5);
   const half = 1 << 15;
-  const crR = fix(1.402);
-  const cbB = fix(1.772);
-  const crG = -fix(0.71414);
-  const cbG = -fix(0.34414);
+  const crR = fix2(1.402);
+  const cbB = fix2(1.772);
+  const crG = -fix2(0.71414);
+  const cbG = -fix2(0.34414);
   const inks = [0, 0, 0, 0];
   const frac = [0, 0, 0, 0];
   const order = [0, 1, 2, 3];
@@ -11361,12 +11361,12 @@ function convertPlanes({ width, height, planes: full, ids, adobe }, colorTransfo
     }
   } else {
     const clamp2 = (v) => v < 0 ? 0 : v > 255 ? 255 : v;
-    const fix = (x) => Math.floor(x * 65536 + 0.5);
+    const fix2 = (x) => Math.floor(x * 65536 + 0.5);
     const half = 1 << 15;
-    const crR = fix(1.402);
-    const cbB = fix(1.772);
-    const crG = -fix(0.71414);
-    const cbG = -fix(0.34414);
+    const crR = fix2(1.402);
+    const cbB = fix2(1.772);
+    const crG = -fix2(0.71414);
+    const cbG = -fix2(0.34414);
     for (let i = 0; i < width * height; i++) {
       const y = full[0][i];
       const cb = full[1][i] - 128;
@@ -12333,7 +12333,7 @@ function flattenBezierPath(pts) {
   }
   return out;
 }
-function roundRectCorners(l, t, r, b, cw, ch, compatible = false, clockwise = false) {
+function roundRectCorners(l, t, r, b, cw, ch, compatible = false, clockwise = false, floorH = false) {
   const w = r - l;
   const h = b - t;
   let ew = Math.min(Math.abs(cw), w);
@@ -12346,7 +12346,7 @@ function roundRectCorners(l, t, r, b, cw, ch, compatible = false, clockwise = fa
   const topX = compatible ? Math.round(r - ew / 2) : Math.floor(r - ew / 2);
   const hx = r - topX;
   const verticalControl = clockwise ? Math.ceil(KAPPA * hy) : Math.floor(KAPPA * hy);
-  const horizontalControl = Math.ceil(KAPPA * hx);
+  const horizontalControl = floorH ? Math.floor(KAPPA * hx) : Math.ceil(KAPPA * hx);
   const q = [r, t + hy, r, t + hy - verticalControl, r - hx + horizontalControl, t, topX, t];
   const mx = (x) => l + r - x;
   const my = (y) => t + b - y;
@@ -12473,8 +12473,8 @@ 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));
+    cos.push(Math.fround(Math.cos(k * TRIG_STEP)));
+    sin.push(Math.fround(Math.sin(k * TRIG_STEP)));
   }
   for (let k = 0; k <= 128; k += 32) {
     cos[k] = [1, 0, -1, 0, 1][k / 32];
@@ -12487,7 +12487,7 @@ function polygonTrig(angle) {
   if (b < 0) {
     b += 2 * Math.PI;
   }
-  const x = b / TRIG_STEP;
+  const x = Math.fround(b / TRIG_STEP);
   const i = Math.min(127, Math.floor(x));
   const f = x - i;
   return [
@@ -12507,16 +12507,38 @@ function approximateArcAngle(x, y) {
   if (ax === 0 && ay === 0) {
     return 0;
   }
-  const a = ay <= ax ? interpolatedAtan(ay / ax) : Math.PI / 2 - interpolatedAtan(ax / ay);
+  const a = ay <= ax ? interpolatedAtan(Math.fround(ay / ax)) : Math.PI / 2 - interpolatedAtan(Math.fround(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) {
+function unitPiece(from, to, small, radius = Infinity) {
   const trig = small ? (a) => [Math.cos(a), Math.sin(a)] : polygonTrig;
   const p0 = trig(from);
   const p3 = trig(to);
+  if (small && 6e-8 * radius / Math.abs(Math.sin(to - from)) > 0.5) {
+    const f = Math.fround;
+    const q0 = [f(p0[0]), f(p0[1])];
+    const q3 = [f(p3[0]), f(p3[1])];
+    const det32 = f(f(q0[0] * q3[1]) - f(q0[1] * q3[0]));
+    if (det32 !== 0) {
+      const X = [f(f(q3[1] - q0[1]) / det32), f(f(q0[0] - q3[0]) / det32)];
+      const c = f(polygonTrig(Math.abs(to - from) / 2)[0]);
+      const kappa = f(f(f(4 / 3) * c) / f(1 + c));
+      return {
+        start: p0,
+        ctrl: [
+          f(q0[0] + f(kappa * f(X[0] - q0[0]))),
+          f(q0[1] + f(kappa * f(X[1] - q0[1]))),
+          f(q3[0] + f(kappa * f(X[0] - q3[0]))),
+          f(q3[1] + f(kappa * f(X[1] - q3[1]))),
+          p3[0],
+          p3[1]
+        ]
+      };
+    }
+  }
   const det = p0[0] * p3[1] - p0[1] * p3[0];
   let ctrl;
   if (Math.abs(det) < 1e-12) {
@@ -12536,7 +12558,7 @@ function unitPiece(from, to, small) {
   }
   return { start: p0, ctrl };
 }
-function arcBeziers(l, t, r, b, xs, ys, xe, ye, clockwise, halfX = false, framed = false) {
+function arcBeziers(l, t, r, b, xs, ys, xe, ye, clockwise, halfX = false, framed = false, mirrorX = false) {
   const w = r - l;
   const h = b - t;
   const Q = Math.PI / 2;
@@ -12549,16 +12571,21 @@ function arcBeziers(l, t, r, b, xs, ys, xe, ye, clockwise, halfX = false, framed
   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 mirrored = (a2) => clockwise ? (2 * Math.PI - a2) % (2 * Math.PI) : a2;
+  const small = a1 !== a0 && Math.abs(mirrored(a1) - mirrored(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 = (u, v) => clockwise && halfX ? Math.ceil(cx + rx * u + 0.5 - v) : Math.round(cx + rx * u + (halfX ? 1 + v : 0));
-  const py = (v) => Math.round(cy - ry * v);
-  const eb = axisBox(l, t, r, b);
+  const axis = (r2, c) => Math.fround(r2 * Math.fround(c));
+  const px = (u, v) => mirrorX ? (
+    // The mirrored circle sits on the same centre but its horizontal radius rounds down (native playback, 144 arcs under a mirrored x).
+    Math.round(cx - axis(Math.floor(w / 2), u))
+  ) : clockwise && halfX ? Math.ceil(cx + axis(rx, u) + 0.5 - v) : Math.round(cx + axis(rx, u) + (halfX ? 1 + v : 0));
+  const py = (v) => Math.round(cy - axis(ry, v));
+  const eb = mirrorX ? axisBox(r, t, l, b) : axisBox(l, t, r, b);
   if (halfX) eb.halfX = true;
   const E = ellipseBeziersBox(eb);
   if (clockwise) {
@@ -12594,7 +12621,7 @@ function arcBeziers(l, t, r, b, xs, ys, xe, ye, clockwise, halfX = false, framed
       continue;
     }
     const e = s > 0 ? Math.min(next, a1) : Math.max(next, a1);
-    const piece = unitPiece(a, e, small);
+    const piece = unitPiece(a, e, small, Math.max(rx, ry));
     for (let i = 0; i < 6; i += 2) {
       out.push(px(piece.ctrl[i], piece.ctrl[i + 1]), py(piece.ctrl[i + 1]));
     }
@@ -16262,6 +16289,21 @@ function decodeBmpFile(bytes) {
   return image ? { kind: "rgba", data: image.data, width: image.width, height: image.height } : null;
 }
 
+// src/float32-down.ts
+var float32 = new Float32Array(1);
+var float32Bits = new Uint32Array(float32.buffer);
+function down32(x) {
+  const r = Math.fround(x);
+  if (r <= x || Number.isNaN(r)) return r;
+  if (r === 0) {
+    float32Bits[0] = 2147483649;
+    return float32[0];
+  }
+  float32[0] = r;
+  float32Bits[0] += r > 0 ? -1 : 1;
+  return float32[0];
+}
+
 // src/emf-plus-linear-ramp.ts
 var GAMMA = 2.2;
 function linearRampIntervals(pointCount, rect) {
@@ -16537,30 +16579,76 @@ function pathGradientQuantum(boundary, matrix = IDENTITY) {
   let x1 = -Infinity;
   let y1 = -Infinity;
   for (const p of boundary) {
-    const x = matrix[0] * p.x + matrix[2] * p.y + matrix[4];
-    const y = matrix[1] * p.x + matrix[3] * p.y + matrix[5];
-    x0 = Math.min(x0, x);
-    y0 = Math.min(y0, y);
-    x1 = Math.max(x1, x);
-    y1 = Math.max(y1, y);
+    x0 = Math.min(x0, p.x);
+    y0 = Math.min(y0, p.y);
+    x1 = Math.max(x1, p.x);
+    y1 = Math.max(y1, p.y);
   }
-  const steps = Math.ceil(2 * Math.hypot(x1 - x0, y1 - y0));
+  const w = x1 - x0;
+  const h = y1 - y0;
+  const first = Math.hypot(matrix[0] * w + matrix[2] * h, matrix[1] * w + matrix[3] * h);
+  const second = Math.hypot(matrix[0] * w - matrix[2] * h, matrix[1] * w - matrix[3] * h);
+  const steps = Math.ceil(first + second);
   return Number.isFinite(steps) && steps > 0 ? steps : 0;
 }
+var TIE_LEVEL = 1e-9;
 var TIE_EPSILON = 1e-7;
+function pathGradientRatio(shape, x, y, focusPoint) {
+  const report = { s: NaN };
+  return pathGradientColorAt(shape, x, y, focusPoint, 0, report) === null ? null : report.s;
+}
 function quantisedPathArgb(surround, centre, t, quantum) {
   const scaled2 = t * quantum;
   const tie = Math.abs(scaled2 - Math.floor(scaled2) - 0.5) < TIE_EPSILON;
-  const k = tie ? scaled2 : Math.floor(scaled2 + 0.5);
-  const fromBoundary = t < 0.5;
+  return quantisedStepArgb(surround, centre, tie ? scaled2 : Math.floor(scaled2 + 0.5), quantum, t < 0.5);
+}
+function roundTowards(v, target) {
+  const floor = Math.floor(v);
+  const fraction = v - floor;
+  if (Math.abs(fraction - 0.5) < TIE_LEVEL) return target > v ? floor + 1 : floor;
+  return fraction > 0.5 ? floor + 1 : floor;
+}
+var centreWeightTables = /* @__PURE__ */ new Map();
+function centreWeight(quantum, j) {
+  let table2 = centreWeightTables.get(quantum);
+  if (!table2) {
+    table2 = new Float64Array(quantum + 1);
+    const step = down32(1 / quantum);
+    let w = 0;
+    for (let i = 1; i <= quantum; i++) {
+      w = down32(w + step);
+      table2[i] = w;
+    }
+    if (centreWeightTables.size > 64) centreWeightTables.clear();
+    centreWeightTables.set(quantum, table2);
+  }
+  return table2[j];
+}
+function centreWeightArgb(surround, centre, k, quantum) {
+  const w = centreWeight(quantum, quantum - k);
+  const aS = surround >>> 24 & 255;
+  const aC = centre >>> 24 & 255;
+  const level2 = (s, c) => roundTowards(c + (s - c) * w, c);
+  const alpha = level2(aS, aC);
+  if (alpha <= 0) return 0;
+  const ch = (shift) => {
+    const p = level2((surround >>> shift & 255) * aS / 255, (centre >>> shift & 255) * aC / 255);
+    return Math.min(255, Math.max(0, Math.round(p * 255 / alpha)));
+  };
+  return (alpha << 24 | ch(16) << 16 | ch(8) << 8 | ch(0)) >>> 0;
+}
+function quantisedStepArgb(surround, centre, k, quantum, fromBoundary) {
+  if (Number.isInteger(k)) return centreWeightArgb(surround, centre, k, quantum);
   const w = (fromBoundary ? k : quantum - k) / quantum;
   const aS = surround >>> 24 & 255;
   const aC = centre >>> 24 & 255;
   const mix2 = (s, c) => fromBoundary ? s + (c - s) * w : c + (s - c) * w;
-  const alpha = Math.floor(mix2(aS, aC) + 0.5);
+  const whole = Number.isInteger(k);
+  const level2 = (s, c) => whole ? roundTowards(mix2(s, c), c) : Math.floor(mix2(s, c) + 0.5);
+  const alpha = level2(aS, aC);
   if (alpha <= 0) return 0;
   const ch = (shift) => {
-    const p = Math.floor(mix2((surround >>> shift & 255) * aS / 255, (centre >>> shift & 255) * aC / 255) + 0.5);
+    const p = level2((surround >>> shift & 255) * aS / 255, (centre >>> shift & 255) * aC / 255);
     return Math.min(255, Math.max(0, Math.round(p * 255 / alpha)));
   };
   return (alpha << 24 | ch(16) << 16 | ch(8) << 8 | ch(0)) >>> 0;
@@ -16570,6 +16658,24 @@ function quantisedPosition(pos, quantum) {
   const tie = Math.abs(scaled2 - Math.floor(scaled2) - 0.5) < TIE_EPSILON;
   return (tie ? scaled2 : Math.floor(scaled2 + 0.5)) / quantum;
 }
+function pathGradientStepColor(shape, k, quantum) {
+  const pos = k / quantum;
+  if (shape.preset && shape.preset.positions.length > 0) {
+    const { positions, argb } = shape.preset;
+    if (pos <= positions[0]) return argb[0];
+    for (let i = 1; i < positions.length; i++) {
+      if (pos <= positions[i]) {
+        const span = positions[i] - positions[i - 1];
+        return lerpArgb(argb[i - 1], argb[i], span > 0 ? (pos - positions[i - 1]) / span : 1);
+      }
+    }
+    return argb[positions.length - 1];
+  }
+  const surround = shape.boundaryArgb[0] ?? shape.centerArgb;
+  if (!shape.blend) return quantisedStepArgb(surround, shape.centerArgb, k, quantum, k * 2 < quantum);
+  const t = Math.min(1, Math.max(0, piecewise2(shape.blend.positions, shape.blend.factors, pos)));
+  return surround >>> 24 !== shape.centerArgb >>> 24 ? lerpUniformPathArgb(surround, shape.centerArgb, t) : lerpArgb(surround, shape.centerArgb, t);
+}
 function piecewise2(xs, ys, x) {
   const n = Math.min(xs.length, ys.length);
   if (n === 0) {
@@ -16604,7 +16710,7 @@ function stopColorAt(stops, t) {
   }
   return stops[stops.length - 1].argb;
 }
-function pathGradientColorAt(shape, x, y, focusPoint, quantum) {
+function pathGradientColorAt(shape, x, y, focusPoint, quantum, report) {
   const { center, boundary, boundaryArgb } = shape;
   const n = boundary.length;
   const px = x - center.x;
@@ -16710,6 +16816,7 @@ function pathGradientColorAt(shape, x, y, focusPoint, quantum) {
     }
   }
   if (found < 0 || !Number.isFinite(s)) return null;
+  if (report) report.s = s;
   const exactPos = 1 - s;
   const pos = quantum && quantum > 0 ? quantisedPosition(exactPos, quantum) : exactPos;
   if (shape.preset && shape.preset.positions.length > 0) {
@@ -17306,19 +17413,31 @@ 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 };
+  const carry = { x: 0, y: 0, set: false };
   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), carry);
   }
   return out;
 }
 var RED_EYE_SECTORS = 60;
-var RED_EYE_BLUE_WEIGHT = 0.225;
-var RED_EYE_PURE_WEIGHT = 1 / (1 + RED_EYE_BLUE_WEIGHT);
-var RED_EYE_CARRY = 0.81;
+var RED_EYE_LEGACY = {
+  blueWeight: 0.225,
+  pureWeight: 1 / 1.225,
+  carry: 0.81
+};
+var RED_EYE_CENTRE_SECTOR = 15;
+var RED_EYE_BLUE_WEIGHT = 2 / 9;
+var RED_EYE_PURE_WEIGHT = 1;
+var RED_EYE_CARRY = 1;
+function redEyeLuma(g, b) {
+  return Math.floor((9 * g + 2 * b + 5) / 11);
+}
 var RED_EYE_GREEN_SHARE = 5 / 16;
-var RED_EYE_SPREAD_STEPS = [31.5, 50, 98.78];
+var RED_EYE_SPREAD_STEPS = [25, 40, 80];
 var RED_EYE_STRENGTHS = [0.25, 0.5, 0.661, 0.75];
+var RED_EYE_HIGHLIGHT_RISE = 40;
+var RED_EYE_FALLBACK_SLOPE = 0.33;
+var RED_EYE_HIGHLIGHT_REST = 5;
 function correctRedEyeArea(out, stride, x0, y0, x1, y1, carry) {
   const w = x1 - x0;
   const h = y1 - y0;
@@ -17328,9 +17447,19 @@ function correctRedEyeArea(out, stride, x0, y0, x1, y1, carry) {
   }
   const redness = new Float64Array(count);
   const dark = new Float64Array(count);
+  const lumas = new Int32Array(count);
   let sx = 0;
   let sy = 0;
   let sw = 0;
+  let sxL = 0;
+  let syL = 0;
+  let swL = 0;
+  let redCount = 0;
+  let sx32 = 0;
+  let sy32 = 0;
+  let sw32 = 0;
+  let firstRed = -1;
+  let uniformRed = true;
   for (let y = 0; y < h; y++) {
     for (let x = 0; x < w; x++) {
       const i = ((y0 + y) * stride + x0 + x) * 4;
@@ -17340,24 +17469,53 @@ function correctRedEyeArea(out, stride, x0, y0, x1, y1, carry) {
       const k = y * w + x;
       const d = g + RED_EYE_BLUE_WEIGHT * b;
       dark[k] = d;
+      const dL = g + RED_EYE_LEGACY.blueWeight * b;
+      const luma = redEyeLuma(g, b);
+      lumas[k] = luma;
       const v = r - Math.max(g, b);
       if (v > 0) {
         redness[k] = v;
-        const weight = d >= 1 ? v / d : RED_EYE_PURE_WEIGHT;
+        const weight = luma >= 1 ? v / luma : RED_EYE_PURE_WEIGHT;
         sx += weight * (x + 0.5);
         sy += weight * (y + 0.5);
         sw += weight;
+        redCount++;
+        const weight32 = Math.fround(weight);
+        sx32 = Math.fround(sx32 + Math.fround(weight32 * Math.fround(x + 0.5)));
+        sy32 = Math.fround(sy32 + Math.fround(weight32 * Math.fround(y + 0.5)));
+        sw32 = Math.fround(sw32 + weight32);
+        const triple = r << 16 | g << 8 | b;
+        if (firstRed < 0) {
+          firstRed = triple;
+        } else if (triple !== firstRed) {
+          uniformRed = false;
+        }
+        const weightL = dL >= 1 ? v / dL : RED_EYE_LEGACY.pureWeight;
+        sxL += weightL * (x + 0.5);
+        syL += weightL * (y + 0.5);
+        swL += weightL;
       }
     }
   }
   if (sw === 0) {
     return;
   }
-  let cx = (sx + RED_EYE_CARRY * carry.x) / sw;
-  let cy = (sy + RED_EYE_CARRY * carry.y) / sw;
+  const snap2 = (v) => Math.round(v * 1e9) / 1e9;
+  const lumaCx = snap2((sx + (carry.set ? carry.x - 0.5 : 0) * RED_EYE_CARRY) / sw);
+  const lumaCy = snap2((sy + (carry.set ? carry.y - 0.5 : 0) * RED_EYE_CARRY) / sw);
+  const onPixelCentre = (v) => Number.isInteger(snap2(v - 0.5));
+  const symmetric = redCount > 1 && (onPixelCentre(lumaCx) || onPixelCentre(lumaCy));
+  const exactCentre = (c, sum32) => !onPixelCentre(c) || Math.fround(sum32 / sw32) === c;
+  const exactSymmetric = symmetric && !uniformRed && !carry.set && exactCentre(lumaCx, sx32) && exactCentre(lumaCy, sy32);
+  const legacyWeights = symmetric && !exactSymmetric;
+  let cx = legacyWeights ? (sxL + RED_EYE_LEGACY.carry * (carry.set ? carry.x : 0)) / swL : lumaCx;
+  let cy = legacyWeights ? (syL + RED_EYE_LEGACY.carry * (carry.set ? carry.y : 0)) / swL : lumaCy;
   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)) {
+  carry.set = true;
+  let fellBack = false;
+  if (Math.hypot(cx - w / 2, cy - h / 2) >= (w + h) / 6) {
+    fellBack = true;
     cx = w / 2;
     cy = h / 2;
   }
@@ -17369,10 +17527,17 @@ function correctRedEyeArea(out, stride, x0, y0, x1, y1, carry) {
   if (!(radius > 0)) {
     return;
   }
-  const sorted = Float64Array.from(dark).sort();
-  const spread = sorted[Math.floor(0.7 * count)] - sorted[Math.floor(0.3 * count)];
+  const sorted = Int32Array.from(lumas).sort();
+  const p70 = sorted[Math.floor(0.7 * count)];
+  const spread = p70 - sorted[Math.floor(0.3 * count)];
+  const brightest = sorted[count - 1];
+  const second = count > 1 ? sorted[count - 2] : -1;
+  let highlight = -1;
+  if (brightest > second && brightest - p70 >= RED_EYE_HIGHLIGHT_RISE) {
+    highlight = lumas.indexOf(brightest);
+  }
   let level2 = 0;
-  while (level2 < RED_EYE_SPREAD_STEPS.length && spread >= RED_EYE_SPREAD_STEPS[level2]) {
+  while (level2 < RED_EYE_SPREAD_STEPS.length && spread > RED_EYE_SPREAD_STEPS[level2]) {
     level2++;
   }
   const strength = RED_EYE_STRENGTHS[level2];
@@ -17393,7 +17558,7 @@ function correctRedEyeArea(out, stride, x0, y0, x1, y1, carry) {
       if (angle < 0) {
         angle += 360;
       }
-      const s = Math.min(RED_EYE_SECTORS - 1, Math.floor(angle / 6));
+      const s = dx === 0 && dy === 0 ? RED_EYE_CENTRE_SECTOR : dy === 0 ? 0 : Math.min(RED_EYE_SECTORS - 1, Math.floor(angle / 6));
       sector[k] = s;
       if (d < radius) {
         sectorSum[s] += redness[k];
@@ -17415,8 +17580,13 @@ function correctRedEyeArea(out, stride, x0, y0, x1, y1, carry) {
       const ratio = meanDark > 0 ? dark[k] / meanDark : 1;
       const u = distance[k] / radius;
       const darknessFalloff = ratio < 2 ? 0.5 * (1 - ratio) ** 2 : 0;
-      const falloff = Math.max(strength * (1 - u) * (1 - u), darknessFalloff);
-      const rest = (1 - falloff) * mean;
+      const falloff = Math.max(strength * (1 - u) * (1 - u), darknessFalloff, fellBack ? RED_EYE_FALLBACK_SLOPE * (1 - u) : 0);
+      let rest = (1 - falloff) * mean;
+      if (highlight >= 0) {
+        const hdx = x - highlight % w;
+        const hdy = y - Math.floor(highlight / w);
+        rest = Math.min(rest, RED_EYE_HIGHLIGHT_REST * (hdx * hdx + hdy * hdy));
+      }
       if (rest >= v) {
         continue;
       }
@@ -19636,13 +19806,13 @@ function recordDeviceFigures(buildPath, device) {
     const f = fig;
     f.curved = true;
     const n = f.pts.length;
-    const fix = (v) => toPlusFix(v);
-    const p0x = fix(f.pts[n - 2]);
-    const p0y = fix(f.pts[n - 1]);
+    const fix2 = (v) => toPlusFix(v);
+    const p0x = fix2(f.pts[n - 2]);
+    const p0y = fix2(f.pts[n - 1]);
     f.pts[n - 2] = p0x / 16;
     f.pts[n - 1] = p0y / 16;
     const out = [];
-    const ctrl = [p0x, p0y, fix(dx(c1x, c1y)), fix(dy(c1x, c1y)), fix(dx(c2x, c2y)), fix(dy(c2x, c2y)), fix(dx(x, y)), fix(dy(x, y))];
+    const ctrl = [p0x, p0y, fix2(dx(c1x, c1y)), fix2(dy(c1x, c1y)), fix2(dx(c2x, c2y)), fix2(dy(c2x, c2y)), fix2(dx(x, y)), fix2(dy(x, y))];
     flattenBezierGdiplus(ctrl, out);
     for (const v of out) {
       f.pts.push(v / 16);
@@ -19916,7 +20086,7 @@ function frame(a, b) {
   const uy = (b.y - a.y) / len;
   return { ux, uy, nx: -uy, ny: ux };
 }
-function joinPoints(p, f1, f2, o, pen) {
+function joinPoints(p, f1, f2, o, pen, meetInside = false) {
   const a = { x: p.x + f1.nx * o, y: p.y + f1.ny * o };
   const b = { x: p.x + f2.nx * o, y: p.y + f2.ny * o };
   if (o === 0) {
@@ -19928,6 +20098,11 @@ function joinPoints(p, f1, f2, o, pen) {
   }
   const outer = cross * o < 0;
   if (!outer) {
+    if (meetInside) {
+      const den2 = f1.ux * f2.uy - f1.uy * f2.ux;
+      const t2 = ((b.x - a.x) * f2.uy - (b.y - a.y) * f2.ux) / den2;
+      return [{ x: a.x + f1.ux * t2, y: a.y + f1.uy * t2 }];
+    }
     return [a, b];
   }
   if (pen.join === 2) {
@@ -19995,7 +20170,7 @@ function sidePoints(pts, closed, o, pen) {
     const inIdx = i - 1 >= 0 ? i - 1 : closed ? segs2 - 1 : -1;
     const outIdx = i < segs2 ? i : -1;
     if (inIdx >= 0 && outIdx >= 0) {
-      out.push(...joinPoints(pts[i], frames[inIdx], frames[outIdx], o, pen));
+      out.push(...joinPoints(pts[i], frames[inIdx], frames[outIdx], o, pen, closed && !!pen.compound));
     } else {
       const f = frames[outIdx >= 0 ? outIdx : inIdx];
       out.push({ x: pts[i].x + f.nx * o, y: pts[i].y + f.ny * o });
@@ -20102,6 +20277,50 @@ function signedArea(pts) {
   }
   return a / 2;
 }
+function insidePolygon(pts, q) {
+  let inside = false;
+  for (let i = 0, j = pts.length - 1; i < pts.length; j = i++) {
+    const a = pts[i];
+    const b = pts[j];
+    if (a.y > q.y !== b.y > q.y && q.x < (b.x - a.x) * (q.y - a.y) / (b.y - a.y) + a.x) {
+      inside = !inside;
+    }
+  }
+  return inside;
+}
+function insetCollapses(pts, d) {
+  const sign = signedArea(pts) > 0 ? 1 : -1;
+  const n = pts.length;
+  const frames = Array.from({ length: n }, (_, i) => frame(pts[i], pts[(i + 1) % n]));
+  const moved = pts.map((v, i) => {
+    const f1 = frames[(i + n - 1) % n];
+    const f2 = frames[i];
+    const n1x = f1.nx * sign, n1y = f1.ny * sign, n2x = f2.nx * sign, n2y = f2.ny * sign;
+    const k = 1 + n1x * n2x + n1y * n2y;
+    return k < 1e-9 ? { x: v.x + n1x * d, y: v.y + n1y * d } : { x: v.x + (n1x + n2x) * d / k, y: v.y + (n1y + n2y) * d / k };
+  });
+  return Math.sign(signedArea(moved)) !== sign || moved.some((q) => !insidePolygon(pts, q));
+}
+function innerBoundary(pts, d, pen) {
+  const sign = signedArea(pts) > 0 ? 1 : -1;
+  const n = pts.length;
+  const frames = Array.from({ length: n }, (_, i) => frame(pts[i], pts[(i + 1) % n]));
+  const out = [];
+  for (let i = 0; i < n; i++) {
+    const f1 = frames[(i + n - 1) % n];
+    const f2 = frames[i];
+    const o = sign * d;
+    const cross = f1.ux * f2.uy - f1.uy * f2.ux;
+    if (cross * o < 0) {
+      out.push(...joinPoints(pts[i], f1, f2, o, pen));
+    } else {
+      const n1x = f1.nx * sign, n1y = f1.ny * sign, n2x = f2.nx * sign, n2y = f2.ny * sign;
+      const k = 1 + n1x * n2x + n1y * n2y;
+      out.push(k < 1e-9 ? { x: pts[i].x + n1x * d, y: pts[i].y + n1y * d } : { x: pts[i].x + (n1x + n2x) * d / k, y: pts[i].y + (n1y + n2y) * d / k });
+    }
+  }
+  return out;
+}
 function widenFigures(figures, pen) {
   const polys = [];
   const h = pen.half;
@@ -20113,6 +20332,13 @@ function widenFigures(figures, pen) {
     const closed = fig.closed && pts.length > 2;
     let lo = -h;
     let hi = h;
+    if (pen.inset && closed && !pen.dash && !pen.compound) {
+      polys.push(pts.slice());
+      if (!insetCollapses(pts, 2 * h)) {
+        polys.push(innerBoundary(pts, 2 * h, pen).reverse());
+      }
+      continue;
+    }
     if (pen.inset && closed) {
       if (signedArea(pts) > 0) {
         lo = 0;
@@ -21022,6 +21248,106 @@ async function preDecodeMetafileCaches(view, depth = 0) {
   };
 }
 
+// src/emf-plus-hq-cubic-weights.ts
+var HQ_CUBIC_HALF_TABLE = [
+  [-1675, 5953, 56660, 6337, -1739],
+  [-1612, 5575, 56650, 6727, -1804],
+  [-1550, 5203, 56630, 7123, -1870],
+  [-1489, 4837, 56600, 7525, -1937],
+  [-1429, 4477, 56561, 7931, -2004],
+  [-1371, 4125, 56510, 8345, -2073],
+  [-1313, 3777, 56451, 8763, -2142],
+  [-1257, 3437, 56381, 9187, -2212],
+  [-1202, 3103, 56301, 9617, -2283],
+  [-1148, 2775, 56211, 10053, -2355],
+  [-1095, 2453, 56112, 10493, -2427],
+  [-1044, 2139, 56002, 10939, -2500],
+  [-993, 1829, 55884, 11389, -2573],
+  [-945, 1529, 55754, 11845, -2647],
+  [-897, 1233, 55616, 12305, -2721],
+  [-851, 945, 55467, 12771, -2796],
+  [-806, 663, 55309, 13241, -2871],
+  [-762, 387, 55142, 13715, -2946],
+  [-720, 119, 54964, 14195, -3022],
+  [-679, -143, 54778, 14677, -3097],
+  [-639, -399, 54582, 15165, -3173],
+  [-600, -649, 54377, 15657, -3249],
+  [-563, -891, 54162, 16153, -3325],
+  [-528, -1125, 53937, 16653, -3401],
+  [-493, -1355, 53705, 17155, -3476],
+  [-460, -1577, 53462, 17663, -3552],
+  [-429, -1791, 53210, 18173, -3627],
+  [-398, -2001, 52950, 18687, -3702],
+  [-369, -2203, 52681, 19203, -3776],
+  [-341, -2399, 52403, 19723, -3850],
+  [-315, -2587, 52116, 20245, -3923],
+  [-289, -2771, 51821, 20771, -3996],
+  [-265, -2947, 51517, 21299, -4068],
+  [-243, -3115, 51204, 21829, -4139],
+  [-221, -3279, 50884, 22361, -4209],
+  [-201, -3435, 50554, 22897, -4279],
+  [-182, -3585, 50217, 23433, -4347],
+  [-164, -3729, 49872, 23971, -4414],
+  [-147, -3867, 49518, 24513, -4481],
+  [-131, -3999, 49158, 25053, -4545],
+  [-117, -4123, 48788, 25597, -4609],
+  [-103, -4243, 48412, 26141, -4671],
+  [-90, -4357, 48029, 26685, -4731],
+  [-79, -4463, 47637, 27231, -4790],
+  [-68, -4565, 47239, 27777, -4847],
+  [-59, -4659, 46833, 28323, -4902],
+  [-50, -4749, 46421, 28869, -4955],
+  [-42, -4833, 46002, 29415, -5006],
+  [-35, -4911, 45576, 29961, -5055],
+  [-29, -4983, 45143, 30507, -5102],
+  [-24, -5049, 44704, 31051, -5146],
+  [-19, -5111, 44259, 31595, -5188],
+  [-15, -5167, 43807, 32139, -5228],
+  [-11, -5219, 43351, 32679, -5264],
+  [-8, -5265, 42888, 33219, -5298],
+  [-6, -5305, 42419, 33757, -5329],
+  [-4, -5341, 41944, 34295, -5358],
+  [-3, -5371, 41464, 34829, -5383],
+  [-2, -5397, 40980, 35359, -5404],
+  [-1, -5419, 40490, 35889, -5423],
+  [0, -5437, 39996, 36415, -5438],
+  [0, -5449, 39497, 36937, -5449],
+  [0, -5457, 38993, 37457, -5457],
+  [0, -5461, 38485, 37973, -5461]
+];
+function hqCubicBinWeights(bin) {
+  if (bin < 64) {
+    return { first: -2, weights: HQ_CUBIC_HALF_TABLE[bin] };
+  }
+  return { first: -1, weights: HQ_CUBIC_HALF_TABLE[127 - bin].slice().reverse() };
+}
+var HQ_CUBIC_CDF = (() => {
+  const cdf = new Int32Array(512).fill(Number.NaN);
+  for (let bin = 0; bin < 128; bin++) {
+    const { first, weights } = hqCubicBinWeights(bin);
+    let acc = -32768;
+    for (let i = 0; i <= 5; i++) {
+      const m = 128 * (first + i) - 64 - bin - 1;
+      if (m >= -256 && m <= 255) {
+        cdf[m + 256] = acc;
+      }
+      if (i < 5) {
+        acc += weights[i];
+      }
+    }
+  }
+  return cdf;
+})();
+function hqCubicCdf(m) {
+  if (m < -256) {
+    return -32768;
+  }
+  if (m > 255) {
+    return 32768;
+  }
+  return HQ_CUBIC_CDF[m + 256];
+}
+
 // src/emf-plus-image-resample.ts
 var INTERPOLATION_KERNELS = {
   0: "bilinear",
@@ -21074,6 +21400,20 @@ function snapToDeviceGrid(spec) {
   const [a, b, c, d] = m;
   return [a, b, c, d, ox - a * spec.srcX - c * spec.srcY, oy - b * spec.srcX - d * spec.srcY];
 }
+function snapOriginKeepCorners(spec) {
+  const m = spec.toDevice;
+  const map = (u, v) => [m[0] * u + m[2] * v + m[4], m[1] * u + m[3] * v + m[5]];
+  const [rx, ry] = map(spec.srcX, spec.srcY);
+  const ox = Math.round(rx * SUBPIXEL_GRID) / SUBPIXEL_GRID;
+  const oy = Math.round(ry * SUBPIXEL_GRID) / SUBPIXEL_GRID;
+  const [ux, uy] = map(spec.srcX + spec.srcW, spec.srcY);
+  const [vx, vy] = map(spec.srcX, spec.srcY + spec.srcH);
+  const a = (ux - ox) / spec.srcW;
+  const b = (uy - oy) / spec.srcW;
+  const c = (vx - ox) / spec.srcH;
+  const d = (vy - oy) / spec.srcH;
+  return [a, b, c, d, ox - a * spec.srcX - c * spec.srcY, oy - b * spec.srcX - d * spec.srcY];
+}
 function cubicKernel(t, a) {
   const x = Math.abs(t);
   if (x < 1) {
@@ -21100,18 +21440,6 @@ function cubicIntegral(t, a) {
   }
   return Math.sign(t) * v;
 }
-var FAR_FADE = [1, 1, 0.985, 0.95, 0.91, 0.85, 0.8, 0.745, 0.69, 0.63, 0.56, 0.5, 0.43, 0.35, 0.28, 0.22, 0.16, 0.11, 0.065, 0.03, 0];
-function fadeAt(d, bilinear) {
-  if (d >= 1) {
-    return 0;
-  }
-  if (bilinear) {
-    return 1 - Math.max(0, d);
-  }
-  const x = Math.max(0, d) * 20;
-  const i = Math.floor(x);
-  return FAR_FADE[i] + (FAR_FADE[i + 1] - FAR_FADE[i]) * (x - i);
-}
 function ceilExtent(len) {
   return Math.ceil(len * (1 - 15e-8));
 }
@@ -21119,6 +21447,17 @@ function nearSourceExtent(deviceLen, srcLen) {
   const d = ceilExtent(deviceLen) - srcLen;
   return d >= -1 && d <= 1;
 }
+function unitCopyOffset(t, other, spec) {
+  const f = t - Math.round(t);
+  if (f > -1 / 64 + 1e-9) {
+    return f <= 1 / 64 + 1e-9;
+  }
+  if (Math.abs(f + 1 / 64) > 1e-9 || !isPowerOfTwo(spec.srcW) || !isPowerOfTwo(spec.srcH)) {
+    return false;
+  }
+  const g = (other - Math.round(other)) * 128;
+  return spec.srcW * spec.srcH * Math.max(spec.srcW, spec.srcH) <= 256 || Math.abs(g - Math.round(g)) < 1e-9;
+}
 var BICUBIC_A = -0.5;
 var HQ_BICUBIC_A = -1;
 function axisFilter(kernel, scale, copy) {
@@ -21238,6 +21577,9 @@ function resampleImage(rgba, width, height, spec, surface, options2 = {}) {
     }
     return resampleImage(grown, width + 1, height, { ...spec, rightHalo: void 0 }, surface);
   }
+  if (spec.wrap === "clamp" && (spec.clampArgb ?? 0) >>> 24 === 0 && (spec.kernel === "hq-bicubic" || spec.kernel === "hq-bilinear")) {
+    return resampleImage(rgba, width, height, { ...spec, wrap: void 0, clampArgb: void 0 }, surface, options2);
+  }
   if (spec.kernel === "nearest" && !spec.wrap) {
     return resampleNearest(rgba, width, height, spec, surface);
   }
@@ -21248,32 +21590,21 @@ function resampleImage(rgba, width, height, spec, surface, options2 = {}) {
     m = [m[0], 0, 0, m[3], m[4], m[5]];
   }
   const axisAligned = m[1] === 0 && m[2] === 0;
+  if (hq && !axisAligned && !keepOrigin) {
+    m = snapOriginKeepCorners(spec);
+  }
   let plainRotated = plainRotatedPass;
-  const unitBicubicCopy = kernel === "bicubic" && axisAligned && !spec.halfPixelOffset && m[0] === 1 && m[3] === 1 && m[4] - Math.round(m[4]) > -1 / 64 && m[4] - Math.round(m[4]) <= 1 / 64 && m[5] - Math.round(m[5]) > -1 / 64 && m[5] - Math.round(m[5]) <= 1 / 64;
-  let farFade = false;
+  const unitBicubicCopy = kernel === "bicubic" && axisAligned && !spec.halfPixelOffset && m[0] === 1 && m[3] === 1 && unitCopyOffset(m[4], m[5], spec) && unitCopyOffset(m[5], m[4], spec);
   let shiftX = 0;
   let shiftY = 0;
   if (hq && !axisAligned) {
     const extentU = Math.hypot(m[0], m[1]) * spec.srcW;
     const extentV = Math.hypot(m[2], m[3]) * spec.srcH;
     const near = nearSourceExtent(extentU, spec.srcW) || nearSourceExtent(extentV, spec.srcH);
-    if (!spec.wrap) {
-      return resampleRotatedTwoStage(rgba, width, height, spec, surface, m, kernel, near);
-    } else if (near) {
-      kernel = kernel === "hq-bicubic" ? "bicubic" : "bilinear";
-      plainRotated = true;
-    } else {
-      farFade = true;
-      if (spec.halfPixelOffset) {
-        const lu = Math.hypot(m[0], m[1]);
-        const lv = Math.hypot(m[2], m[3]);
-        shiftX = 0.5 * m[0] / lu + 0.5 * m[2] / lv;
-        shiftY = 0.5 * m[1] / lu + 0.5 * m[3] / lv;
-      }
-    }
+    return resampleRotatedTwoStage(rgba, width, height, spec, surface, m, kernel, near);
   }
   const integerBicubic = kernel === "bicubic" && (axisAligned || plainRotated);
-  if (hq && axisAligned && !spec.wrap && !premultSource) {
+  if (hq && axisAligned && !premultSource) {
     const phased = resampleHqAxisAligned(rgba, width, height, spec, surface, m, premultOut);
     if (phased !== void 0) {
       return phased;
@@ -21334,8 +21665,8 @@ function resampleImage(rgba, width, height, spec, surface, options2 = {}) {
   const vMax = spec.srcY + spec.srcH;
   const wu = [];
   const wv = [];
-  const gradU = Math.hypot(inv2[0], inv2[2]);
-  const gradV = Math.hypot(inv2[1], inv2[3]);
+  Math.hypot(inv2[0], inv2[2]);
+  Math.hypot(inv2[1], inv2[3]);
   const c = spec.clampArgb ?? 0;
   const edge = {
     wrap: spec.wrap,
@@ -21391,18 +21722,6 @@ function resampleImage(rgba, width, height, spec, surface, options2 = {}) {
         return blendSeparable(rgba, width, box, iu0, wu, iv0, wv, kernel === "bicubic", edge, integerBicubic, premultSource);
       };
       let [r, g, b, a] = sampleAt(u, v);
-      if (farFade && !spec.wrap && a > 0) {
-        const du = (uMax - u) / gradU;
-        const dv = (vMax - v) / gradV;
-        const k = 1 - (du < 1 ? fadeAt(du, kernel === "hq-bilinear") * (sampleAt(uMax, v)[3] / a) : 0) - (dv < 1 ? fadeAt(dv, kernel === "hq-bilinear") * (sampleAt(u, vMax)[3] / a) : 0);
-        if (k < 1) {
-          const f = Math.max(0, k);
-          r *= f;
-          g *= f;
-          b *= f;
-          a *= f;
-        }
-      }
       if (a <= 0) {
         continue;
       }
@@ -21430,21 +21749,74 @@ function resampleImage(rgba, width, height, spec, surface, options2 = {}) {
   return { x: bx0, y: by0, w, h, rgba: out };
 }
 var HQ_PHASES = 128;
+function isPowerOfTwo(v) {
+  return Number.isInteger(v) && v > 0 && (v & v - 1) === 0;
+}
+function mirroredUnitIsExact(spec) {
+  return !spec.pointsForm || isPowerOfTwo(spec.srcW) && isPowerOfTwo(spec.srcH);
+}
+function mirroredBias(spec, scale, fractionalEdge) {
+  if (mirroredUnitIsExact(spec)) {
+    return scale === 1 ? -(fractionalEdge ? 2 : 1) * 65536 + (spec.kernel === "hq-bicubic" ? 1 : 0) : 0;
+  }
+  return scale <= 1 ? 1 : 0;
+}
+function hqStep(scale) {
+  return Math.round(65536 / scale);
+}
+function hqTentCdf(j) {
+  if (j <= -128) {
+    return -32768;
+  }
+  if (j >= 128) {
+    return 32768;
+  }
+  return j < 0 ? -(512 * -j - 2 * j * j) : 512 * j - 2 * j * j;
+}
+function hqReductionTaps(cubic, scale, step, position, origin, from, to) {
+  const taps = [];
+  const s = Math.fround(scale);
+  const radius = (cubic ? 2 : 1) * (step / 65536) + 1;
+  for (let k = from; k <= to; k++) {
+    const p = position(k);
+    const centre = origin + p / 65536;
+    const first = Math.ceil(centre - radius);
+    const last = Math.floor(centre + radius);
+    const weights = [];
+    let prev = Number.NaN;
+    for (let t = first; t <= last + 1; t++) {
+      const q = 128 * s * (t - 0.5 - origin - p / 65536);
+      const edge = Math.floor(q);
+      const cdf = cubic ? hqCubicCdf(edge) : hqTentCdf(edge);
+      if (t > first) {
+        weights.push((cdf - prev) / 65536);
+      }
+      prev = cdf;
+    }
+    taps.push({ first, weights });
+  }
+  return taps;
+}
 function resampleHqAxisAligned(rgba, width, height, spec, surface, m, premultOut) {
   const kernel = spec.kernel;
-  const scaleU = m[0];
+  const mirrorU = m[0] < 0;
+  const scaleU = Math.abs(m[0]);
   const scaleV = m[3];
-  if (!(scaleU >= 1 && scaleV >= 1) || spec.rightHalo) {
+  if (!(scaleU > 0 && scaleV > 0) || spec.rightHalo) {
     return void 0;
   }
   const integral = (v) => Math.abs(v - Math.round(v)) < 1e-9;
-  if (scaleU === 1 && scaleV === 1 && integral(m[4]) && integral(m[5])) {
+  if (scaleU === 1 && scaleV === 1 && !mirrorU && integral(m[4]) && integral(m[5])) {
     return void 0;
   }
+  const unitMirror = mirrorU && scaleU === 1;
   const shift = spec.halfPixelOffset ? 0.5 : 0;
-  const left = m[0] * spec.srcX + m[4] - shift;
+  const edge0 = m[0] * spec.srcX + m[4] - shift;
+  const edge1 = edge0 + m[0] * spec.srcW;
+  const rawLeft = spec.toDevice[0] * (spec.srcX + spec.srcW) + spec.toDevice[4] - shift;
+  const left = mirrorU ? Math.round(rawLeft * SUBPIXEL_GRID) / SUBPIXEL_GRID : Math.min(edge0, edge1);
   const top = m[3] * spec.srcY + m[5] - shift;
-  const right = left + m[0] * spec.srcW;
+  const right = mirrorU ? left + scaleU * spec.srcW : Math.max(edge0, edge1);
   const bottom = top + m[3] * spec.srcH;
   const xFirst = Math.ceil(left - COVERAGE_NUDGE_X);
   const xLast = Math.ceil(right - COVERAGE_NUDGE_X) - 1;
@@ -21464,43 +21836,86 @@ function resampleHqAxisAligned(rgba, width, height, spec, surface, m, premultOut
   }
   const cubic = kernel === "hq-bicubic";
   const bin = cubic ? 0.5 : 1;
-  const stepU = Math.round(65536 / scaleU);
-  const stepV = Math.round(65536 / scaleV);
-  const dx = Math.max(0, xFirst - left);
+  const stepU = hqStep(scaleU);
+  const stepV = hqStep(scaleV);
+  const rawLeftEdge = mirrorU ? rawLeft : spec.toDevice[0] * spec.srcX + spec.toDevice[4] - shift;
+  const dxRaw = xFirst - rawLeftEdge;
+  const dx = dxRaw < 1e-5 ? 0 : dxRaw;
   const dy = Math.max(0, yFirst - top);
-  const offsetU = dx > 1e-9 ? Math.round((1 - dx) * stepU) : 0;
+  if (mirrorU && (spec.halfPixelOffset || !integral(spec.srcX) || !integral(spec.srcW))) {
+    return void 0;
+  }
+  const mirroredPixels = xLast - xFirst + 1 + dx;
+  const offsetU = !mirrorU && dx > 1e-9 ? Math.round((1 - dx) * stepU) : 0;
   const offsetV = dy > 1e-9 ? Math.round(dy * stepV) : 0;
   const filterU = axisFilter(kernel, scaleU, false);
   const filterV = axisFilter(kernel, scaleV, false);
-  const tapsFor = (filter, step, offset, origin, from, to) => {
+  const tapsFor = (filter, step, offset, origin, from, to, scale, mirror2 = false) => {
     const taps = [];
+    const farBias = ((step & step - 1) === 0 ? 0 : Math.round(spec.srcW / 170)) + (mirror2 ? mirroredBias(spec, scale, dx > 1e-9) : 0);
+    const position = (k) => mirror2 ? Math.round((mirroredPixels - k) * step) + farBias : k * step + offset;
+    if (mirror2 && unitMirror && dx <= 1e-9 && mirroredUnitIsExact(spec)) {
+      for (let k = from; k <= to; k++) {
+        taps.push({ first: Math.round(origin + position(k) / 65536), weights: [1] });
+      }
+      return taps;
+    }
+    const originBins = origin * HQ_PHASES;
+    const wholeBins = Math.abs(originBins - Math.round(originBins)) < 1e-6;
+    if (scale < 1 && wholeBins) {
+      return hqReductionTaps(cubic, scale, step, position, origin, from, to);
+    }
+    const tabulated = cubic && wholeBins;
     for (let k = from; k <= to; k++) {
-      const phase = Math.floor((k * step + offset - 1) / (65536 / HQ_PHASES));
-      const c = origin + (phase + bin) / HQ_PHASES;
-      const first = Math.ceil(c - filter.radius);
-      const last = Math.floor(c + filter.radius);
+      const phase = Math.floor((position(k) - 1) / (65536 / HQ_PHASES));
+      if (tabulated) {
+        const total = Math.round(originBins) + phase;
+        const bins = hqCubicBinWeights((total % HQ_PHASES + HQ_PHASES) % HQ_PHASES);
+        taps.push({
+          first: Math.floor(total / HQ_PHASES) + bins.first,
+          weights: bins.weights.map((w2) => w2 / 65536)
+        });
+        continue;
+      }
+      const c2 = origin + (phase + bin) / HQ_PHASES;
+      const first = Math.ceil(c2 - filter.radius);
+      const last = Math.floor(c2 + filter.radius);
       const weights = [];
       for (let t = first; t <= last; t++) {
-        weights.push(filter.weight(t, c));
+        weights.push(filter.weight(t, c2));
       }
       taps.push({ first, weights });
     }
     return taps;
   };
-  const colTaps = tapsFor(filterU, stepU, offsetU, spec.srcX, cx0 - xFirst, cx1 - xFirst);
-  const rowTaps = tapsFor(filterV, stepV, offsetV, spec.srcY, cy0 - yFirst, cy1 - yFirst);
+  const colTaps = tapsFor(filterU, stepU, offsetU, spec.srcX, cx0 - xFirst, cx1 - xFirst, scaleU, mirrorU);
+  const rowTaps = tapsFor(filterV, stepV, offsetV, spec.srcY, cy0 - yFirst, cy1 - yFirst, scaleV);
   let rowMin = Infinity;
   let rowMax = -Infinity;
   for (const t of rowTaps) {
     rowMin = Math.min(rowMin, t.first);
     rowMax = Math.max(rowMax, t.first + t.weights.length - 1);
   }
-  rowMin = Math.max(0, rowMin);
-  rowMax = Math.min(height - 1, rowMax);
+  const c = spec.clampArgb ?? 0;
+  const edge = spec.wrap ? {
+    wrap: spec.wrap,
+    clamp: [c >>> 16 & 255, c >>> 8 & 255, c & 255, c >>> 24 & 255],
+    mirrorX: spec.wrap === "tile-flip-x" || spec.wrap === "tile-flip-xy",
+    mirrorY: spec.wrap === "tile-flip-y" || spec.wrap === "tile-flip-xy"
+  } : null;
+  if (!edge) {
+    rowMin = Math.max(0, rowMin);
+    rowMax = Math.min(height - 1, rowMax);
+  }
   const rows = Math.max(0, rowMax - rowMin + 1);
+  const rowMargin = edge || Math.abs(scaleV - 1) < 1e-9 ? Infinity : Math.ceil((cubic ? 2 : 1) / Math.min(1, scaleV));
   const inter = new Uint8Array(rows * w * 4);
   for (let r = 0; r < rows; r++) {
-    const srcRow = (rowMin + r) * width;
+    const rowTexel = edge ? wrapTap(rowMin + r, 0, height, edge.mirrorY, edge) : rowMin + r;
+    if (rowTexel === OUTSIDE_TRANSPARENT || rowTexel < spec.srcY - rowMargin || rowTexel > spec.srcY + spec.srcH + rowMargin - 1) {
+      continue;
+    }
+    const srcRow = rowTexel * width;
     for (let i = 0; i < w; i++) {
       const t = colTaps[i];
       let pr = 0;
@@ -21508,19 +21923,30 @@ function resampleHqAxisAligned(rgba, width, height, spec, surface, m, premultOut
       let pb = 0;
       let pa = 0;
       for (let q = 0; q < t.weights.length; q++) {
-        const tx = t.first + q;
-        if (tx < 0 || tx >= width) {
+        let tx = t.first + q;
+        let px = rgba;
+        let o = 0;
+        if (edge) {
+          tx = wrapTap(tx, 0, width, edge.mirrorX, edge);
+          if (tx === OUTSIDE_TRANSPARENT) {
+            continue;
+          }
+        } else if (tx < 0 || tx >= width) {
           continue;
         }
-        const o = (srcRow + tx) * 4;
-        const a = rgba[o + 3];
+        if (tx === OUTSIDE_CLAMP || rowTexel === OUTSIDE_CLAMP) {
+          px = edge?.clamp ?? [0, 0, 0, 0];
+        } else {
+          o = (srcRow + tx) * 4;
+        }
+        const a = px[o + 3];
         if (a === 0) {
           continue;
         }
         const wq = t.weights[q];
-        pr += wq * Math.round(rgba[o] * a / 255);
-        pg += wq * Math.round(rgba[o + 1] * a / 255);
-        pb += wq * Math.round(rgba[o + 2] * a / 255);
+        pr += wq * Math.round(px[o] * a / 255);
+        pg += wq * Math.round(px[o + 1] * a / 255);
+        pb += wq * Math.round(px[o + 2] * a / 255);
         pa += wq * a;
       }
       const alpha = Math.min(255, Math.max(0, Math.round(pa)));
@@ -21566,7 +21992,7 @@ function resampleHqAxisAligned(rgba, width, height, spec, surface, m, premultOut
   return { x: cx0, y: cy0, w, h, rgba: out, premultiplied: premultOut };
 }
 function resampleRotatedTwoStage(rgba, width, height, spec, surface, m, kernel, near) {
-  const pad = 2;
+  const pad = spec.wrap ? 0 : 2;
   let img;
   let pw;
   let ph;
@@ -21607,7 +22033,9 @@ function resampleRotatedTwoStage(rgba, width, height, spec, surface, m, kernel,
       srcH: spec.srcH,
       toDevice: [kx, 0, 0, ky, -spec.srcX * kx, -spec.srcY * ky],
       kernel,
-      halfPixelOffset: false
+      halfPixelOffset: false,
+      wrap: spec.wrap,
+      clampArgb: spec.clampArgb
     }, { w: W, h: H }, { premultOut: true });
     if (!pre) {
       return null;
@@ -21648,7 +22076,9 @@ function resampleRotatedTwoStage(rgba, width, height, spec, surface, m, kernel,
     srcH: ph,
     toDevice: [a, b, c, d, ex - a * pad - c * pad, ey - b * pad - d * pad],
     kernel: kernel === "hq-bicubic" ? "bicubic" : "bilinear",
-    halfPixelOffset: false
+    halfPixelOffset: false,
+    wrap: spec.wrap,
+    clampArgb: spec.clampArgb
   }, surface, { plainRotated: true, keepOrigin: true, premultSource: true });
   if (!block) {
     return block;
@@ -23772,21 +24202,21 @@ function popState(rCtx, stackId) {
   if (idx !== void 0 && idx < rCtx.saveStack.length) {
     const saved = rCtx.saveStack[idx];
     rCtx.worldTransform = [...saved.transform];
-    const snap = saved.snapshot;
-    if (snap) {
-      rCtx.clipRegion = snap.clipRegion;
-      rCtx.antiAlias = snap.antiAlias;
-      rCtx.interpolationMode = snap.interpolationMode;
-      rCtx.pixelOffsetMode = snap.pixelOffsetMode;
-      rCtx.textRenderingHint = snap.textRenderingHint;
-      rCtx.pageUnit = snap.pageUnit;
-      rCtx.pageScale = snap.pageScale;
+    const snap2 = saved.snapshot;
+    if (snap2) {
+      rCtx.clipRegion = snap2.clipRegion;
+      rCtx.antiAlias = snap2.antiAlias;
+      rCtx.interpolationMode = snap2.interpolationMode;
+      rCtx.pixelOffsetMode = snap2.pixelOffsetMode;
+      rCtx.textRenderingHint = snap2.textRenderingHint;
+      rCtx.pageUnit = snap2.pageUnit;
+      rCtx.pageScale = snap2.pageScale;
       const ext = plusExt(rCtx);
       const { multiFormatSkip, pendingEffect } = ext;
       for (const key of Object.keys(ext)) {
         delete ext[key];
       }
-      Object.assign(ext, snap.ext, { multiFormatSkip, pendingEffect });
+      Object.assign(ext, snap2.ext, { multiFormatSkip, pendingEffect });
     }
     rCtx.saveStack.length = idx;
     const newMap = /* @__PURE__ */ new Map();
@@ -23796,7 +24226,7 @@ function popState(rCtx, stackId) {
       }
     }
     rCtx.saveIdMap = newMap;
-    if (snap) {
+    if (snap2) {
       reapplyPlusClip(rCtx);
     }
   }
@@ -25265,6 +25695,7 @@ function defaultGS() {
     deltaShift: 3,
     instructControl: 0,
     scanControl: false,
+    scanSet: false,
     scanType: 0,
     gep0: 1,
     gep1: 1,
@@ -25277,6 +25708,13 @@ function defaultGS() {
 var HintError = class extends Error {
 };
 var MAX_INSTRUCTIONS = 1e6;
+var SIZE_TWEAK_BODIES = [
+  // MPPEM GTEQ SWAP MPPEM LTEQ AND IF SHPIX ELSE POP POP EIF
+  [75, 83, 35, 75, 81, 90, 88, 56, 27, 33, 33, 89],
+  // MPPEM EQ IF SHPIX ELSE POP POP EIF
+  [75, 84, 88, 56, 27, 33, 33, 89]
+];
+var DEFAULT_DROPOUT_PPEM = 32;
 var HintedSize = class _HintedSize {
   constructor(font, ppemX, ppemY, env, hinting = true) {
     this.fdefs = [];
@@ -25293,6 +25731,8 @@ var HintedSize = class _HintedSize {
     this.callFrames = [];
     /** The glyph program being run belongs to a composite glyph. */
     this.inComposite = false;
+    /** IUP[y] has run in the current glyph program. */
+    this.iupy = false;
     this.count = 0;
     this.font = font;
     this.env = env;
@@ -25360,7 +25800,7 @@ var HintedSize = class _HintedSize {
   }
   /** The scan-conversion mode prep left, used when a glyph program doesn't set its own. */
   get defaultScan() {
-    return { scanControl: this.gs0.scanControl, scanType: this.gs0.scanType };
+    return { scanControl: this.gs0.scanControl, scanSet: this.gs0.scanSet, scanType: this.gs0.scanType };
   }
   // -----------------------------------------------------------------------
   // Glyph loading
@@ -25388,6 +25828,7 @@ var HintedSize = class _HintedSize {
       advance: pp2x - pp1x,
       linearAdvance: mulFix(advance, this.xScale),
       scanControl: res2.scanControl,
+      scanSet: res2.scanSet,
       scanType: res2.scanType
     };
   }
@@ -25452,7 +25893,7 @@ var HintedSize = class _HintedSize {
     let lastScan = scan;
     for (const comp of glyph.components) {
       const sub = this.loadRecursive(comp.glyphIndex, depth + 1);
-      lastScan = { scanControl: sub.scanControl, scanType: sub.scanType };
+      lastScan = { scanControl: sub.scanControl, scanSet: sub.scanSet, scanType: sub.scanType };
       const z = sub.zone;
       const m = z.n - 4;
       if (comp.flags & (WE_HAVE_A_SCALE | WE_HAVE_AN_X_AND_Y_SCALE | WE_HAVE_A_TWO_BY_TWO)) {
@@ -25588,12 +26029,13 @@ var HintedSize = class _HintedSize {
     this.pts = zone;
     this.zp0 = this.zp1 = this.zp2 = zone;
     this.stack = [];
+    this.iupy = false;
     this.computeFuncs();
     try {
       this.execute(instructions);
     } catch {
     }
-    return { zone, scanControl: this.gs.scanControl, scanType: this.gs.scanType };
+    return { zone, scanControl: this.gs.scanControl, scanSet: this.gs.scanSet, scanType: this.gs.scanType };
   }
   // -----------------------------------------------------------------------
   // Vector / projection machinery
@@ -25693,14 +26135,21 @@ var HintedSize = class _HintedSize {
   }
   /**
    * Backward-compatible ClearType reads storage 22 (TypeMan Talk
-   * DStroke/IStroke), 24 (spacing functions) and 8 (VacuFormRound) as 0
-   * inside the functions whose signatures Microsoft documents, which
-   * bypasses them.
+   * DStroke/IStroke) and 24 (spacing functions) as 0 inside the functions
+   * whose signatures Microsoft documents, which bypasses them, and storage
+   * 8 (VacuFormRound) as 0 wherever it is read: the Monotype fonts store
+   * there whether the size is small (`MPPEM <= limit`) and, when it is,
+   * run a block of corner-squaring ALIGNRP and SHPIX calls after the IUPs
+   * that native ClearType never runs (Arial and Times New Roman bowls at
+   * 9 to 17 ppem; 2,890 to 3,059 of 3,720 size-sheet captures exact).
    */
   ctBypassStorage(i) {
     if (!this.ctCompat() || i !== 22 && i !== 24 && i !== 8) {
       return false;
     }
+    if (i === 8) {
+      return true;
+    }
     const frame2 = this.callFrames[this.callFrames.length - 1];
     if (!frame2) {
       return false;
@@ -25711,10 +26160,7 @@ var HintedSize = class _HintedSize {
     if (i === 22) {
       return at([176, 22, 67, 88]);
     }
-    if (i === 24) {
-      return at([1, 176, 24, 67, 88]) || at([1, 24, 176, 24, 67, 88]);
-    }
-    return at([69, 35, 70, 96, 32, 176, 38]);
+    return at([1, 176, 24, 67, 88]) || at([1, 24, 176, 24, 67, 88]);
   }
   /** True when the projection vector points (mostly) along x, ClearType's direction. */
   ctDirection() {
@@ -25884,6 +26330,27 @@ var HintedSize = class _HintedSize {
     this.stack.push(v | 0);
   }
   /** Returns the length of the instruction at `ip` (for skipping). */
+  /**
+   * True for the two generic per-size tweak helpers of Monotype-hinted fonts
+   * (Arial, Times New Roman, Tahoma), whose whole body is `MPPEM >= lo and
+   * MPPEM <= hi: SHPIX` or `MPPEM == ppem: SHPIX`. Native ClearType ignores
+   * the x shifts they issue; the mode-selected variants (the same body behind
+   * `RS 2` / `EQ`), inline shifts and every other function are applied. Measured on
+   * private fonts (`shpix-*.ttf`): any other body, such as extra bytes before
+   * or after the helper, strict comparisons or a missing ELSE branch, is
+   * applied, and the function number does not matter.
+   */
+  static isSizeTweak(def) {
+    if (def.sizeTweak === void 0) {
+      const n = def.end - def.start;
+      def.sizeTweak = SIZE_TWEAK_BODIES.some((body) => body.length === n && body.every((b, i) => def.code[def.start + i] === b));
+    }
+    return def.sizeTweak;
+  }
+  inSizeTweak() {
+    const frame2 = this.callFrames[this.callFrames.length - 1];
+    return !!frame2 && _HintedSize.isSizeTweak(frame2.def);
+  }
   static insLength(code, ip) {
     const op = code[ip];
     if (op === 64) {
@@ -25903,6 +26370,7 @@ var HintedSize = class _HintedSize {
   execute(code) {
     const calls = [];
     this.callFrames = calls;
+    this.count = 0;
     let ip = 0;
     let cur = code;
     while (true) {
@@ -26350,7 +26818,7 @@ var HintedSize = class _HintedSize {
         while (gs.loop > 0) {
           const p = this.pop();
           if (p >= 0 && p < this.zp2.n) {
-            const keep = !this.ctCompat() || this.inComposite || gs.fvx === 0 && (this.zp2.tags[p] & TOUCH_Y) !== 0;
+            const keep = !this.ctCompat() || this.inComposite || gs.fvx === 0 && (this.zp2.tags[p] & TOUCH_Y) !== 0 || gs.fvx !== 0 && !this.env.grayscale && !this.inSizeTweak();
             if (keep) {
               this.moveZp2(p, dx, dy, true);
             }
@@ -26382,7 +26850,7 @@ var HintedSize = class _HintedSize {
           this.zp1.curY[p] - this.zp0.curY[gs.rp0]
         );
         let target = d;
-        if (this.ctCompat() && gs.gep0 !== 0 && gs.gep1 !== 0) {
+        if (this.ctCompat() && this.ctDirection() && gs.gep0 !== 0 && gs.gep1 !== 0) {
           const org = this.dualProjectOrus(
             this.zp1.orusX[p] - this.zp0.orusX[gs.rp0],
             this.zp1.orusY[p] - this.zp0.orusY[gs.rp0]
@@ -26675,6 +27143,7 @@ var HintedSize = class _HintedSize {
       case 133: {
         const v = this.pop();
         const a = v & 255;
+        gs.scanSet = true;
         if (a === 255) {
           gs.scanControl = true;
           return true;
@@ -26685,10 +27154,10 @@ var HintedSize = class _HintedSize {
         }
         if (v & 256 && this.ppem <= a) gs.scanControl = true;
         if (v & 512 && this.env.rotated) gs.scanControl = true;
-        if (v & 1024 && this.stretched) gs.scanControl = true;
+        if (v & 1024 && (this.stretched || this.env.reportStretched)) gs.scanControl = true;
         if (v & 2048 && this.ppem > a) gs.scanControl = false;
         if (v & 4096 && this.env.rotated) gs.scanControl = false;
-        if (v & 8192 && this.stretched) gs.scanControl = false;
+        if (v & 8192 && (this.stretched || this.env.reportStretched)) gs.scanControl = false;
         return true;
       }
       case 134:
@@ -26700,7 +27169,7 @@ var HintedSize = class _HintedSize {
         let k = 0;
         if (sel & 1) k = this.env.version;
         if (sel & 2 && this.env.rotated) k |= 1 << 8;
-        if (sel & 4 && this.stretched) k |= 1 << 9;
+        if (sel & 4 && (this.stretched || this.env.reportStretched)) k |= 1 << 9;
         if (sel & 32 && this.env.grayscale) k |= 1 << 12;
         if (sel & 64 && this.env.clearType) k |= 1 << 13;
         if (sel & 128 && this.env.clearType && this.env.compatibleWidths !== false) k |= 1 << 14;
@@ -27002,6 +27471,7 @@ var HintedSize = class _HintedSize {
     return this.dualProject(mulFix(dx, this.xScale), mulFix(dy, this.yScale));
   }
   insIUP(xAxis) {
+    if (!xAxis) this.iupy = true;
     const z = this.pts;
     const mask = xAxis ? TOUCH_X : TOUCH_Y;
     const orgs = xAxis ? z.orgX : z.orgY;
@@ -27133,7 +27603,7 @@ var HintedSize = class _HintedSize {
         let s = (b & 15) - 8;
         if (s >= 0) s++;
         s *= 1 << 6 - this.gs.deltaShift;
-        if (this.ctCompat() && !(this.gs.fvx === 0 && (this.zp0.tags[a] & TOUCH_Y) !== 0)) {
+        if (this.ctCompat() && (this.iupy || !(this.gs.fvx === 0 && (this.zp0.tags[a] & TOUCH_Y) !== 0))) {
           continue;
         }
         this.move(this.zp0, a, s);
@@ -27812,7 +28282,7 @@ function monoBox(o) {
   }
   return { xMin, xMax, yMin, yMax };
 }
-function rasterizeMono(o, dropout, fixedBox) {
+function rasterizeMono(o, dropout, fixedBox, stubOvershoot = true) {
   const box = fixedBox ?? monoBox(o);
   if (!box) {
     return null;
@@ -27868,10 +28338,10 @@ function rasterizeMono(o, dropout, fixedBox) {
               break;
             case 1:
             case 5:
-              if (left.next === right && left.height <= 0 && !(left.flags & OVERSHOOT_TOP && x2 - x1 >= r.half)) {
+              if (left.next === right && left.height <= 0 && !(stubOvershoot && left.flags & OVERSHOOT_TOP && x2 - x1 >= r.half)) {
                 return;
               }
-              if (right.next === left && left.start === y && !(left.flags & OVERSHOOT_BOTTOM && x2 - x1 >= r.half)) {
+              if (right.next === left && left.start === y && !(stubOvershoot && left.flags & OVERSHOOT_BOTTOM && x2 - x1 >= r.half)) {
                 return;
               }
               pxl = mode === 1 ? e2 : r.floorPub(Math.floor((x1 + x2 + Math.floor(P * 63 / 64)) / 2));
@@ -27927,10 +28397,10 @@ function rasterizeMono(o, dropout, fixedBox) {
                 break;
               case 1:
               case 5:
-                if (left.next === right && left.height <= 0 && !(left.flags & OVERSHOOT_TOP && x2 - x1 >= h.half)) {
+                if (left.next === right && left.height <= 0 && !(stubOvershoot && left.flags & OVERSHOOT_TOP && x2 - x1 >= h.half)) {
                   return;
                 }
-                if (right.next === left && left.start === col && !(left.flags & OVERSHOOT_BOTTOM && x2 - x1 >= h.half)) {
+                if (right.next === left && left.start === col && !(stubOvershoot && left.flags & OVERSHOOT_BOTTOM && x2 - x1 >= h.half)) {
                   return;
                 }
                 pxl = mode === 1 ? e2 : h.floorPub(Math.floor((x1 + x2 + Math.floor(P * 63 / 64)) / 2));
@@ -27956,7 +28426,7 @@ function rasterizeMono(o, dropout, fixedBox) {
   return { width, height, left: box.xMin, top: box.yMax, data };
 }
 var GRAY_OVERSAMPLE = 4;
-function rasterizeSamples(o, kx, ky, padX = 0) {
+function rasterizeSamples(o, kx, ky, padX = 0, dropout = 2, stubOvershoot = true) {
   const n = o.xs.length;
   if (n === 0) {
     return null;
@@ -27985,10 +28455,10 @@ function rasterizeSamples(o, kx, ky, padX = 0) {
     onCurve: o.onCurve,
     endPts: o.endPts
   };
-  const hi = rasterizeMono(big, 2, { xMin: box.xMin * kx, xMax: box.xMax * kx, yMin: box.yMin * ky, yMax: box.yMax * ky });
+  const hi = rasterizeMono(big, dropout, { xMin: box.xMin * kx, xMax: box.xMax * kx, yMin: box.yMin * ky, yMax: box.yMax * ky }, stubOvershoot);
   return hi ? { box, hi } : null;
 }
-function rasterizeGray(o) {
+function rasterizeGray(o, dropout = 2) {
   const n = o.xs.length;
   if (n === 0) {
     return null;
@@ -28018,7 +28488,7 @@ function rasterizeGray(o) {
     onCurve: o.onCurve,
     endPts: o.endPts
   };
-  const hi = rasterizeMono(big, 2, { xMin: box.xMin * k, xMax: box.xMax * k, yMin: box.yMin * k, yMax: box.yMax * k });
+  const hi = rasterizeMono(big, dropout, { xMin: box.xMin * k, xMax: box.xMax * k, yMin: box.yMin * k, yMax: box.yMax * k }, false);
   if (!hi) {
     return null;
   }
@@ -28076,7 +28546,8 @@ function slantRows(b) {
   }
   return { ...b, width, data };
 }
-var RASTER_STRETCH_COST = [0, 0, 120, 150, 250, 250];
+var RASTER_STRETCH_COST = [0, 0, 120, 150, 250, 250, 1150, 1280, 1840];
+var RASTER_MAX_X_SCALE = 5;
 function unitOf(f) {
   return Math.max(1, f.pixHeight - f.internalLeading);
 }
@@ -28499,8 +28970,7 @@ var RealizedFont = class {
     const skew = m && !(Math.abs(m[1]) < 1e-9 && Math.abs(m[2]) < 1e-9) && !(Math.abs(m[0]) < 1e-9 && Math.abs(m[3]) < 1e-9);
     const src = skew ? this.rotatedOutline(index) : this.outline(index);
     if (skew && m) {
-      const p = this.ppem;
-      m = [Math.round(m[0] * p) / p, Math.round(m[1] * p) / p, Math.round(m[2] * p) / p, Math.round(m[3] * p) / p];
+      m = roundedRotationMatrix(m, this.ppem);
     }
     let o = this.mode === "cleartype" && !m && !this.syntheticItalic ? this.ctOutline(index) : src;
     if (this.syntheticItalic || m || subX || subY) {
@@ -28526,11 +28996,12 @@ var RealizedFont = class {
     }
     let bitmap;
     if (this.mode === "mono") {
-      bitmap = rasterizeMono(o, dropoutMode(src.scanControl, src.scanType));
+      bitmap = rasterizeMono(o, dropoutMode(src.scanSet ? src.scanControl : this.ppem <= DEFAULT_DROPOUT_PPEM, src.scanType));
     } else if (this.mode === "cleartype") {
-      bitmap = rasterizeClearType(o, this.gdiPlus);
+      const dropout = src.scanSet ? dropoutMode(src.scanControl, src.scanType) : 2;
+      bitmap = rasterizeClearType(o, this.gdiPlus, this.gdiPlus ? clearTypeSpread(this.ttf) : void 0, dropout);
     } else {
-      bitmap = rasterizeGray(o);
+      bitmap = rasterizeGray(o, src.scanSet ? dropoutMode(src.scanControl, src.scanType) : 2);
     }
     if (bitmap && this.syntheticBold) {
       bitmap = embolden(bitmap, this.mode === "mono" ? 1 : 16);
@@ -28540,6 +29011,19 @@ var RealizedFont = class {
     return g;
   }
 };
+function roundedRotationMatrix(m, ppem) {
+  const isRotation = Math.abs(m[0] - m[3]) < 1e-6 && Math.abs(m[1] + m[2]) < 1e-6;
+  if (isRotation && ppem > 0) {
+    const major = ppem * Math.max(Math.abs(m[0]), Math.abs(m[1]));
+    const target = Math.round(major);
+    if (target >= 1) {
+      const k = target / major;
+      return [m[0] * k, m[1] * k, m[2] * k, m[3] * k];
+    }
+  }
+  const p = ppem;
+  return [Math.round(m[0] * p) / p, Math.round(m[1] * p) / p, Math.round(m[2] * p) / p, Math.round(m[3] * p) / p];
+}
 function embolden(b, full) {
   const w = b.width + 1;
   const data = new Uint8Array(w * b.height);
@@ -28638,8 +29122,9 @@ var GdiFontCollection = class _GdiFontCollection {
    * heights for a negative lfHeight and cell heights for a positive one.
    * The cost model is fitted to GetTextMetrics over lfHeight -60..60 for
    * MS Sans Serif, MS Serif, Courier, Small Fonts, System and Terminal
-   * (98% exact): 150 per pixel too small; 290 plus 350 per pixel too big;
-   * a stretch cost by factor (120, 150, 250, 250 for 2x..5x) plus 100 per
+   * (98% exact): 150 per pixel too small; 290 plus 340 per pixel too big;
+   * a stretch cost by factor (120, 150, 250, 250 for 2x..5x and 1,150,
+   * 1,280 and 1,840 for 6x..8x, the largest GDI uses) plus 100 per
    * extra factor divided by the face's character height (small faces
    * stretch less readily); ties go to the smaller stretch, then to the
    * 96 dpi face. A weight mismatch costs 3 per 10 units (so Terminal's
@@ -28659,9 +29144,9 @@ var GdiFontCollection = class _GdiFontCollection {
     let bestCost = Infinity;
     for (const f of pool) {
       const unit = height < 0 ? unitOf(f) : f.pixHeight;
-      for (let n = 1; n <= 5; n++) {
+      for (let n = 1; n < RASTER_STRETCH_COST.length; n++) {
         const d = unit * n - target;
-        const cost = (d < 0 ? -d * 150 : d > 0 ? 290 + d * 350 : 0) + RASTER_STRETCH_COST[n] + (n > 1 ? 100 * (n - 1) / unitOf(f) : 0) + Math.abs(f.weight - weight) * 3 / 10 + n * 0.01 + (f.vertRes === 96 ? 0 : 1e-3);
+        const cost = (d < 0 ? -d * 150 : d > 0 ? 290 + d * 340 : 0) + RASTER_STRETCH_COST[n] + (n > 1 ? 100 * (n - 1) / unitOf(f) : 0) + Math.abs(f.weight - weight) * 3 / 10 + n * 0.01 + (f.vertRes === 96 ? 0 : 1e-3);
         if (cost < bestCost) {
           bestCost = cost;
           best = { face: f, scale: n };
@@ -28677,7 +29162,7 @@ var GdiFontCollection = class _GdiFontCollection {
       return null;
     }
     const { face, scale } = pick;
-    const scaleX = spec.width > 0 && face.avgWidth > 0 ? Math.max(1, Math.ceil(spec.width / face.avgWidth - 0.5)) : scale;
+    const scaleX = spec.width > 0 && face.avgWidth > 0 ? Math.max(1, Math.ceil(spec.width / face.avgWidth - 0.5)) : Math.min(scale, RASTER_MAX_X_SCALE);
     return new RasterRealizedFont(face, scale, weight >= 600 && face.weight < 600, scaleX, spec.italic && !face.italic);
   }
   /**
@@ -28828,9 +29313,15 @@ function resolvePpem(font, height) {
   return ppem;
 }
 var CLEARTYPE_OVERSAMPLE = 6;
-function rasterizeClearType(o, truncate = false) {
+function clearTypeSpread(ttf) {
+  if (ttf.family.toLowerCase() !== "courier new") {
+    return void 0;
+  }
+  return { left: 1, right: ttf.weightClass >= 600 ? 1 : 2 };
+}
+function rasterizeClearType(o, truncate = false, spread, dropout = 2) {
   const S = CLEARTYPE_OVERSAMPLE / 3;
-  const r = rasterizeSamples(o, CLEARTYPE_OVERSAMPLE, 1, 1);
+  const r = rasterizeSamples(o, CLEARTYPE_OVERSAMPLE, 1, 1, dropout, false);
   if (!r) {
     return null;
   }
@@ -28844,12 +29335,23 @@ function rasterizeClearType(o, truncate = false) {
     sub.fill(0);
     const row2 = y * hi.width;
     for (let x = 0; x < hi.width; x++) {
-      if (hi.data[row2 + x]) {
+      let on = hi.data[row2 + x] !== 0;
+      if (spread && !on) {
+        for (let k = x - spread.right; k <= x + spread.left && !on; k++) {
+          on = k >= 0 && k < hi.width && hi.data[row2 + k] !== 0;
+        }
+      }
+      if (on) {
         sub[Math.floor(x / S)] += 1;
       }
     }
     for (let j = 0; j < n; j++) {
-      const acc = (j > 0 ? sub[j - 1] : 0) + sub[j] + (j + 1 < n ? sub[j + 1] : 0);
+      const before = j > 0 ? sub[j - 1] : 0;
+      const after = j + 1 < n ? sub[j + 1] : 0;
+      let acc = before + sub[j] + after;
+      if (spread && acc === 1 && sub[j] === 0 && (j % 3 === 0 && before === 1 || (j + 1) % 3 === 0 && after === 1)) {
+        acc = 0;
+      }
       data[y * n + j] = (truncate ? Math.floor : Math.round)(255 * acc / (3 * S));
     }
   }
@@ -30168,22 +30670,27 @@ function penPolygon(width, height = width) {
   return pen;
 }
 var matrixPenCache = /* @__PURE__ */ new Map();
+function halfVectorComponent(v) {
+  return Math.sign(v) * Math.floor(Math.abs(v) + 0.75);
+}
 function penPolygonMatrix(width, m) {
   const key = `${width},${m.join(",")}`;
   const cached = matrixPenCache.get(key);
   if (cached) {
     return cached;
   }
-  const r = Math.ceil(width / 2);
+  const scale = Math.hypot(m[0], m[1]);
+  if (Math.abs(Math.hypot(m[2], m[3]) - scale) < 1e-4 * scale && Math.abs(m[0] * m[2] + m[1] * m[3]) < 1e-4 * scale * scale && width * scale < HOBBY_LIMIT) {
+    const digital = penPolygon(Math.round(width * scale));
+    matrixPenCache.set(key, digital);
+    return digital;
+  }
+  const h = width / 2;
   const mirror2 = m[0] * m[3] - m[1] * m[2] < 0 ? -1 : 1;
-  const bez = ellipseBeziers(-r, -r, r, r);
-  const dev = [];
-  for (let i = 0; i < 14; i += 2) {
-    const x = bez[i];
-    const y = bez[i + 1] * mirror2;
-    dev.push(Math.round(m[0] * x + m[2] * y), Math.round(m[1] * x + m[3] * y));
-  }
-  const f = flattenBezierPath(dev);
+  const hx = [halfVectorComponent(m[0] * h), halfVectorComponent(m[1] * h)];
+  const hy = [mirror2 * halfVectorComponent(m[2] * h), mirror2 * halfVectorComponent(m[3] * h)];
+  const box = ellipseBeziersBox({ ax: -hx[0] - hy[0], ay: -hx[1] - hy[1], exx: 2 * hx[0], exy: 2 * hx[1], eyx: 2 * hy[0], eyy: 2 * hy[1] });
+  const f = flattenBezierPath(box.slice(0, 14));
   const half = [];
   for (let i = 0; i + 1 < f.length; i += 2) {
     half.push([f[i], f[i + 1]]);
@@ -30255,9 +30762,10 @@ function perpendicularVectors(width, dx0, dy0, height = width, matrixPen) {
   const den = 2 * (bh - hB + (bh - hS));
   const w = den === 0 ? 0 : (hB - hS) / den;
   const x = D[0] + (B[0] - D[0]) * w, y = D[1] + (B[1] - D[1]) * w;
-  const signs = [dx === 0 ? 0 : Math.sign(dy), Math.sign(dx)];
-  const firstEdge = best === 0 && hP >= hN;
   const num = hB - hS;
+  const sign = (c) => Math.sign(den === 0 ? D[c] : D[c] * den + (B[c] - D[c]) * num);
+  const signs = matrixPen ? [sign(0) !== 0 ? -sign(0) : dx === 0 ? 0 : Math.sign(dy), sign(1) !== 0 ? sign(1) : Math.sign(dx)] : [dx === 0 ? 0 : Math.sign(dy), Math.sign(dx)];
+  const firstEdge = matrixPen ? best < n / 2 : best === 0 && hP >= hN;
   const rounded = [0, 1].map((c) => {
     const bias2 = signs[c] + 2 * oddEdgeAdjustment(Math.abs(B[c] - D[c]) % 2 === 1, firstEdge);
     if (den === 0) {
@@ -30284,7 +30792,8 @@ function squareExtension(width, dx, dy, scale = 1, height = width, matrix, whole
       if (l === 0) return [0, 0];
     }
     const q = width / 2 * scale / l;
-    return [Math.floor((matrix[0] * lx + matrix[2] * ly) * q + 0.5), Math.floor((matrix[1] * lx + matrix[3] * ly) * q + 0.5)];
+    const round2 = symmetric ? (v) => Math.sign(v) * Math.floor(Math.abs(v) + 0.5) : (v) => Math.floor(v + 0.5);
+    return [round2((matrix[0] * lx + matrix[2] * ly) * q), round2((matrix[1] * lx + matrix[3] * ly) * q)];
   }
   const [ax, ay] = typeof logicalScale === "number" ? [logicalScale, logicalScale] : logicalScale;
   const r = width / 2 * scale;
@@ -30338,7 +30847,8 @@ var Outliner = class {
     const [L, R] = drawVertices(this.pen, d[0], d[1], this.opts.width, this.opts.height, nibMatrix);
     const perpendicular = curve && drawDir ? drawDir : [dx, dy];
     const vectors = perpendicularVectors(this.opts.width, perpendicular[0], perpendicular[1], this.opts.height, nibMatrix ? this.pen : void 0);
-    return { dx, dy, L, R, v: vectors.v, vRaw: vectors.ray, e: squareExtension(this.opts.capWidth ?? this.opts.width, perpendicular[0], perpendicular[1], 1, this.opts.height ?? this.opts.capWidth, nibMatrix, !!(this.opts.wholePixelDashVectors || this.opts.cutToLogicalUnits), void 0, this.opts.logicalScale), pe: [perpendicular[0], perpendicular[1]], curveEnd: !!drawDir, role: drawDir?.[2] ?? 3, tangentLength: drawDir ? drawDir[0] * drawDir[0] + drawDir[1] * drawDir[1] : 0, curve };
+    const reversed = !!drawDir && dx * drawDir[0] + dy * drawDir[1] < 0;
+    return { dx, dy, tx: reversed ? drawDir[0] : dx, ty: reversed ? drawDir[1] : dy, L, R, v: vectors.v, vRaw: vectors.ray, e: squareExtension(this.opts.capWidth ?? this.opts.width, perpendicular[0], perpendicular[1], 1, this.opts.height ?? this.opts.capWidth, nibMatrix, !!(this.opts.wholePixelDashVectors || this.opts.cutToLogicalUnits), void 0, this.opts.logicalScale), pe: [perpendicular[0], perpendicular[1]], curveEnd: !!drawDir, role: drawDir?.[2] ?? 3, 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]]);
@@ -30451,7 +30961,7 @@ var Outliner = class {
     const sv = this.capSide(s, from);
     const ev = this.capSide(s, to);
     if (cap === "square") {
-      const e0 = scale === 1 || s.curveEnd ? s.e : squareExtension(this.opts.width, s.pe[0], s.pe[1], scale, this.opts.height, this.opts.deviceNib ? this.opts.matrix : void 0, false, !!this.opts.wholePixelDashVectors);
+      const e0 = scale === 1 || s.curveEnd ? s.e : this.scaledExtension(s, scale);
       const e = start ? [-e0[0], -e0[1]] : e0;
       this.push(p, [sv[0] + e[0], sv[1] + e[1]]);
       this.push(p, [ev[0] + e[0], ev[1] + e[1]]);
@@ -30460,6 +30970,23 @@ var Outliner = class {
       this.push(p, ev);
     }
   }
+  /**
+   * The square-cap extension of a dash end that GDI scales by its real over whole-pixel length. At one logical unit per device pixel the
+   * extension is the vector component times (half the width over the whole-pixel length), a float32 product of a float32 ratio, rounded
+   * half away from zero; ties of the exact product (110.5, 3.5, 57.5, -62.5) fall where that single-precision value puts them.
+   */
+  scaledExtension(s, scale) {
+    const o = this.opts;
+    if (o.wholePixelDashVectors && !o.matrix && !o.dashMetric && (o.height === void 0 || o.height === o.width)) {
+      const length = norm(Math.floor(s.pe[0] / 16), Math.floor(s.pe[1] / 16)) * 16;
+      if (length > 0) {
+        const ratio = Math.fround(o.width / 2 / length);
+        const component = (v) => Math.sign(v) * Math.floor(Math.fround(Math.abs(v) * ratio) + 0.5);
+        return [component(s.pe[0]), component(s.pe[1])];
+      }
+    }
+    return squareExtension(o.width, s.pe[0], s.pe[1], scale, o.height, o.deviceNib ? o.matrix : void 0, false, !!o.wholePixelDashVectors);
+  }
   /**
    * The join at `p` on `side`, coming along `a` and leaving along `b` in
    * outline order (for the left side, walked backwards, `a` is the later
@@ -30503,7 +31030,7 @@ var Outliner = class {
           }
         }
       } else if (join === "miter") {
-        const m = miterPoint(sa, [a.dx, a.dy], sb, [b.dx, b.dy], width, miterLimit, side, this.opts.height);
+        const m = miterPoint(sa, [a.dx, a.dy], sb, [b.dx, b.dy], width, miterLimit, side, this.opts.height, this.opts.deviceNib ? this.opts.matrix : void 0);
         if (m) {
           this.push(p, m);
         }
@@ -30577,7 +31104,7 @@ var Outliner = class {
     for (let i = 0; i + 1 < segs2.length; i++) {
       const s = segs2[i];
       const t = segs2[i + 1];
-      const tr = turnSign(s.dx, s.dy, t.dx, t.dy);
+      const tr = turnSign(s.tx, s.ty, t.tx, t.ty);
       if (tr === 0) {
         this.push(P[i + 1], this.joinSide(s, "R"));
       } else {
@@ -30588,7 +31115,7 @@ var Outliner = class {
     for (let i = segs2.length - 1; i > 0; i--) {
       const s = segs2[i];
       const t = segs2[i - 1];
-      const tr = turnSign(t.dx, t.dy, s.dx, s.dy);
+      const tr = turnSign(t.tx, t.ty, s.tx, s.ty);
       if (tr === 0) {
         this.push(P[i], this.joinSide(s, "L"));
       } else {
@@ -30608,7 +31135,7 @@ var Outliner = class {
       const i = j % m;
       const s = segs2[(i + m - 1) % m];
       const t = segs2[i];
-      const tr = turnSign(s.dx, s.dy, t.dx, t.dy);
+      const tr = turnSign(s.tx, s.ty, t.tx, t.ty);
       if (tr === 0) {
         this.push(P[i], this.joinSide(s, "R"));
       } else {
@@ -30620,7 +31147,7 @@ var Outliner = class {
       const i = (m - j) % m;
       const s = segs2[i];
       const t = segs2[(i + m - 1) % m];
-      const tr = turnSign(t.dx, t.dy, s.dx, s.dy);
+      const tr = turnSign(t.tx, t.ty, s.tx, s.ty);
       if (tr === 0) {
         this.push(P[i], this.joinSide(s, "L"));
       } else {
@@ -30640,6 +31167,14 @@ var Outliner = class {
     this.flush();
   }
 };
+function nearestUnit(v) {
+  return Math.sign(v) * Math.floor((Math.abs(v) + 8) / 16) * 16;
+}
+function cutCoordinate(x0, d, t, len) {
+  const offset = Math.abs(d) * (t / len);
+  const v = Math.fround(x0 + (d < 0 ? -offset : offset));
+  return d < 0 ? Math.ceil(v - 0.5) : Math.floor(v + 0.5);
+}
 function dashPieces(P, tangents, curveFlags, pattern, shorten, wholePixelVectors, metric, matrix) {
   const out = [];
   const dashes = [];
@@ -30662,7 +31197,7 @@ function dashPieces(P, tangents, curveFlags, pattern, shorten, wholePixelVectors
     const dir = [x1 - x0, y1 - y0];
     const det = matrix ? matrix[0] * matrix[3] - matrix[1] * matrix[2] : 1;
     const real = matrix ? Math.hypot((matrix[3] * dir[0] - matrix[2] * dir[1]) / det, (-matrix[1] * dir[0] + matrix[0] * dir[1]) / det) : metric ? Math.hypot(dir[0] / metric[0], dir[1] / metric[1]) : norm(dir[0], dir[1]);
-    const len = metric || matrix ? real : wholePixelVectors ? norm(Math.floor(dir[0] / 16), Math.floor(dir[1] / 16)) * 16 : norm(dir[0], dir[1]);
+    const len = metric ? norm(nearestUnit(dir[0] / metric[0]), nearestUnit(dir[1] / metric[1])) : matrix ? norm(nearestUnit((matrix[3] * dir[0] - matrix[2] * dir[1]) / det), nearestUnit((-matrix[1] * dir[0] + matrix[0] * dir[1]) / det)) : wholePixelVectors ? norm(Math.floor(dir[0] / 16), Math.floor(dir[1] / 16)) * 16 : norm(dir[0], dir[1]);
     if (len === 0) {
       if (on && cur) {
         cur.pts.push(P[i + 1]);
@@ -30675,7 +31210,7 @@ function dashPieces(P, tangents, curveFlags, pattern, shorten, wholePixelVectors
     let t = 0;
     while (len - t > left || left === 0 && on) {
       t += left;
-      const q = [Math.floor(x0 + dir[0] * t / len + 0.5), Math.floor(y0 + dir[1] * t / len + 0.5)];
+      const q = [cutCoordinate(x0, dir[0], t, len), cutCoordinate(y0, dir[1], t, len)];
       if (on && cur) {
         cur.pts.push(q);
         cur.dirs.push(dir);
@@ -30732,7 +31267,7 @@ function widenInLogicalSpace(path, opts, m) {
   });
 }
 function widenPath(path, opts) {
-  if (opts.matrix && !(opts.deviceNib && opts.join === "round")) {
+  if (opts.matrix && !opts.deviceNib) {
     return widenInLogicalSpace(path, opts, opts.matrix);
   }
   const out = [];
@@ -30786,7 +31321,7 @@ function widenPath(path, opts) {
   }
   return out;
 }
-function miterPoint(sa, da, sb, db, width, limit, side, height = width) {
+function miterPoint(sa, da, sb, db, width, limit, side, height = width, matrix) {
   const den = da[0] * db[1] - da[1] * db[0];
   if (den === 0) {
     return null;
@@ -30799,6 +31334,12 @@ function miterPoint(sa, da, sb, db, width, limit, side, height = width) {
   const x = Math.sign(mx) * Math.floor(Math.abs(mx) + 0.5);
   const y = Math.sign(my) * Math.floor(Math.abs(my) + 0.5);
   const pixel = side === "L" ? Math.ceil : Math.floor;
+  if (matrix) {
+    const det = matrix[0] * matrix[3] - matrix[1] * matrix[2];
+    const lx = (matrix[3] * x - matrix[2] * y) / det;
+    const ly = (-matrix[1] * x + matrix[0] * y) / det;
+    return Math.hypot(Math.round(lx / 16), Math.round(ly / 16)) > limit * width / 32 ? null : [x, y];
+  }
   const yDistance = height === width ? pixel(y / 16) : pixel(y / 16) * width / height;
   if (Math.hypot(pixel(x / 16), yDistance) > limit * width / 32) {
     return null;
@@ -30882,9 +31423,12 @@ function boxFrame(box) {
   const h = Math.round(Math.hypot(box.eyx, box.eyy));
   return { l: 0, t: 0, r: w, b: h };
 }
-function roundRectDeviceBeziers(box, cw, ch, clockwise = false, compatible = false) {
+function roundRectDeviceBeziers(box, cw, ch, recordedClockwise = false, compatible = false) {
   const f = boxFrame(box);
-  const q = roundRectCorners(f.l, f.t, f.r, f.b, cw, ch, compatible, clockwise);
+  const mirrorX = isAxisBox(box) && box.exx < 0;
+  const mirrorY = isAxisBox(box) && box.eyy < 0;
+  const clockwise = recordedClockwise !== mirrorY;
+  const q = roundRectCorners(f.l, f.t, f.r, f.b, cw, ch, compatible, clockwise, mirrorX);
   const map = frameMapper(box, f.l, f.t, f.r - f.l, f.b - f.t);
   const pts = [];
   for (let i = 0; i < q.length; i += 2) {
@@ -30936,6 +31480,11 @@ function roundRectDeviceBeziers(box, cw, ch, clockwise = false, compatible = fal
       set(15, null, f.b - hy);
     }
   }
+  if (mirrorX) {
+    for (let i = 0; i < pts.length; i += 2) {
+      pts[i] = f.l + f.r - pts[i];
+    }
+  }
   return pts;
 }
 function roundRectRasterPath(box, cw, ch, clockwise = false, rectangle = false, compatible = false) {
@@ -30949,7 +31498,7 @@ function roundRectRasterPath(box, cw, ch, clockwise = false, rectangle = false,
   path.closeFigure();
   return path;
 }
-function arcRasterPath(box, s, e, clockwise, kind, from, path = new GdiRasterPath()) {
+function arcRasterPath(box, s, e, clockwise, kind, from, path = new GdiRasterPath(), mirror2) {
   const f = boxFrame(box);
   const map = frameMapper(box, f.l, f.t, f.r - f.l, f.b - f.t);
   let sx = s[0];
@@ -30971,12 +31520,19 @@ function arcRasterPath(box, s, e, clockwise, kind, from, path = new GdiRasterPat
     if (det < 0) {
       cw = !cw;
     }
+  } else if (mirror2) {
+    cw = clockwise !== mirror2.y;
+    if (mirror2.x) {
+      sx = f.l + f.r - sx;
+      ex = f.l + f.r - ex;
+    }
   } else {
     if (box.exx < 0 !== box.eyy < 0) {
       cw = !cw;
     }
   }
-  const bz = arcBeziers(f.l, f.t, f.r, f.b, sx, sy, ex, ey, cw, !!box.halfX, !!box.framed);
+  const mirrorX = !!mirror2?.x && isAxisBox(box);
+  const bz = arcBeziers(f.l, f.t, f.r, f.b, sx, sy, ex, ey, cw, !!box.halfX, !!box.framed, mirrorX);
   const pts = [];
   for (let i = 0; i < bz.length; i += 2) {
     pts.push(...map(bz[i], bz[i + 1]));
@@ -30990,7 +31546,7 @@ function arcRasterPath(box, s, e, clockwise, kind, from, path = new GdiRasterPat
   if (kind === "pie") {
     const w = f.r - f.l;
     const h = f.b - f.t;
-    const [cx, cy] = map(f.l + Math.ceil(w / 2) + (box.halfX ? 1 : 0), f.t + Math.ceil(h / 2));
+    const [cx, cy] = map(f.l + Math.ceil(w / 2) + (box.halfX && !mirrorX ? 1 : 0), f.t + Math.ceil(h / 2));
     path.lineTo(cx, cy);
   }
   if (kind === "pie" || kind === "chord") {
@@ -31031,8 +31587,10 @@ function penWidenOptions(rCtx, opts = {}) {
   const rotatedOrSheared = Math.abs(matrix[1]) >= 1e-6 || Math.abs(matrix[2]) >= 1e-6;
   const quarterTurn = Math.abs(matrix[0]) < 1e-9 && Math.abs(matrix[3]) < 1e-9;
   const general = !rCtx.wholeDevicePixels && rotatedOrSheared && !quarterTurn && Math.abs(det) > 1e-9 && state.penWidth * Math.sqrt(Math.abs(det)) * 16 >= 1;
-  const dashes = state.penExtended ? ellipse || general ? geometricStyle(flags, state.penWidth, state.penUserStyle, 1) : geometricStyle(flags, widthPx, state.penUserStyle, widthPx / (state.penWidth || 1)) : null;
-  const dashMetric = ellipse && dashes ? [Math.abs(matrix[0]), Math.abs(matrix[3])] : void 0;
+  const unrotated = Math.abs(matrix[1]) < 1e-6 && Math.abs(matrix[2]) < 1e-6;
+  const scaled2 = !rCtx.wholeDevicePixels && unrotated && (Math.abs(Math.abs(matrix[0]) - 1) > 1e-6 || Math.abs(Math.abs(matrix[3]) - 1) > 1e-6);
+  const dashes = state.penExtended ? ellipse || general || scaled2 ? geometricStyle(flags, state.penWidth, state.penUserStyle, 1) : geometricStyle(flags, widthPx, state.penUserStyle, widthPx / (state.penWidth || 1)) : null;
+  const dashMetric = (ellipse || scaled2) && !general && dashes ? [Math.abs(matrix[0]), Math.abs(matrix[3])] : void 0;
   if (general) {
     return {
       width: Math.round(state.penWidth * 16),
@@ -31047,8 +31605,6 @@ function penWidenOptions(rCtx, opts = {}) {
       cutToLogicalUnits: !dashes
     };
   }
-  const unrotated = Math.abs(matrix[1]) < 1e-6 && Math.abs(matrix[2]) < 1e-6;
-  const scaled2 = !rCtx.wholeDevicePixels && unrotated && (Math.abs(Math.abs(matrix[0]) - 1) > 1e-6 || Math.abs(Math.abs(matrix[3]) - 1) > 1e-6);
   const uniform = scaled2 && !ellipse && state.penExtended && (flags & 15) !== 6;
   return {
     width: Math.round((ellipse ? state.penWidth * Math.abs(matrix[0]) : widthPx) * 16),
@@ -31062,7 +31618,7 @@ function penWidenOptions(rCtx, opts = {}) {
     // One logical unit per device pixel, unrotated: GDI measures dash
     // segments in whole pixels.
     wholePixelDashVectors: Math.abs(matrix[0] - 1) < 1e-6 && Math.abs(matrix[3] - 1) < 1e-6 && Math.abs(matrix[1]) < 1e-6 && Math.abs(matrix[2]) < 1e-6,
-    ...scaled2 && !dashes ? {
+    ...scaled2 ? {
       cutToLogicalUnits: true,
       logicalScale: ellipse ? [Math.abs(matrix[0]), Math.abs(matrix[3])] : Math.abs(matrix[0]),
       // A square cap extends by half the unrounded width in FIX.
@@ -31495,6 +32051,406 @@ function withoutOutline(spans, path) {
   return out;
 }
 
+// src/emf-plus-path-gradient-copies.ts
+var fix = (v) => Math.floor(v * 16 + 0.5) / 16;
+var TIE = 1e-6;
+var STRIP_TIE = 5e-3;
+var CONTAINMENT_TIE = 5e-4;
+var SLANTED_NEAR = 5e-6;
+var CEIL_EPSILON = 1e-9;
+function prepareCopies(shape, full, steps) {
+  const n = shape.boundary.length;
+  if (n < 3 || steps <= 0) return null;
+  const isotropic = !shape.focus || Math.abs(shape.focus.x - shape.focus.y) <= 1e-9;
+  const focus = shape.focus && isotropic ? Math.min(1, Math.max(0, shape.focus.x)) : 0;
+  const vx = new Float64Array(n);
+  const vy = new Float64Array(n);
+  for (let i = 0; i < n; i++) {
+    const p = shape.boundary[i];
+    vx[i] = fix(full[0] * p.x + full[2] * p.y + full[4]);
+    vy[i] = fix(full[1] * p.x + full[3] * p.y + full[5]);
+  }
+  const c = shape.center;
+  const cx = fix(full[0] * c.x + full[2] * c.y + full[4]);
+  const cy = fix(full[1] * c.x + full[3] * c.y + full[5]);
+  const anisotropic = isotropic ? null : {
+    ...shape,
+    boundary: Array.from(vx, (x, i) => ({ x, y: vy[i] })),
+    center: { x: cx, y: cy },
+    boundaryArgb: shape.boundaryArgb,
+    blend: null,
+    preset: null,
+    transform: null
+  };
+  let degenerate = false;
+  for (let i = 0; i < n; i++) {
+    const j = (i + 1) % n;
+    if ((vx[i] - cx) * (vy[j] - cy) - (vy[i] - cy) * (vx[j] - cx) === 0) degenerate = true;
+  }
+  return { cx, cy, vx, vy, steps, focus, anisotropic, degenerate };
+}
+function floatCopyIndex(g, edge, dx, dy) {
+  const n = g.vx.length;
+  const ax = g.vx[edge] - g.cx;
+  const ay = g.vy[edge] - g.cy;
+  const ex = g.vx[(edge + 1) % n] - g.vx[edge];
+  const ey = g.vy[(edge + 1) % n] - g.vy[edge];
+  const denominator = down32(down32(ex * dy) - down32(ey * dx));
+  if (denominator === 0) return null;
+  const u = down32(down32(down32(ay * dx) - down32(ax * dy)) / denominator);
+  const bx = down32(ax + down32(u * ex));
+  const by = down32(ay + down32(u * ey));
+  const useX = Math.abs(bx) >= Math.abs(by);
+  const boundary = useX ? bx : by;
+  if (boundary === 0) return null;
+  const r = Math.abs(down32((useX ? dx : dy) / boundary));
+  return Math.max(0, Math.floor(down32(down32(g.steps * r) + 0.5)));
+}
+function focusCopyIndex(g, edge, px, py) {
+  const n = g.vx.length;
+  const dx = px - g.cx;
+  const dy = py - g.cy;
+  const f = Math.fround(g.focus);
+  const j = (edge + 1) % n;
+  const ax = g.vx[edge] - g.cx;
+  const ay = g.vy[edge] - g.cy;
+  const ex = g.vx[j] - g.vx[edge];
+  const ey = g.vy[j] - g.vy[edge];
+  const denominator = down32(down32(ex * dy) - down32(ey * dx));
+  if (denominator === 0) return null;
+  const u = down32(down32(down32(ay * dx) - down32(ax * dy)) / denominator);
+  const bx = down32(ax + down32(u * ex));
+  const by = down32(ay + down32(u * ey));
+  const useX = Math.abs(bx) >= Math.abs(by);
+  const b = useX ? bx : by;
+  if (b === 0) return null;
+  const c = useX ? g.cx : g.cy;
+  const p = useX ? px : py;
+  const outer = down32(c + b);
+  const scaled2 = (c0, v) => down32(c0 + down32(f * (v - c0)));
+  const f0x = scaled2(g.cx, g.vx[edge]);
+  const f0y = scaled2(g.cy, g.vy[edge]);
+  const f1x = scaled2(g.cx, g.vx[j]);
+  const f1y = scaled2(g.cy, g.vy[j]);
+  const fax = down32(f0x - g.cx);
+  const fay = down32(f0y - g.cy);
+  const fex = down32(f1x - f0x);
+  const fey = down32(f1y - f0y);
+  const focusDenominator = down32(down32(fex * dy) - down32(fey * dx));
+  if (focusDenominator === 0) return null;
+  const fu = down32(down32(down32(fay * dx) - down32(fax * dy)) / focusDenominator);
+  const inner = down32((useX ? f0x : f0y) + down32(fu * (useX ? fex : fey)));
+  const span = Math.fround(outer - inner);
+  if (span === 0) return null;
+  const t = down32(Math.fround(p - inner) / span);
+  const position = Math.fround(down32(g.steps * t) + 0.5);
+  if (ex !== 0 && ey !== 0) {
+    const ulp = (v) => 2 ** (Math.floor(Math.log2(Math.abs(v) || 1)) - 23);
+    const slack = g.steps * (ulp(inner) + ulp(outer)) / Math.abs(span);
+    const short = Math.ceil(position) - position;
+    if (short > 0 && short <= slack) return null;
+  }
+  return Math.max(0, Math.floor(position));
+}
+function tieSide(g, edge, dx, dy, q, focus = 0) {
+  const n = g.vx.length;
+  const ex = g.vx[(edge + 1) % n] - g.vx[edge];
+  const ey = g.vy[(edge + 1) % n] - g.vy[edge];
+  if (ex === 0 && ey === 0) return null;
+  const adx = Math.abs(dx);
+  const ady = Math.abs(dy);
+  let odd = g.steps;
+  while (odd % 2 === 0) odd /= 2;
+  const fractional = (2 * q + 1) % odd !== 0;
+  const axisAligned = ex === 0 || ey === 0;
+  const alike = axisAligned ? ex === 0 ? adx <= ady : ady <= adx : Math.abs(ex) === Math.abs(ey) || Math.abs(ex) > Math.abs(ey) === adx > ady;
+  if (!alike) return axisAligned ? fractional : null;
+  const forward = ex > 0 || ex === 0 && ey > 0;
+  if (!forward) return focus > 0 && !axisAligned ? null : fractional;
+  if (dx * ex + dy * ey < 0) return fractional || !edgeParameterIsBinary(g, edge, dx, dy, q);
+  return fractional && adx === ady;
+}
+function gcd(a, b) {
+  while (b) [a, b] = [b, a % b];
+  return a;
+}
+function edgeParameterIsBinary(g, edge, dx, dy, q) {
+  const n = g.vx.length;
+  const k = 16;
+  const ex = Math.round((g.vx[(edge + 1) % n] - g.vx[edge]) * k);
+  const ey = Math.round((g.vy[(edge + 1) % n] - g.vy[edge]) * k);
+  const ax = Math.round((g.vx[edge] - g.cx) * k);
+  const ay = Math.round((g.vy[edge] - g.cy) * k);
+  const S = 2 * q + 1;
+  const D = 2 * g.steps;
+  const P = Math.round(dx * k) * ex + Math.round(dy * k) * ey;
+  const A = ax * ex + ay * ey;
+  const numerator = P * D - A * S;
+  const denominator = (ex * ex + ey * ey) * S;
+  if (!Number.isSafeInteger(numerator) || !Number.isSafeInteger(denominator)) return false;
+  if (numerator === 0) return true;
+  let d = Math.abs(denominator / gcd(Math.abs(numerator), Math.abs(denominator)));
+  while (d % 2 === 0) d /= 2;
+  return d === 1;
+}
+function insideCopy(g, scale, px, py, scaleY = scale) {
+  const n = g.vx.length;
+  let xl = Infinity;
+  let xr = -Infinity;
+  let ax = g.cx + (g.vx[n - 1] - g.cx) * scale;
+  let ay = g.cy + (g.vy[n - 1] - g.cy) * scaleY;
+  for (let i = 0; i < n; i++) {
+    const bx = g.cx + (g.vx[i] - g.cx) * scale;
+    const by = g.cy + (g.vy[i] - g.cy) * scaleY;
+    if (ay <= py && by > py || by <= py && ay > py) {
+      const x = ax + (py - ay) / (by - ay) * (bx - ax);
+      if (x < xl) xl = x;
+      if (x > xr) xr = x;
+    }
+    ax = bx;
+    ay = by;
+  }
+  return xl !== Infinity && px >= Math.ceil(xl - CEIL_EPSILON) && px < Math.ceil(xr - CEIL_EPSILON);
+}
+function edgeAt(g, scaleX, scaleY, px, py) {
+  const n = g.vx.length;
+  const near = 1e-6;
+  let hit = null;
+  let vertexRow = false;
+  for (let i = 0; i < n; i++) {
+    const j = (i + 1) % n;
+    const ax = g.cx + (g.vx[i] - g.cx) * scaleX;
+    const ay = g.cy + (g.vy[i] - g.cy) * scaleY;
+    const bx = g.cx + (g.vx[j] - g.cx) * scaleX;
+    const by = g.cy + (g.vy[j] - g.cy) * scaleY;
+    if (Math.abs(ax - bx) < near && Math.abs(px - ax) < near && py >= Math.min(ay, by) - near && py <= Math.max(ay, by) + near) return { kind: "vertical", edge: i };
+    if (Math.abs(ay - by) < near && Math.abs(py - ay) < near && px >= Math.min(ax, bx) - near && px <= Math.max(ax, bx) + near) return { kind: "horizontal", edge: i };
+    if (Math.abs(ay - py) < near) vertexRow = true;
+    const length = Math.hypot(bx - ax, by - ay);
+    if (length < near) continue;
+    const across = ((px - ax) * (by - ay) - (py - ay) * (bx - ax)) / length;
+    const along = ((px - ax) * (bx - ax) + (py - ay) * (by - ay)) / (length * length);
+    if (Math.abs(across) < SLANTED_NEAR && along >= -near && along <= 1 + near) hit = { kind: "slanted", edge: i };
+  }
+  return hit ?? (vertexRow ? { kind: "slanted", edge: -1 } : null);
+}
+function focusedEdgeStep(g, px, py) {
+  const focus = g.anisotropic.focus;
+  const full = 1 - 1e-9;
+  if (focus.x < full && focus.y < full) return void 0;
+  const n = g.vx.length;
+  let onEdge = false;
+  for (let i = 0; i < n && !onEdge; i++) {
+    const j = (i + 1) % n;
+    const near = 1e-6;
+    if (focus.x >= full && Math.abs(g.vx[i] - g.vx[j]) < near && Math.abs(px - g.vx[i]) < near && py >= Math.min(g.vy[i], g.vy[j]) - near && py <= Math.max(g.vy[i], g.vy[j]) + near) onEdge = true;
+    if (focus.y >= full && Math.abs(g.vy[i] - g.vy[j]) < near && Math.abs(py - g.vy[i]) < near && px >= Math.min(g.vx[i], g.vx[j]) - near && px <= Math.max(g.vx[i], g.vx[j]) + near) onEdge = true;
+  }
+  if (!onEdge) return void 0;
+  const fx = Math.min(1, Math.max(0, focus.x));
+  const fy = Math.min(1, Math.max(0, focus.y));
+  for (let m = 0; m <= g.steps; m++) {
+    const along = m === g.steps ? 1 : (m + 0.5) / g.steps;
+    if (insideCopy(g, fx + (1 - fx) * along, px, py, fy + (1 - fy) * along)) return g.steps - m;
+  }
+  return null;
+}
+function anisotropicTieStep(g, q, tie, dx, dy, px, py) {
+  const focus = g.anisotropic.focus;
+  const along = (tie + 0.5) / g.steps;
+  const fx = Math.min(1, Math.max(0, focus.x));
+  const fy = Math.min(1, Math.max(0, focus.y));
+  const scaleX = fx + (1 - fx) * along;
+  const scaleY = fy + (1 - fy) * along;
+  const hit = edgeAt(g, scaleX, scaleY, px, py);
+  const half = g.steps - tie - 0.5;
+  if (hit?.kind === "slanted") return half;
+  if (hit === null && Math.abs(q - tie) >= CONTAINMENT_TIE) return half;
+  if (hit === null) return g.steps - tie - (insideCopy(g, scaleX, px, py, scaleY) ? 0 : 1);
+  let odd = g.steps;
+  while (odd % 2 === 0) odd /= 2;
+  const fractional = (2 * tie + 1) % odd !== 0;
+  const vertical = hit.kind === "vertical";
+  if (vertical ? Math.abs(dx) > Math.abs(dy) : Math.abs(dy) > Math.abs(dx)) return g.steps - tie - (fractional ? 0 : 1);
+  const n = g.vx.length;
+  const ex = g.vx[(hit.edge + 1) % n] - g.vx[hit.edge];
+  const ey = g.vy[(hit.edge + 1) % n] - g.vy[hit.edge];
+  if (!(ex > 0 || ex === 0 && ey > 0)) return g.steps - tie - (fractional ? 0 : 1);
+  if (dx * ex + dy * ey >= 0) return g.steps - tie - (fractional && Math.abs(dx) === Math.abs(dy) ? 0 : 1);
+  const ax = g.cx + (g.vx[hit.edge] - g.cx) * scaleX;
+  const ay = g.cy + (g.vy[hit.edge] - g.cy) * scaleY;
+  const u = vertical ? (py - ay) / (ey * scaleY) : (px - ax) / (ex * scaleX);
+  const scaled2 = u * 2 ** 24;
+  const binary = Math.abs(scaled2 - Math.round(scaled2)) < 1e-4;
+  return g.steps - tie - (fractional || !binary ? 0 : 1);
+}
+function copiesStepAt(g, px, py, nudge = 0) {
+  const n = g.vx.length;
+  let s = -1;
+  let edge = -1;
+  const dx = px - g.cx;
+  const dy = py - g.cy;
+  for (let i = 0; i < n; i++) {
+    const ax = g.vx[i] - g.cx;
+    const ay = g.vy[i] - g.cy;
+    const ex = g.vx[(i + 1) % n] - g.vx[i];
+    const ey = g.vy[(i + 1) % n] - g.vy[i];
+    const det = ax * ey - ay * ex;
+    if (Math.abs(det) < 1e-12) continue;
+    const alpha = (dx * ey - dy * ex) / det;
+    const beta = (ax * dy - ay * dx) / det;
+    if (alpha < -1e-9 || beta < -1e-9 || beta > alpha + 1e-9 || alpha > 1 + 1e-9) continue;
+    s = alpha;
+    edge = i;
+  }
+  if (g.anisotropic) {
+    const edge2 = s > 1 - 1e-9;
+    const column2 = focusedEdgeStep(g, px, py);
+    if (column2 !== void 0) return column2;
+    const ratio = pathGradientRatio(g.anisotropic, px + nudge, py, { x: px, y: py });
+    if (ratio === null) return null;
+    if (edge2) return Math.max(0, g.steps * (1 - ratio));
+    s = ratio;
+  }
+  if (s < 0) return null;
+  if (g.degenerate && !insideCopy(g, 1, px, py)) return null;
+  if (!g.anisotropic && g.focus === 0 && edge >= 0) {
+    const m2 = floatCopyIndex(g, edge, dx, dy);
+    if (m2 !== null) {
+      if (m2 >= g.steps && !insideCopy(g, 1, px, py)) return null;
+      return g.steps - Math.min(m2, g.steps);
+    }
+  }
+  if (!g.anisotropic && g.focus > 0 && g.focus < 1 && edge >= 0 && !(px === g.cx && py === g.cy)) {
+    const m2 = focusCopyIndex(g, edge, px, py);
+    if (m2 !== null) {
+      if (m2 >= g.steps && !insideCopy(g, 1, px, py)) return null;
+      return g.steps - Math.min(m2, g.steps);
+    }
+  }
+  const f = g.focus;
+  const q = s <= f ? 0 : (s - f) / (1 - f) * g.steps - 0.5;
+  if (q > 0 && Math.abs(q - Math.round(q)) < (g.anisotropic ? STRIP_TIE : TIE)) {
+    const tie = Math.round(q);
+    if (g.anisotropic) return anisotropicTieStep(g, q, tie, dx, dy, px, py);
+    const decided = edge >= 0 ? tieSide(g, edge, dx, dy, tie, f) : null;
+    if (decided !== null) return g.steps - tie - (decided ? 0 : 1);
+    return g.steps - tie - 0.5;
+  }
+  const m = Math.max(0, Math.ceil(q));
+  if (m >= g.steps && !insideCopy(g, 1, px, py)) return null;
+  return g.steps - Math.min(m, g.steps);
+}
+
+// src/emf-plus-path-gradient-vertices.ts
+var FRACTION_BITS = 16;
+var ONE = 2 ** FRACTION_BITS;
+var CEIL_EPSILON2 = 1e-9;
+var snap = (v) => Math.ceil(v * 16 - 1e-9) / 16;
+function premultiplied2(argb) {
+  const a = argb >>> 24;
+  return [a, (argb >>> 16 & 255) * a / 255, (argb >>> 8 & 255) * a / 255, (argb & 255) * a / 255];
+}
+function prepareVertexGradient(shape, full) {
+  const n = shape.boundary.length;
+  if (n < 3 || shape.preset || shape.blend || shape.boundaryArgb.length < n) {
+    return null;
+  }
+  if (shape.boundaryArgb.every((color) => color === shape.boundaryArgb[0])) {
+    return null;
+  }
+  const vx = new Float64Array(n);
+  const vy = new Float64Array(n);
+  const vc = new Float64Array(n * 4);
+  for (let i = 0; i < n; i++) {
+    const p = shape.boundary[i];
+    vx[i] = snap(full[0] * p.x + full[2] * p.y + full[4]);
+    vy[i] = snap(full[1] * p.x + full[3] * p.y + full[5]);
+    vc.set(premultiplied2(shape.boundaryArgb[i]), i * 4);
+  }
+  const c = shape.center;
+  return {
+    cx: snap(full[0] * c.x + full[2] * c.y + full[4]),
+    cy: snap(full[1] * c.x + full[3] * c.y + full[5]),
+    vx,
+    vy,
+    vc,
+    cc: premultiplied2(shape.centerArgb)
+  };
+}
+function edgeChannel(ax, ay, bx, by, ca, cb, x, y) {
+  const dx = bx - ax;
+  const dy = by - ay;
+  let t = 0;
+  if (Math.abs(dx) > Math.abs(dy)) {
+    const steps = Math.trunc(Math.abs(dx));
+    if (steps > 0) t = Math.abs(x - Math.floor(ax)) / steps;
+  } else {
+    const steps = Math.trunc(Math.abs(dy));
+    if (steps > 0) t = Math.abs(y - Math.floor(ay)) / steps;
+  }
+  return Math.trunc((ca + (cb - ca) * t) * ONE);
+}
+function vertexGradientColorAt(g, px, py) {
+  const n = g.vx.length;
+  let result = null;
+  const tx = [0, 0, 0];
+  const ty = [0, 0, 0];
+  const out = [0, 0, 0, 0];
+  for (let f = 0; f < n; f++) {
+    const f1 = (f + 1) % n;
+    tx[0] = g.cx;
+    tx[1] = g.vx[f];
+    tx[2] = g.vx[f1];
+    ty[0] = g.cy;
+    ty[1] = g.vy[f];
+    ty[2] = g.vy[f1];
+    let left = -1;
+    let right = -1;
+    let xl = Infinity;
+    let xr = -Infinity;
+    for (let i = 0; i < 3; i++) {
+      const j = (i + 1) % 3;
+      const ay = ty[i];
+      const by = ty[j];
+      if (!(ay <= py && by > py || by <= py && ay > py)) continue;
+      const x = tx[i] + (py - ay) / (by - ay) * (tx[j] - tx[i]);
+      if (x < xl) {
+        xl = x;
+        left = i;
+      }
+      if (x > xr) {
+        xr = x;
+        right = i;
+      }
+    }
+    if (left < 0 || right < 0 || left === right) continue;
+    const xs = Math.ceil(xl - CEIL_EPSILON2);
+    const xe = Math.ceil(xr - CEIL_EPSILON2);
+    if (px < xs || px >= xe) continue;
+    const li = left;
+    const lj = (left + 1) % 3;
+    const ri = right;
+    const rj = (right + 1) % 3;
+    for (let q = 0; q < 4; q++) {
+      const colors = [g.cc[q], g.vc[f * 4 + q], g.vc[f1 * 4 + q]];
+      const cL = edgeChannel(tx[li], ty[li], tx[lj], ty[lj], colors[li], colors[lj], xs, py);
+      const cR = edgeChannel(tx[ri], ty[ri], tx[rj], ty[rj], colors[ri], colors[rj], xe, py);
+      const step = Math.floor((cR - cL) / (xe - xs));
+      const v = cL + step * (px - xs);
+      out[q] = Math.max(0, Math.min(255, Math.floor((v + ONE / 2) / ONE)));
+    }
+    const alpha = out[0];
+    if (alpha === 0) {
+      result = 0;
+      continue;
+    }
+    const ch = (premult) => Math.min(255, Math.round(premult * 255 / alpha));
+    result = (alpha << 24 | ch(out[1]) << 16 | ch(out[2]) << 8 | ch(out[3])) >>> 0;
+  }
+  return result;
+}
+
 // src/emf-plus-exact-fill.ts
 var IDENTITY4 = [1, 0, 0, 1, 0, 0];
 var MAX_EXACT_PIXELS = 16 * 1024 * 1024;
@@ -31573,17 +32529,110 @@ function pixelAligned(boundary, m) {
   }
   return [x0, y0, x1, y1].every((v) => Math.abs(v - Math.round(v)) < 1e-6);
 }
-function pathGradientSampler(shape, wrap, device) {
+var TILE_WEIGHT_STEPS = 2048;
+function tileIndex(i, n, mirror2) {
+  if (!mirror2) {
+    return (i % n + n) % n;
+  }
+  const m = (i % (2 * n) + 2 * n) % (2 * n);
+  return m < n ? m : 2 * n - 1 - m;
+}
+function fractionalTileSampler(shape, wrap, full) {
+  if (Math.abs(full[1]) > 1e-9 || Math.abs(full[2]) > 1e-9 || full[0] <= 0 || full[3] <= 0) return null;
+  if (!shape.boundaryArgb.every((color) => color === shape.boundaryArgb[0])) return null;
+  let x0 = Infinity;
+  let y0 = Infinity;
+  let x1 = -Infinity;
+  let y1 = -Infinity;
+  for (const point of shape.boundary) {
+    const x = full[0] * point.x + full[4];
+    const y = full[3] * point.y + full[5];
+    x0 = Math.min(x0, x);
+    y0 = Math.min(y0, y);
+    x1 = Math.max(x1, x);
+    y1 = Math.max(y1, y);
+  }
+  const round = (v) => Math.floor(v + 0.5);
+  const width = round(x1) - round(x0);
+  const height = round(y1) - round(y0);
+  if (!(x1 > x0) || !(y1 > y0) || width < 1 || height < 1 || width * height > 4 * 1024 * 1024) return null;
+  const kx = width / (x1 - x0);
+  const ky = height / (y1 - y0);
+  const toTile = (point) => ({
+    x: (full[0] * point.x + full[4] - x0) * kx,
+    y: (full[3] * point.y + full[5] - y0) * ky
+  });
+  const inner = pathGradientSampler({
+    ...shape,
+    boundary: shape.boundary.map(toTile),
+    center: toTile(shape.center),
+    transform: null
+  }, "clamp", IDENTITY4, false);
+  if (!inner) return null;
+  const mirrorX = wrap === "tile-flip-x" || wrap === "tile-flip-xy";
+  const mirrorY = wrap === "tile-flip-y" || wrap === "tile-flip-xy";
+  let texels = null;
+  const texel = () => {
+    if (texels) return texels;
+    const rgba = new Uint8ClampedArray(width * height * 4);
+    inner(0, 0, width, height, rgba);
+    texels = new Float64Array(width * height * 4);
+    for (let i = 0; i < width * height; i++) {
+      const a = rgba[i * 4 + 3];
+      texels[i * 4] = rgba[i * 4] * a / 255;
+      texels[i * 4 + 1] = rgba[i * 4 + 1] * a / 255;
+      texels[i * 4 + 2] = rgba[i * 4 + 2] * a / 255;
+      texels[i * 4 + 3] = a;
+    }
+    return texels;
+  };
+  return (px, py, w, h, out) => {
+    const t = texel();
+    for (let j = 0; j < h; j++) {
+      const v = ky * (py + j - y0);
+      const iv = Math.floor(v);
+      const wy = Math.floor((v - iv) * TILE_WEIGHT_STEPS + 0.5) / TILE_WEIGHT_STEPS;
+      const r0 = tileIndex(iv, height, mirrorY) * width;
+      const r1 = tileIndex(iv + 1, height, mirrorY) * width;
+      for (let i = 0; i < w; i++) {
+        const u = kx * (px + i - x0);
+        const iu = Math.floor(u);
+        const wx = Math.floor((u - iu) * TILE_WEIGHT_STEPS + 0.5) / TILE_WEIGHT_STEPS;
+        const c0 = tileIndex(iu, width, mirrorX);
+        const c1 = tileIndex(iu + 1, width, mirrorX);
+        const o = (j * w + i) * 4;
+        const sample2 = (k) => (1 - wx) * (1 - wy) * t[(r0 + c0) * 4 + k] + wx * (1 - wy) * t[(r0 + c1) * 4 + k] + (1 - wx) * wy * t[(r1 + c0) * 4 + k] + wx * wy * t[(r1 + c1) * 4 + k];
+        const coverage = sample2(3);
+        const alpha = Math.floor(coverage + 0.5);
+        if (alpha <= 0) {
+          out[o] = out[o + 1] = out[o + 2] = out[o + 3] = 0;
+          continue;
+        }
+        const scale = coverage >= 255 ? 1 : 255 / coverage;
+        out[o] = Math.min(255, Math.floor(sample2(0) * scale + 0.5));
+        out[o + 1] = Math.min(255, Math.floor(sample2(1) * scale + 0.5));
+        out[o + 2] = Math.min(255, Math.floor(sample2(2) * scale + 0.5));
+        out[o + 3] = alpha;
+      }
+    }
+  };
+}
+function pathGradientSampler(shape, wrap, device, strictOutside = true) {
   const box = boundaryBox2(shape.boundary);
   const full = mulMatrix(device, shape.transform ?? IDENTITY4);
   const inv2 = invertAffine(full);
   if (!box || !inv2) {
     return null;
   }
-  const anisotropicFocus = !!shape.focus && Math.abs(shape.focus.x - shape.focus.y) > 1e-9;
+  if (wrap !== "clamp" && !pixelAligned(shape.boundary, full)) {
+    const tiled = fractionalTileSampler(shape, wrap, full);
+    if (tiled) return tiled;
+  }
   const uniformSurround = shape.boundaryArgb.every((color) => color === shape.boundaryArgb[0]);
-  const smooth = !uniformSurround && !shape.preset || anisotropicFocus || wrap !== "clamp" && !pixelAligned(shape.boundary, full);
+  const smooth = !uniformSurround && !shape.preset || wrap !== "clamp" && !pixelAligned(shape.boundary, full);
   const quantum = smooth ? 0 : pathGradientQuantum(shape.boundary, full);
+  const vertexGradient = wrap === "clamp" || pixelAligned(shape.boundary, full) ? prepareVertexGradient(shape, full) : null;
+  const copies = quantum > 0 ? prepareCopies(shape, full, quantum) : null;
   const pxX = Math.hypot(full[0], full[1]);
   const pxY = Math.hypot(full[2], full[3]);
   const lagX = pxX > 0 ? 1 / pxX : 0;
@@ -31604,7 +32653,25 @@ function pathGradientSampler(shape, wrap, device) {
         }
         if (wrap === "clamp" && by >= box.y + box.h) continue;
         const focusPoint = bias ? { x: bx - inv2[0] * bias, y: by - inv2[1] * bias } : void 0;
-        const c = pathGradientColorAt(shape, bx, by, focusPoint, quantum);
+        let c = null;
+        let decided = false;
+        if (vertexGradient || copies) {
+          const fx = wrap === "clamp" ? x0 + i : full[0] * bx + full[2] * by + full[4];
+          const fy = wrap === "clamp" ? dy : full[1] * bx + full[3] * by + full[5];
+          const rx = Math.round(fx);
+          const ry = Math.round(fy);
+          if (Math.abs(fx - rx) < 1e-6 && Math.abs(fy - ry) < 1e-6) {
+            if (vertexGradient) {
+              c = vertexGradientColorAt(vertexGradient, rx, ry);
+              if (c === null && strictOutside) decided = true;
+            } else if (copies) {
+              const step = copiesStepAt(copies, rx, ry, bias);
+              if (step !== null) c = pathGradientStepColor(shape, step, quantum);
+              else if (strictOutside && !copies.anisotropic) decided = true;
+            }
+          }
+        }
+        if (c === null && !decided) c = pathGradientColorAt(shape, bx, by, focusPoint, quantum);
         if (c === null) {
           continue;
         }
@@ -32205,6 +33272,23 @@ function handleLineTo(rCtx, dataOff, recSize) {
   }
   return true;
 }
+function cosmeticRectangleBox(rCtx, box) {
+  const { state } = rCtx;
+  if (rCtx.inPath || state.penStyle === 5 || state.penStyle === 6 || box.exy !== 0 || box.eyx !== 0 || box.exx === 0 || box.eyy === 0 || !penIsCosmetic(rCtx)) {
+    return box;
+  }
+  const ax = Math.ceil(box.ax / 16) * 16;
+  const ay = Math.ceil(box.ay / 16) * 16;
+  return { ...box, ax, ay, exx: Math.ceil((box.ax + box.exx) / 16) * 16 - ax, eyy: Math.ceil((box.ay + box.eyy) / 16) * 16 - ay };
+}
+function devicePositiveBox(box) {
+  if (!isAxisBox(box) || box.exx >= 0 && box.eyy >= 0) {
+    return box;
+  }
+  const ax = box.exx < 0 ? box.ax + box.exx : box.ax;
+  const ay = box.eyy < 0 ? box.ay + box.eyy : box.ay;
+  return { ...box, ax, ay, exx: Math.abs(box.exx), eyy: Math.abs(box.eyy) };
+}
 function handleRectangle(rCtx, dataOff, recSize) {
   const { ctx, view, state, inPath } = rCtx;
   if (recSize >= 24) {
@@ -32212,7 +33296,7 @@ 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 unframed = uprightFixBox(rCtx, l, t, r, b);
+    const unframed = cosmeticRectangleBox(rCtx, uprightFixBox(rCtx, l, t, r, b));
     const inset = insideFrameInset(rCtx, unframed, true, rCtx.state.arcDirection === 2);
     const box = inset ? insetFixBox(unframed, inset) : unframed;
     const clockwise = rCtx.state.arcDirection === 2;
@@ -32267,7 +33351,7 @@ function handleRectangle(rCtx, dataOff, recSize) {
           c.beginPath();
           c.rect(x, y, w, h);
         },
-        raster: () => rectRasterPath(box, clockwise),
+        raster: () => rectRasterPath(devicePositiveBox(box), clockwise),
         rectangle: true,
         fill: true,
         stroke: true,
@@ -32377,7 +33461,7 @@ function handleRoundRect(rCtx, dataOff, recSize) {
     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 cornerOnFrame = (fix2, size, framedSize) => inset && size !== 0 ? Math.floor(Math.min(fix2, size) * framedSize / size) : fix2;
     let cw = cornerOnFrame(cornerFixW, Math.abs((r - l) * devM[0]) * 16, Math.abs(framed.exx));
     let ch = cornerOnFrame(cornerFixH, Math.abs((b - t) * devM[3]) * 16, Math.abs(framed.eyy));
     const drawBox = inset ? framed : curvedFixBox(rCtx, l, t, r, b, true);
@@ -32441,18 +33525,21 @@ function curvedFixBox(rCtx, l, t, r, b, upright = false) {
     return box;
   }
   const m = gdiDeviceMatrix(rCtx);
-  if (Math.abs(m[0]) !== 1 || Math.abs(m[3]) !== 1 || m[1] !== 0 || m[2] !== 0) {
+  if (m[1] !== 0 || m[2] !== 0) {
     return box;
   }
+  const whole = box.ax % 16 === 0 && box.ay % 16 === 0 && box.exx % 16 === 0 && box.eyy % 16 === 0;
+  const gx = whole ? 4 : 0;
+  const gy = gx;
   const sx = box.exx < 0 ? -1 : 1;
   const sy = box.eyy < 0 ? -1 : 1;
   return {
-    ax: box.ax - 4 * sx,
-    ay: box.ay - 4 * sy,
-    exx: box.exx + 8 * sx,
+    ax: box.ax - gx * sx,
+    ay: box.ay - gy * sy,
+    exx: box.exx + 2 * gx * sx,
     exy: 0,
     eyx: 0,
-    eyy: box.eyy + 8 * sy
+    eyy: box.eyy + 2 * gy * sy
   };
 }
 function handleEllipse(rCtx, dataOff, recSize) {
@@ -32548,34 +33635,41 @@ function handleArcFamily(rCtx, recType, dataOff, recSize) {
       }
     };
     const kind = isArcTo ? "arcto" : recType === EMR_PIE ? "pie" : recType === EMR_CHORD ? "chord" : "arc";
+    const radialOnBox = (box, x, y) => {
+      const wl = r - l;
+      const hl = b - t;
+      if (wl === 0 || hl === 0) {
+        return fixPoint(rCtx, x, y);
+      }
+      const u = (x - l) / wl;
+      const v = (y - t) / hl;
+      return [box.ax + box.exx * u + box.eyx * v, box.ay + box.exy * u + box.eyy * v];
+    };
     const devM = gdiDeviceMatrix(rCtx);
-    const rawFix = (x, y) => [(devM[0] * x + devM[2] * y + devM[4]) * 16, (devM[1] * x + devM[3] * y + devM[5]) * 16];
-    const radialOnBox = (p, raw) => {
-      if (!inset) {
-        return p;
-      }
-      const [rl, rt] = rawFix(l, t);
-      const [rr, rb] = rawFix(r, b);
-      const kx = rr !== rl ? framed.exx / (rr - rl) : 1;
-      const ky = rb !== rt ? framed.eyy / (rb - rt) : 1;
-      const snap = (v) => Math.abs(v) < 1e-6 ? 0 : v;
-      return [framed.ax + framed.exx / 2 + snap(raw[0] - (rl + rr) / 2) * kx, framed.ay + framed.eyy / 2 + snap(raw[1] - (rt + rb) / 2) * ky];
+    const mapFlips = devM[0] * devM[3] - devM[1] * devM[2] < 0;
+    const axisMap2 = devM[1] === 0 && devM[2] === 0;
+    const rasterArgs = (immediate = false) => {
+      const box = inset ? framed : immediate && needsFill ? curvedFixBox(rCtx, l, t, r, b) : unframed;
+      const boxFlips = box.exx * box.eyy - box.exy * box.eyx < 0;
+      const mirror2 = axisMap2 && isAxisBox(box) ? { x: devM[0] < 0, y: devM[3] < 0 } : void 0;
+      return {
+        box,
+        mirror: mirror2,
+        clockwise: mirror2 ? clockwise : clockwise !== (mapFlips !== boxFlips),
+        s: radialOnBox(box, startX, startY),
+        // Device FIX rounding can separate distinct radial points on the
+        // same logical ray. Preserve their proven endpoint identity.
+        e: fullEllipse ? radialOnBox(box, startX, startY) : radialOnBox(box, endX, endY),
+        from: currentFix(rCtx)
+      };
     };
-    const rasterArgs = (immediate = false) => ({
-      box: inset ? framed : immediate && needsFill ? curvedFixBox(rCtx, l, t, r, b) : unframed,
-      s: radialOnBox(fixPoint(rCtx, startX, startY), rawFix(startX, startY)),
-      // Device FIX rounding can separate distinct radial points on the
-      // same logical ray. Preserve their proven endpoint identity.
-      e: fullEllipse ? radialOnBox(fixPoint(rCtx, startX, startY), rawFix(startX, startY)) : radialOnBox(fixPoint(rCtx, endX, endY), rawFix(endX, endY)),
-      from: currentFix(rCtx)
-    });
     if (inPath) {
       if (isArcTo) {
         continueFigure(rCtx);
       }
       build(gdiPathRecorder(rCtx));
       const a = rasterArgs();
-      arcRasterPath(a.box, a.s, a.e, clockwise, kind, a.from, rasterPathOf(rCtx));
+      arcRasterPath(a.box, a.s, a.e, a.clockwise, kind, a.from, rasterPathOf(rCtx), a.mirror);
       if (needsFill) {
         rasterPathOf(rCtx).closeFigure();
       }
@@ -32589,7 +33683,7 @@ function handleArcFamily(rCtx, recType, dataOff, recSize) {
         },
         raster: () => {
           const a = rasterArgs(true);
-          return arcRasterPath(a.box, a.s, a.e, clockwise, kind, a.from).path;
+          return arcRasterPath(a.box, a.s, a.e, a.clockwise, kind, a.from, void 0, a.mirror).path;
         },
         fill: needsFill,
         stroke: true
@@ -32597,7 +33691,7 @@ function handleArcFamily(rCtx, recType, dataOff, recSize) {
     }
     if (isArcTo) {
       const a = rasterArgs();
-      const end = arcRasterPath(a.box, a.s, a.e, clockwise, "arc").end;
+      const end = arcRasterPath(a.box, a.s, a.e, a.clockwise, "arc", void 0, void 0, a.mirror).end;
       const dx = Math.floor(end[0] / 16);
       const dy = Math.floor(end[1] / 16);
       const inv2 = invertAffine(gdiDeviceMatrix(rCtx));
@@ -32719,6 +33813,21 @@ function handleEmfGdiShapeRecord(rCtx, recType, dataOff, recSize) {
   }
 }
 
+// src/emf-gdi-chroma-tie-data.ts
+var CHROMA_TIE_FLIPS = {
+  "40,0": [374, 506, 1076, 1078, 1142, 1526, 1910, 2294, 2678, 3446, 5750, 5806, 5818, 5830, 5842, 5854, 5866, 5902, 5938, 6324, 7256, 7484, 7868, 8636, 8792, 8996, 9020, 9404, 9788, 10556, 11904, 12112, 12136, 12160, 12172, 12184, 12208, 12220, 12244, 12256, 12268, 12666, 13190, 13598, 15338, 18246, 18540, 18750, 19940, 21272, 21476, 21680, 21759, 21884, 24100, 24882, 27364, 27614, 28022, 30442, 30534, 30900, 31062, 32478, 32482, 33673, 36394, 36984, 37242, 37404, 40380, 41256, 41541, 42688, 42736, 42784, 43188, 46651, 48193, 49126, 49530, 49668, 50268, 53877, 54849, 55404, 55476, 58319, 61818, 62257, 66538, 67026, 67236, 67398, 67716, 69373, 71370, 73392, 73872, 77949, 78325, 79054, 80143, 80400, 85086, 85632, 86184, 86370, 86394, 88496, 91974, 98682, 98820, 98868, 99054, 102841, 104262, 104628, 110970, 111628, 115656, 116574, 116916, 119216, 119334, 119968, 123396, 127812, 128579, 129366, 129493, 129738, 134784, 134878, 140880, 142861, 143671, 146590, 147484, 150855, 151211, 153414, 153922, 154543, 155567, 157776, 159826, 160168, 160910, 162313, 165787, 166068, 169642, 171408, 171882, 172510, 174117, 174926, 176025, 176170, 176928, 177636, 177718, 177990, 178356, 181268, 184330, 184354, 184390, 184402, 184414, 184426, 184438, 184462, 184498, 184514, 185282, 185666, 186434, 186818, 188354, 189491, 190278, 190672, 190696, 190732, 190756, 190768, 190804, 190840, 191624, 192776, 193160, 193952, 194615, 194782, 194948, 195080, 195464, 195848, 196010],
+  "40,20": [1345, 13655, 16768, 19051, 22461, 23888, 29071, 34630, 40955, 41856, 43128, 47160, 47377, 47934, 47976, 48106, 48607, 49476, 59008, 59116, 59372, 65851, 69045, 69721, 71741, 74531, 85884, 89225, 89899, 91692, 93843, 94915, 95071, 95968, 97561, 100356, 101005, 102444, 109699, 116446, 117163, 118538, 119501, 133219, 136360, 137042, 137929, 138173, 143164, 145012, 145555, 146068, 156036, 158160, 160630, 161047, 174146, 175587, 176339, 177137],
+  "50,20": [3435, 4690, 7934, 11527, 21838, 22211, 24980, 32745, 35495, 36570, 38851, 41578, 43128, 49195, 57142, 72649, 73084, 81747, 89022, 89826, 93145, 94307, 96679, 99174, 99185, 102486, 103896, 109861, 110110, 112698, 116081, 130842, 133613, 137784, 139643, 142939, 143358, 143734, 143834, 152125, 158072, 170378, 170422, 174146, 175547, 177966, 180424, 182339, 190180, 192424, 196256],
+  "-40,0": [5816, 9911, 17137, 17332, 18078, 19903, 25108, 39517, 46996, 54208, 54890, 55254, 59753, 61616, 73287, 73927, 77843, 90139, 93011, 94263, 96552, 99873, 104370, 115822, 116256, 119156, 122178, 125065, 125455, 127853, 133264, 133614, 136585, 141275, 148914, 149785, 153213, 156483, 167561, 171079, 171826, 183498, 184714, 185541, 186397, 190359, 194533],
+  "100,0": [458, 506, 543, 845, 1142, 1274, 1526, 2294, 5074, 5750, 5782, 5806, 5818, 5830, 5854, 5866, 5902, 5926, 5938, 6800, 7100, 7256, 7484, 7616, 7868, 8384, 8636, 8792, 8996, 9020, 9152, 9404, 10328, 10556, 11324, 11416, 11904, 12092, 12112, 12136, 12160, 12184, 12208, 12244, 12256, 12268, 12546, 13142, 13370, 13502, 13598, 14522, 15338, 16670, 17320, 18246, 19484, 19712, 19940, 20864, 21068, 21272, 21476, 21680, 21884, 23710, 24882, 25615, 25874, 26054, 26282, 27002, 27206, 27614, 28022, 30004, 30442, 30780, 30883, 31062, 31176, 31224, 31434, 33073, 36480, 36984, 37122, 37242, 37404, 37566, 37776, 39326, 39686, 40862, 42346, 42688, 42784, 43746, 43908, 45308, 45543, 45668, 46232, 46959, 48210, 48250, 48322, 48380, 49030, 49078, 49126, 49248, 49530, 49668, 50088, 52485, 54592, 54688, 55030, 55343, 55404, 55476, 55590, 56010, 58009, 59324, 59888, 60522, 60592, 60628, 60894, 60934, 60958, 61372, 61746, 61932, 62118, 62352, 62617, 66410, 66970, 67276, 67324, 67348, 67398, 67716, 67902, 68088, 68274, 68460, 73240, 73340, 73618, 73666, 73690, 73872, 74430, 75097, 77750, 79094, 79618, 79686, 80052, 80400, 80690, 81053, 84630, 85308, 85632, 86184, 86370, 86394, 86742, 86928, 89565, 91974, 92478, 92526, 92898, 93084, 97548, 97782, 98610, 98682, 98820, 98868, 99426, 99612, 100368, 103704, 104124, 104262, 104628, 104952, 105162, 105210, 105396, 105768, 106117, 107011, 110614, 110686, 110712, 110970, 111040, 111294, 111504, 111738, 111924, 112828, 113676, 114388, 115341, 115393, 116574, 116916, 116956, 116992, 117636, 117846, 122298, 122464, 122968, 123266, 123298, 123334, 123650, 123724, 123978, 124188, 125029, 125924, 128054, 128514, 129238, 129262, 129286, 129310, 129366, 129640, 129712, 130196, 134784, 136054, 136080, 136538, 137182, 141253, 141946, 142018, 142292, 142396, 143060, 143828, 145207, 145667, 145693, 146155, 147484, 147922, 148226, 148264, 148288, 148312, 148392, 148634, 148738, 149402, 152235, 153414, 153874, 153922, 154264, 154568, 155106, 155744, 156104, 156308, 156512, 156716, 156858, 158768, 159360, 159826, 160168, 160216, 160264, 160606, 160910, 161020, 162086, 162242, 162398, 162446, 162650, 165540, 166068, 166168, 166558, 167252, 168584, 171720, 171882, 172510, 172948, 174926, 175538, 176306, 177852, 177990, 178356, 181064, 181268, 181676, 181997, 182648, 183008, 183936, 184330, 184354, 184390, 184402, 184414, 184438, 184462, 184514, 185194, 185282, 185632, 185666, 186434, 188354, 189758, 189890, 190278, 190410, 190672, 190684, 190696, 190732, 190768, 190804, 190816, 190840, 191624, 191926, 192776, 193160, 193802, 193952, 195080, 195165, 195332, 195464, 195692, 195848],
+  "-100,0": [8492, 8494, 18577, 69397, 74091, 76386, 76390, 120219, 122518, 127206, 127210, 173433, 182718, 188113, 188115, 188117],
+  "20,0": [374, 758, 1142, 1526, 2294, 2678, 4598, 5782, 5806, 5818, 5830, 5842, 5878, 5926, 5938, 6857, 7100, 7256, 7484, 7868, 8144, 8636, 9020, 9404, 10556, 11324, 11904, 12092, 12112, 12136, 12160, 12184, 12208, 12232, 12244, 12256, 12268, 12408, 15256, 15338, 16012, 19736, 22402, 24192, 24490, 24720, 30900, 31062, 33949, 36540, 37242, 43461, 45209, 45343, 47763, 49530, 50829, 51159, 52932, 54027, 54376, 55056, 55110, 55476, 59280, 59784, 60294, 61056, 61170, 65557, 65771, 67398, 71574, 73872, 78008, 79686, 80052, 83615, 86184, 86370, 88236, 88957, 90159, 90896, 90972, 91188, 92340, 92657, 93560, 94764, 95047, 95257, 95760, 98682, 98796, 102636, 103746, 104262, 104628, 108240, 110418, 110970, 113753, 116916, 121939, 122283, 122285, 123481, 126166, 126786, 127848, 128811, 129546, 133194, 137205, 139249, 140100, 140104, 143450, 143585, 144257, 148826, 153414, 157182, 159486, 160495, 160975, 161749, 164341, 166068, 166168, 168189, 169944, 171030, 171630, 173895, 175302, 175860, 176838, 178356, 184104, 184330, 184342, 184354, 184366, 184390, 184402, 184414, 184426, 184438, 184462, 184474, 184486, 184514, 185282, 185666, 185765, 187202, 188354, 188776, 190038, 190672, 190696, 190732, 190768, 190792, 190804, 190816, 190840, 191302, 191624, 192392, 192776, 193160, 194369, 194696, 195003, 195464, 195848],
+  "70,0": [254, 458, 1142, 1274, 1526, 2246, 2294, 2348, 2450, 2654, 2858, 3062, 4598, 5750, 5782, 5806, 5830, 5842, 5854, 5866, 5902, 5926, 5938, 6300, 7100, 7256, 7484, 7616, 7868, 8384, 8636, 8792, 8996, 9020, 9404, 9470, 9497, 9788, 10328, 10556, 11021, 11324, 11416, 11904, 12092, 12112, 12136, 12184, 12244, 12256, 12268, 12546, 13370, 13598, 15134, 15338, 16670, 18540, 19532, 19712, 19940, 21068, 21272, 21476, 21884, 24192, 24720, 24841, 26282, 27410, 27614, 28180, 29026, 30004, 30442, 30534, 30900, 31062, 31224, 31434, 34160, 35373, 36480, 36984, 37242, 37404, 37566, 39890, 42688, 42784, 46640, 48380, 49030, 49078, 49126, 49248, 49530, 49668, 50088, 50659, 54592, 54664, 54688, 55476, 55590, 56010, 60766, 60958, 60982, 61372, 61560, 61746, 61932, 62617, 65226, 67348, 67398, 67716, 68088, 68274, 69492, 69557, 70194, 73107, 73578, 73714, 74244, 75841, 76888, 79686, 80400, 83650, 84127, 84200, 86184, 86370, 86394, 86742, 86845, 86928, 88496, 90155, 90522, 90549, 91974, 92478, 92526, 92898, 93084, 94736, 95937, 96873, 97782, 98682, 98820, 98868, 103659, 104262, 104628, 104952, 105162, 105210, 105396, 107075, 108234, 110686, 110712, 110970, 111294, 111504, 111628, 111738, 116332, 116574, 116916, 116992, 117636, 121933, 122621, 122968, 123024, 123334, 123396, 127016, 127044, 129262, 129286, 129310, 129366, 129712, 134394, 134784, 136054, 136080, 140378, 142018, 142292, 144762, 145335, 145710, 147484, 147922, 148226, 148312, 148392, 150262, 153414, 153874, 153922, 154568, 155744, 159360, 159826, 160168, 160216, 160264, 160606, 160910, 161076, 162242, 162446, 162650, 163690, 164494, 166068, 166168, 166558, 166606, 167252, 167848, 168584, 170886, 171648, 171882, 172510, 172948, 174722, 174926, 176306, 177852, 177990, 178356, 181064, 181268, 183008, 184330, 184354, 184390, 184402, 184414, 184426, 184438, 184462, 184498, 184514, 185194, 185282, 185632, 185666, 185714, 186434, 187202, 189033, 189051, 189758, 189890, 190278, 190672, 190696, 190732, 190792, 190804, 190816, 190840, 191624, 192776, 193160, 193952, 195464, 195563, 195692, 195848],
+  "0,30": [1721, 4912, 17621, 23134, 24625, 24929, 33960, 36358, 38321, 38379, 40933, 42823, 43299, 45130, 45943, 49299, 52890, 53885, 57288, 57436, 59699, 61699, 64420, 65176, 65236, 72099, 72211, 72381, 83500, 85501, 88189, 89169, 92103, 93701, 95610, 95681, 108288, 108606, 114622, 117231, 119626, 123617, 127534, 133819, 136508, 136984, 139544, 143792, 145778, 147469, 149239, 153446, 153562, 154152, 159126, 166024, 175800, 176759, 180377, 181528, 182453, 183108, 192812],
+  "0,-50": [1993, 2566, 7118, 7355, 11339, 12468, 15355, 19766, 19939, 26761, 31589, 32405, 35291, 38652, 41997, 50880, 52335, 53022, 53093, 55240, 72257, 72491, 75259, 75267, 80408, 83070, 83658, 83938, 85802, 86633, 90942, 99179, 101706, 102357, 106183, 108569, 117985, 120676, 140059, 141222, 143338, 147505, 147553, 150898, 152640, 156175, 156373, 156839, 158346, 159040, 163988, 171036, 176002, 179175, 179438, 192876, 194345, 194768, 194848],
+  "0,60": [2079, 10520, 24043, 34818, 38212, 39257, 41632, 41905, 48383, 50923, 58894, 59675, 61206, 64816, 65028, 66919, 71898, 77171, 77667, 82511, 82591, 90280, 94741, 98446, 99892, 99982, 103615, 105816, 111088, 115141, 115170, 126478, 127086, 129937, 130463, 131475, 133798, 134795, 134807, 136638, 138053, 139328, 140657, 143569, 145200, 146837, 147691, 147766, 149712, 151474, 168315, 171698, 173961, 177231, 182638, 184786, 185640, 188116, 192273, 196154]
+};
+
 // src/emf-gdi-illuminant-data.ts
 var ILLUMINANT_CUBE_DATA = {
   1: "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",
@@ -32900,7 +34009,33 @@ function adjustChroma(r, g, b, scale, angle) {
   }
   return out;
 }
-function colorAdjustmentMapper(ca) {
+var chromaTieTables = /* @__PURE__ */ new Map();
+function chromaTieTable(ca) {
+  if (ca.illuminant !== 0 && ca.illuminant !== 6) return null;
+  const key = `${ca.colorfulness},${ca.redGreenTint}`;
+  let table2 = chromaTieTables.get(key);
+  if (table2 === void 0) {
+    const flips = CHROMA_TIE_FLIPS[key];
+    table2 = null;
+    if (flips) {
+      table2 = new Int8Array(32768 * 3);
+      for (const f of flips) table2[f >> 1] = f & 1 ? 1 : -1;
+    }
+    chromaTieTables.set(key, table2);
+  }
+  return table2;
+}
+function paletteEntry(v) {
+  const n = Math.round(v * 31 / 255);
+  return PALETTE[n] === v ? n : -1;
+}
+function tieIndex(c) {
+  const r = paletteEntry(c[0]);
+  const g = paletteEntry(c[1]);
+  const b = paletteEntry(c[2]);
+  return r < 0 || g < 0 || b < 0 ? -1 : (r * 32 + g) * 32 + b;
+}
+function colorAdjustmentMapper(ca, options2) {
   const illuminant = illuminantCube(ca.illuminant);
   const matrix = ILLUMINANT_MATRICES[ca.illuminant];
   const gammas = [ca.redGamma / 1e4, ca.greenGamma / 1e4, ca.blueGamma / 1e4];
@@ -32913,6 +34048,7 @@ function colorAdjustmentMapper(ca) {
   const angle = TINT_RADIANS * ca.redGreenTint / 100;
   const log = (ca.flags & CA_LOG_FILTER) !== 0;
   const negative = (ca.flags & CA_NEGATIVE) !== 0;
+  const ties = chroma && options2?.chromaTies !== false ? chromaTieTable(ca) : null;
   const curve = (value, channel) => {
     let v = 255 * (clamp255(value) / 255) ** gammas[channel];
     v = (v - black) / span * 255;
@@ -32932,6 +34068,7 @@ function colorAdjustmentMapper(ca) {
   return (rgb2) => {
     let c = [rgb2 >> 16 & 255, rgb2 >> 8 & 255, rgb2 & 255];
     if (chroma) {
+      const tie = ties ? tieIndex(c) : -1;
       c = c.map(exactPaletteLevel);
       if (matrix) {
         const [r, g, b] = c;
@@ -32939,6 +34076,7 @@ function colorAdjustmentMapper(ca) {
       }
       c = adjustChroma(c[0], c[1], c[2], scale, angle);
       c = c.map(roundHalfUp);
+      if (ties && tie >= 0) c = c.map((v, k) => v + ties[tie * 3 + k]);
     } else if (illuminant) {
       const mapped = lookupIlluminant(illuminant, c[0] / 255, c[1] / 255, c[2] / 255);
       c = [mapped[0] * 255, mapped[1] * 255, mapped[2] * 255];
@@ -33022,6 +34160,50 @@ function ditherQuantize(v, threshold) {
   return paletteLevel(n < 0 ? 0 : n > 31 ? 31 : n);
 }
 
+// src/emf-gdi-halftone-branch.ts
+function halftoneColorKey(r, g, b) {
+  return b === r ? 16777216 | b >> 2 << 8 | g >> 2 : b | g << 8 | r << 16;
+}
+function halftoneBranch(rgb2, w, h) {
+  if (w <= 0 || h <= 0) return "replicate";
+  const n = w * h;
+  if (n <= 2304) return "replicate";
+  const keyAt = (i) => halftoneColorKey(rgb2[i * 3], rgb2[i * 3 + 1], rgb2[i * 3 + 2]);
+  const seen = /* @__PURE__ */ new Set();
+  if (n > 16384) {
+    for (let y = 0; y < h; y += 6) {
+      for (let x = 0; x < w; x++) seen.add(keyAt(y * w + x));
+      if (seen.size >= 20) return "filter";
+    }
+    return "replicate";
+  }
+  const rows = Math.floor(2304 / w) + 1;
+  if (h < rows) return "replicate";
+  const exact = h === rows;
+  const limit = exact ? 289 + Math.floor((rows * w - 2304) / 8) : 145 + Math.floor((rows * w - 2304) / 16);
+  let colors = 0;
+  let duplicateRows = 0;
+  let coloredPixels = 0;
+  let gaveUp = false;
+  for (let y = 0; y < h; y++) {
+    let added = 0;
+    for (let x = 0; x < w; x++) {
+      const key = keyAt(y * w + x);
+      if (!seen.has(key)) {
+        seen.add(key);
+        added++;
+      }
+    }
+    colors += added;
+    if (!gaveUp && colors >= limit) return "filter";
+    if (added === 0) duplicateRows++;
+    else coloredPixels += w;
+    if (colors >= 20 && coloredPixels > 2304 && !(exact && gaveUp)) return "filter";
+    if (exact ? colors + duplicateRows * w >= limit - 1 : colors + (duplicateRows + 1) * w >= n - 2305 + limit) gaveUp = true;
+  }
+  return "replicate";
+}
+
 // src/emf-gdi-stretch.ts
 var BLACKONWHITE = 1;
 var WHITEONBLACK = 2;
@@ -33154,119 +34336,24 @@ function halftoneReduceTaps(srcLen, dstLen, reverse) {
   if (reverse) taps.reverse();
   return taps;
 }
-var ENLARGE_INNER = [
-  1e3,
-  992.47,
-  984.9399,
-  977.4099,
-  969.8798,
-  962.3498,
-  954.8198,
-  947.2897,
-  939.7597,
-  932.2296,
-  924.6996,
-  917.1695,
-  909.6395,
-  902.1095,
-  894.5665,
-  886.8087,
-  879.045,
-  871.2813,
-  863.4349,
-  855.5885,
-  847.7421,
-  839.8269,
-  831.9046,
-  823.912,
-  815.9193,
-  807.9266,
-  799.847,
-  791.7283,
-  783.6096,
-  775.449,
-  767.3204,
-  758.9233,
-  750.5263,
-  742.4271,
-  734.0547,
-  725.6823,
-  717.232,
-  708.7675,
-  700.2393,
-  691.7111,
-  683.0734,
-  674.4357,
-  665.7105,
-  656.9854,
-  648.2603,
-  639.3747,
-  630.4873,
-  621.5157,
-  612.5442
-];
-var ENLARGE_OUTER = [
-  375.1388,
-  364.2093,
-  353.2797,
-  342.4714,
-  331.7615,
-  321.1462,
-  310.6456,
-  300.2252,
-  289.9229,
-  279.7227,
-  269.6439,
-  259.6535,
-  249.7825,
-  240.0362,
-  230.3856,
-  220.8799,
-  211.4594,
-  202.1844,
-  192.9996,
-  183.9679,
-  175.1064,
-  166.2864,
-  157.6436,
-  149.1447,
-  140.7609,
-  132.5474,
-  124.4802,
-  116.5636,
-  108.778,
-  101.1602,
-  93.7098,
-  86.4419,
-  79.3251,
-  72.4091,
-  65.6853,
-  59.1472,
-  52.812,
-  46.6978,
-  40.8001,
-  35.1449,
-  29.7494,
-  24.6096,
-  19.7977,
-  15.2801,
-  11.1442,
-  7.3916,
-  4.1415,
-  1.4039,
-  0
-];
-var ENLARGE_HALF = 500.0106;
-var ENLARGE_KNOTS = 96;
 function enlargeKernel(u) {
   if (u >= 1) return 0;
-  if (Math.abs(u - 0.5) < 1e-9) return ENLARGE_HALF;
-  const table2 = u < 0.5 ? ENLARGE_INNER : ENLARGE_OUTER;
-  const edge = u * ENLARGE_KNOTS - (u < 0.5 ? 0 : ENLARGE_KNOTS / 2);
-  const i = Math.min(table2.length - 2, Math.floor(edge + 1e-9));
-  return table2[i] + (table2[i + 1] - table2[i]) * (edge - i);
+  const x = 1 - u;
+  if (Math.abs(u - 0.5) < 1e-9) return x;
+  return Math.pow(x, u < 0.5 ? Math.SQRT1_2 : Math.SQRT2);
 }
 function halftoneEnlargeTaps(src, dst) {
+  return halftoneEnlargeCumulative(src, dst).map((row2) => {
+    let prev = 0;
+    return row2.map(([j, cum], i) => {
+      const c = i === row2.length - 1 ? 8192 : Math.ceil(cum - 1e-7);
+      const share = c - prev;
+      prev = c;
+      return [j, share / 8192];
+    });
+  });
+}
+function halftoneEnlargeCumulative(src, dst) {
   const ratio = dst / src;
   const reach = Math.ceil(ratio) - 1;
   const fir = [];
@@ -33287,7 +34374,7 @@ function halftoneEnlargeTaps(src, dst) {
     }
     cover.push(run);
   }
-  const taps = [];
+  const rows = [];
   for (let x = 0; x < dst; x++) {
     const weights = /* @__PURE__ */ new Map();
     for (let k = -reach; k <= reach; k++) {
@@ -33298,18 +34385,13 @@ function halftoneEnlargeTaps(src, dst) {
       }
     }
     const sorted = [...weights.entries()].sort((a, b) => a[0] - b[0]);
-    let prev = 0;
     let cum = 0;
-    const row2 = [];
-    for (let i = 0; i < sorted.length; i++) {
-      cum += sorted[i][1] * 8192;
-      const c = i === sorted.length - 1 ? 8192 : Math.ceil(cum - 1e-7);
-      row2.push([sorted[i][0], (c - prev) / 8192]);
-      prev = c;
-    }
-    taps.push(row2);
+    rows.push(sorted.map(([j, v]) => {
+      cum += v * 8192;
+      return [j, cum];
+    }));
   }
-  return taps;
+  return rows;
 }
 function ditherPixels(px, w, h, dither, flipX, flipY, phaseX, phaseY) {
   for (let y = 0; y < h; y++) {
@@ -33386,6 +34468,20 @@ function halftoneDespeckle(px, w, h) {
     }
   }
 }
+function halftoneSharpen(px, w, h) {
+  const src = px.slice();
+  const at = (x, y, c) => src[(Math.max(0, Math.min(h - 1, y)) * w + Math.max(0, Math.min(w - 1, x))) * 3 + c];
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      for (let c = 0; c < 3; c++) {
+        const v = at(x, y, c);
+        const sum = at(x - 1, y, c) + at(x + 1, y, c) + at(x, y - 1, c) + at(x, y + 1, c);
+        const out = v + Math.floor((4 * v - sum) / 8);
+        px[(y * w + x) * 3 + c] = out < 0 ? 0 : out > 255 ? 255 : out;
+      }
+    }
+  }
+}
 function halftonePairDespeckle(px, w, h, rows) {
   const n = rows ? w : h;
   const at = (k, side) => (rows ? side * w + k : k * w + side) * 3;
@@ -33448,6 +34544,239 @@ function halftoneReduceBoth(rect, sw, sh, dw, dh, flipX, flipY) {
   }
   return out;
 }
+function halftoneReduceOneAxis(rect, sw, sh, dw, dh, flipX, flipY) {
+  const vertical = dh < sh;
+  const taps = vertical ? halftoneReduceTaps(sh, dh, flipY) : halftoneReduceTaps(sw, dw, flipX);
+  const reduced = new Float64Array(dw * dh * 3);
+  for (let y = 0; y < dh; y++) {
+    for (let x = 0; x < dw; x++) {
+      const run = vertical ? taps[y] : taps[x];
+      const keep = vertical ? flipX ? dw - 1 - x : x : flipY ? dh - 1 - y : y;
+      let total = 0;
+      for (const [, w] of run) total += w;
+      for (let c = 0; c < 3; c++) {
+        let sum = 0;
+        for (const [k, w] of run) sum += rect[((vertical ? k : keep) * sw + (vertical ? keep : k)) * 3 + c] * w;
+        reduced[(y * dw + x) * 3 + c] = sum / total;
+      }
+    }
+  }
+  const out = new Int32Array(dw * dh * 3);
+  const at = (x, y, c) => reduced[(Math.max(0, Math.min(dh - 1, y)) * dw + Math.max(0, Math.min(dw - 1, x))) * 3 + c];
+  for (let y = 0; y < dh; y++) {
+    for (let x = 0; x < dw; x++) {
+      for (let c = 0; c < 3; c++) {
+        const v = at(x, y, c);
+        const sum = vertical ? at(x, y - 1, c) + at(x, y + 1, c) : at(x - 1, y, c) + at(x + 1, y, c);
+        out[(y * dw + x) * 3 + c] = Math.max(0, Math.min(255, Math.floor(v + (2 * v - sum) / 4)));
+      }
+    }
+  }
+  return out;
+}
+var FILTER_WEIGHTS = {
+  1: [[5, 22, 5, 32]],
+  2: [[4, 12, 0, 16], [0, 12, 4, 16]],
+  3: [[6, 10, 0, 16], [1, 14, 1, 16], [0, 10, 6, 16]],
+  4: [[6, 10, 0, 16], [3, 12, 1, 16], [1, 12, 3, 16], [0, 10, 6, 16]],
+  5: [[13, 19, 0, 32], [6, 25, 1, 32], [3, 26, 3, 32], [1, 25, 6, 32], [0, 19, 13, 32]]
+};
+function filterAxisTaps(src, dst) {
+  const factor = dst / src;
+  if (factor === 2) {
+    const rows = FILTER_WEIGHTS[2].map(([a, b, c]) => [a * 512, b * 512, c * 512]);
+    return Array.from({ length: dst }, (_, i) => {
+      const k = Math.floor(i / 2);
+      const [a, b, c] = rows[i % 2];
+      return [[Math.max(0, k - 1), a], [k, b], [Math.min(src - 1, k + 1), c]];
+    });
+  }
+  return halftoneEnlargeTaps(src, dst).map((row2) => row2.map(([j, v]) => [j, Math.round(v * 8192)]));
+}
+function halftoneFilterOneAxis(rgb2, w, h, W, H, below) {
+  const horizontal = W > w;
+  const n = horizontal ? w : h;
+  const sharp = new Int32Array(rgb2.length);
+  const at = (x, y, c) => y >= h && below ? below[Math.max(0, Math.min(w - 1, x)) * 3 + c] : rgb2[(Math.max(0, Math.min(h - 1, y)) * w + Math.max(0, Math.min(w - 1, x))) * 3 + c];
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      for (let c = 0; c < 3; c++) {
+        const v = at(x, y, c);
+        const sum = horizontal ? at(x - 1, y, c) + at(x + 1, y, c) : at(x, y - 1, c) + at(x, y + 1, c);
+        const out2 = v + Math.floor((2 * v - sum) / 4);
+        sharp[(y * w + x) * 3 + c] = out2 < 0 ? 0 : out2 > 255 ? 255 : out2;
+      }
+    }
+  }
+  const taps = filterAxisTaps(n, horizontal ? W : H);
+  const out = new Int32Array(W * H * 3);
+  for (let y = 0; y < H; y++) {
+    for (let x = 0; x < W; x++) {
+      for (let c = 0; c < 3; c++) {
+        let sum = 0;
+        if (horizontal) for (const [j, weight] of taps[x]) sum += weight * sharp[(y * w + j) * 3 + c];
+        else for (const [j, weight] of taps[y]) sum += weight * sharp[(j * w + x) * 3 + c];
+        out[(y * W + x) * 3 + c] = Math.floor((sum + 4096) / 8192);
+      }
+    }
+  }
+  return out;
+}
+function filterRuns(src, dst) {
+  const k = Array.from({ length: dst }, (_, i) => halftoneNearest(i, src, dst));
+  const length = /* @__PURE__ */ new Map();
+  for (const v of k) length.set(v, (length.get(v) ?? 0) + 1);
+  const placed = /* @__PURE__ */ new Map();
+  return k.map((v) => {
+    const p = placed.get(v) ?? 0;
+    placed.set(v, p + 1);
+    return { k: v, weights: FILTER_WEIGHTS[length.get(v)][p] };
+  });
+}
+function halftoneFilterSupported(w, h, W, H) {
+  return w > 0 && h > 0 && W >= w && H >= h && (W > w || H > h);
+}
+function ditherFilteredSource(rect, SW, SH, W, H, dither, flipY) {
+  if (W > 5 * SW || H > 5 * SH) {
+    const further = new Int32Array((SH + 1) * SW * 3);
+    further.set(rect);
+    further.set(rect.subarray((SH - 1) * SW * 3), SH * SW * 3);
+    ditherPixels(
+      further,
+      SW,
+      SH + 1,
+      dither,
+      false,
+      false,
+      void 0,
+      Int32Array.from({ length: SH + 1 }, (_, j) => flipY ? H - 1 - j : j)
+    );
+    return further;
+  }
+  const extended = new Int32Array((SH + 4) * SW * 3);
+  extended.set(rect.subarray(0, SW * 3), 0);
+  extended.set(rect.subarray(0, SW * 3), SW * 3);
+  extended.set(rect, 2 * SW * 3);
+  extended.set(rect.subarray((SH - 1) * SW * 3), (SH + 2) * SW * 3);
+  extended.set(rect.subarray((SH - 1) * SW * 3), (SH + 3) * SW * 3);
+  ditherPixels(
+    extended,
+    SW,
+    SH + 4,
+    { startX: dither.startX, startY: (dither.startY + (flipY ? 63 : 2)) % 65 },
+    false,
+    false,
+    void 0,
+    Int32Array.from({ length: SH + 4 }, (_, e) => flipY ? H - e + 1 : e - 2)
+  );
+  return extended;
+}
+function halftoneFilterEnlarge(rgb2, w, h, W, H, extended) {
+  if (W === w || H === h) return halftoneFilterOneAxis(rgb2, w, h, W, H, extended && extended.length === (h + 1) * w * 3 ? extended.subarray(h * w * 3) : void 0);
+  const clamp2 = (v) => v < 0 ? 0 : v > 255 ? 255 : v;
+  const general = W > 5 * w || H > 5 * h;
+  const out = new Int32Array(W * H * 3);
+  if (general) {
+    const sharp2 = rgb2.slice();
+    if (extended) {
+      const at2 = (x, y, c) => extended[(Math.max(0, Math.min(h, y)) * w + Math.max(0, Math.min(w - 1, x))) * 3 + c];
+      for (let y = 0; y < h; y++) {
+        for (let x = 0; x < w; x++) {
+          for (let c = 0; c < 3; c++) {
+            const v = at2(x, y, c);
+            const sum = at2(x - 1, y, c) + at2(x + 1, y, c) + at2(x, y - 1, c) + at2(x, y + 1, c);
+            sharp2[(y * w + x) * 3 + c] = clamp2(v + Math.floor((4 * v - sum) / 8));
+          }
+        }
+      }
+    } else {
+      halftoneSharpen(sharp2, w, h);
+    }
+    const xt = filterAxisTaps(w, W);
+    const yt = filterAxisTaps(h, H);
+    const middle2 = new Int32Array(W * h * 3);
+    for (let y = 0; y < h; y++) {
+      for (let x = 0; x < W; x++) {
+        for (let c = 0; c < 3; c++) {
+          let sum = 0;
+          for (const [j, weight] of xt[x]) sum += weight * sharp2[(y * w + j) * 3 + c];
+          middle2[(y * W + x) * 3 + c] = Math.floor((sum + 4096) / 8192);
+        }
+      }
+    }
+    for (let y = 0; y < H; y++) {
+      for (let x = 0; x < W; x++) {
+        for (let c = 0; c < 3; c++) {
+          let sum = 0;
+          for (const [j, weight] of yt[y]) sum += weight * middle2[(j * W + x) * 3 + c];
+          out[(y * W + x) * 3 + c] = clamp2(Math.floor((sum + 4096) / 8192));
+        }
+      }
+    }
+    return out;
+  }
+  const rows = h + 2;
+  const sharp = new Int32Array(w * rows * 3);
+  let padded;
+  if (extended && extended.length === (h + 4) * w * 3) padded = extended;
+  else {
+    padded = new Int32Array(w * (h + 4) * 3);
+    if (extended && extended.length === rows * w * 3) {
+      padded.set(extended.subarray(w * 3, 2 * w * 3), 0);
+      padded.set(extended, w * 3);
+      padded.set(extended.subarray(h * w * 3, (h + 1) * w * 3), (h + 3) * w * 3);
+    } else {
+      padded.set(rgb2.subarray(0, w * 3), 0);
+      padded.set(rgb2.subarray(0, w * 3), w * 3);
+      padded.set(rgb2, 2 * w * 3);
+      padded.set(rgb2.subarray((h - 1) * w * 3), (h + 2) * w * 3);
+      padded.set(rgb2.subarray((h - 1) * w * 3), (h + 3) * w * 3);
+    }
+  }
+  const source = padded;
+  const at = (x, y, c) => source[((y + 1) * w + Math.max(0, Math.min(w - 1, x))) * 3 + c];
+  for (let y = 0; y < rows; y++) {
+    for (let x = 0; x < w; x++) {
+      for (let c = 0; c < 3; c++) {
+        const v = at(x, y, c);
+        const sum = at(x - 1, y, c) + at(x + 1, y, c) + at(x, y - 1, c) + at(x, y + 1, c);
+        sharp[(y * w + x) * 3 + c] = clamp2(v + Math.floor((4 * v - sum) / 8));
+      }
+    }
+  }
+  const xr = filterRuns(w, W);
+  const yr = filterRuns(h, H);
+  const middle = new Int32Array(w * 3);
+  for (let y = 0; y < H; y++) {
+    const near = yr[y].k + 1;
+    const [a, b, c, total] = yr[y].weights;
+    const before = (near - 1) * w * 3;
+    const here = near * w * 3;
+    const after = (near + 1) * w * 3;
+    for (let i = 0; i < w * 3; i++) {
+      middle[i] = Math.floor((a * sharp[before + i] + b * sharp[here + i] + c * sharp[after + i] + total / 2) / total);
+    }
+    for (let x = 0; x < W; x++) {
+      const k = xr[x].k;
+      const [a2, b2, c2, total2] = xr[x].weights;
+      const left = Math.max(0, k - 1);
+      const right = Math.min(w - 1, k + 1);
+      for (let c3 = 0; c3 < 3; c3++) {
+        out[(y * W + x) * 3 + c3] = Math.floor((a2 * middle[left * 3 + c3] + b2 * middle[k * 3 + c3] + c2 * middle[right * 3 + c3] + total2 / 2) / total2);
+      }
+    }
+  }
+  return out;
+}
+function halftoneMixedEngine(rect, SW, SH, W, H) {
+  const halved = W > SW && H * 2 <= SH || H > SH && W * 2 <= SW;
+  const cap = H < SH && 3 * H + 2 <= 2 * SH || W < SW && 3 * W + 2 <= 2 * SW;
+  if (halved || cap) return "reduced";
+  const small = SW * SH <= 2304;
+  if (!small && halftoneBranch(rect, SW, SH) === "filter") return "reduced";
+  if (W * H < SW * SH) return small ? "despeckled" : "reduced";
+  return "nearest";
+}
 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)));
@@ -33492,14 +34821,76 @@ function stretchHalftone(src, sx, sy, sw, sh, dw, dh, adjust, adjustAfterSamplin
   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 && !pairRows && !pairColumns) {
+  const mixedPlain = mixed && (!adjust || adjustAfterSampling || dithered);
+  const engine = mixedPlain ? halftoneMixedEngine(rect, SW, SH, W, H) : "nearest";
+  const nearestMixed = mixedPlain && engine === "nearest" && (W < SW && W * 2 > SW || H < SH && H * 2 > SH);
+  const nativeMixed = mixedPlain && engine !== "nearest";
+  const despeckles = SW * SH <= 2304 || SW * SH > 16384;
+  const oneAxisReduce = W < SW && H === SH || H < SH && W === SW;
+  const reduceDespeckle = (reducing || oneAxisReduce) && despeckles && !directDib && !(W < SW && 3 * W + 2 <= 2 * SW) && !(H < SH && 3 * H + 2 <= 2 * SH) && (SW * SH <= 2304 || halftoneBranch(rect, SW, SH) === "replicate");
+  if (oneAxisReduce && (!adjust || adjustAfterSampling || dithered)) {
+    if (reduceDespeckle) halftoneDespeckle(rect, SW, SH);
+    const reduced = halftoneReduceOneAxis(rect, SW, SH, W, H, flipX, flipY);
+    if (dithered) {
+      ditherPixels(reduced, W, H, dither);
+      adjust(reduced);
+      if (curves) curves(reduced);
+    } else if (adjust) adjust(reduced);
+    for (let i = 0, o = 0; i < W * H; i++, o += 3) {
+      data[i * 4] = reduced[o];
+      data[i * 4 + 1] = reduced[o + 1];
+      data[i * 4 + 2] = reduced[o + 2];
+      data[i * 4 + 3] = 255;
+    }
+    return { width: W, height: H, data };
+  }
+  if (enlarging && halftoneFilterSupported(SW, SH, W, H) && (!adjust || adjustAfterSampling || dithered) && halftoneBranch(rect, SW, SH) === "filter") {
+    let extended;
+    let source = rect;
+    if (dithered) {
+      if (W === SW || H === SH) {
+        if (H > SH) {
+          extended = new Int32Array((SH + 1) * SW * 3);
+          extended.set(rect);
+          extended.set(rect.subarray((SH - 1) * SW * 3), SH * SW * 3);
+          ditherPixels(extended, SW, SH + 1, dither, false, false, void 0, Int32Array.from({ length: SH + 1 }, (_, j) => flipY ? H - 1 - j : j));
+          adjust(extended);
+          source = extended.subarray(0, SW * SH * 3);
+        } else {
+          source = rect.slice();
+          ditherPixels(source, SW, SH, dither, false, false, void 0, Int32Array.from({ length: SH }, (_, j) => flipY ? H - 1 - j : j));
+          adjust(source);
+        }
+      } else {
+        extended = ditherFilteredSource(rect, SW, SH, W, H, dither, flipY);
+        adjust(extended);
+      }
+    }
+    const filtered = halftoneFilterEnlarge(source, SW, SH, W, H, extended);
+    if (flipX || flipY) {
+      const mirror2 = filtered.slice();
+      for (let y = 0; y < H; y++) {
+        for (let x = 0; x < W; x++) {
+          const from = ((flipY ? H - 1 - y : y) * W + (flipX ? W - 1 - x : x)) * 3;
+          filtered.set(mirror2.subarray(from, from + 3), (y * W + x) * 3);
+        }
+      }
+    }
+    if (adjust && adjustAfterSampling) adjust(filtered);
+    if (curves && dithered) curves(filtered);
+    for (let i = 0, o = 0; i < W * H; i++, o += 3) {
+      data[i * 4] = filtered[o];
+      data[i * 4 + 1] = filtered[o + 1];
+      data[i * 4 + 2] = filtered[o + 2];
+      data[i * 4 + 3] = 255;
+    }
+    return { width: W, height: H, data };
+  }
+  if (((enlarging || nearestMixed || engine === "despeckled") && despeckles || reducing && reduceDespeckle) && !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);
-  const extendRow = ditherAtSource && nativeMixed && W < SW && H > SH && !flipY;
+  const ditherAtSource = dithered && (W >= SW && H >= SH || nativeMixed && W * H >= SW * SH);
+  const extendRow = ditherAtSource && nativeMixed && W < SW && H > SH;
   if (extendRow) {
     const bigger = new Int32Array((SH + 1) * SW * 3);
     bigger.set(rect);
@@ -33515,7 +34906,7 @@ function stretchHalftone(src, sx, sy, sw, sh, dw, dh, adjust, adjustAfterSamplin
       false,
       false,
       void 0,
-      flipY ? Int32Array.from({ length: SH }, (_, j) => H - 1 - j) : void 0
+      flipY ? Int32Array.from({ length: extendRow ? SH + 1 : SH }, (_, j) => H - 1 - j) : void 0
     );
   }
   if (adjust && !adjustAfterSampling && (!dithered || ditherAtSource)) {
@@ -36620,9 +38011,9 @@ function handlePolyDraw(rCtx, offset, dataOff, recSize, pointSize) {
         ensureOpen();
         const pts = [0, 1, 2].map((k) => readPt(i + k));
         const dev = pts.map(([x, y]) => gmapPoint(rCtx, x, y));
-        const fix = pts.map(([x, y]) => fixPoint(rCtx, x, y));
+        const fix2 = pts.map(([x, y]) => fixPoint(rCtx, x, y));
         canvas?.bezierCurveTo(dev[0].x, dev[0].y, dev[1].x, dev[1].y, dev[2].x, dev[2].y);
-        raster?.bezierTo(fix[0][0], fix[0][1], fix[1][0], fix[1][1], fix[2][0], fix[2][1]);
+        raster?.bezierTo(fix2[0][0], fix2[0][1], fix2[1][0], fix2[1][1], fix2[2][0], fix2[2][1]);
         i += 2;
       } else {
         continue;
@@ -38021,22 +39412,22 @@ function strokeGdiplus(rCtx, pen, nib, sampler, buildPath, device, size, mode, c
     const m = frame2.toDevice;
     return poly.flatMap((p) => [toPlusFix(m[0] * p.x + m[2] * p.y + m[4]), toPlusFix(m[1] * p.x + m[3] * p.y + m[5])]);
   };
-  let fix;
+  let fix2;
   if (hasCustomCap(pen)) {
-    fix = customCapOutline(figures, width, devicePen, pen).map(toFix);
+    fix2 = customCapOutline(figures, width, devicePen, pen).map(toFix);
   } else if (width <= NOMINAL_PEN_MAX && !devicePen.dash && !(((pen.startCap ?? 0) | (pen.endCap ?? 0) | (pen.dashCap ?? 0)) & 240)) {
     return strokeNominal(rCtx, pen, sampler, buildPath, device, size, antialias, closedFigure);
   } else {
-    fix = widenFigures(figures, devicePen).map(toFix);
+    fix2 = widenFigures(figures, devicePen).map(toFix);
   }
-  const box = figuresBox(fix, size);
+  const box = figuresBox(fix2, size);
   if (!box) {
     return true;
   }
   if (box.w * box.h > 16e6) {
     return false;
   }
-  const coverage = rasterizePlusFill(fix, false, antialias, isHalfPixelOffset(rCtx.pixelOffsetMode ?? 0), box);
+  const coverage = rasterizePlusFill(fix2, false, antialias, isHalfPixelOffset(rCtx.pixelOffsetMode ?? 0), box);
   return compositeBrushCoverage(rCtx, sampler, box, coverage, 1, true);
 }
 function strokeNominal(rCtx, pen, sampler, buildPath, device, size, antialias, closedFigure) {
@@ -38171,7 +39562,7 @@ function deviceQuad(wt, s, pts) {
   }
   return out;
 }
-function imageResampleSpec(rCtx, dataOff, isMetafile, toWorld) {
+function imageResampleSpec(rCtx, dataOff, isMetafile, toWorld, points) {
   const { view } = rCtx;
   const kernel = resampleKernelFor(rCtx.interpolationMode ?? 0);
   if (isMetafile || view.getUint32(dataOff + 4, true) !== UNIT_PIXEL2) {
@@ -38192,10 +39583,11 @@ function imageResampleSpec(rCtx, dataOff, isMetafile, toWorld) {
     toDevice: mulMatrix(plusWorldMatrix(rCtx), toWorld(srcX, srcY, srcW, srcH)),
     kernel,
     halfPixelOffset: isHalfPixelOffset(rCtx.pixelOffsetMode ?? 0),
+    ...points ? { pointsForm: true } : {},
     ...imageAttributesWrap(rCtx, view.getUint32(dataOff, true))
   };
 }
-function drawOrDeferImage(rCtx, imgObj, dataOff, dx, dy, dw, dh, toWorld, effect = null) {
+function drawOrDeferImage(rCtx, imgObj, dataOff, dx, dy, dw, dh, toWorld, effect = null, points = false) {
   if (!imgObj.data) {
     return;
   }
@@ -38208,7 +39600,7 @@ function drawOrDeferImage(rCtx, imgObj, dataOff, dx, dy, dw, dh, toWorld, effect
     dh,
     transform: plusWorldMatrix(rCtx),
     isMetafile,
-    resample: imageResampleSpec(rCtx, dataOff, isMetafile, toWorld)
+    resample: imageResampleSpec(rCtx, dataOff, isMetafile, toWorld, points)
   };
   const { view } = rCtx;
   const source = {
@@ -38677,7 +40069,7 @@ function handleEmfPlusTextImageRecord(rCtx, recType, recFlags, dataOff, recDataS
             const c = (p3x - p1x) / sh;
             const d = (p3y - p1y) / sh;
             return [a, b, c, d, p1x - a * sx - c * sy, p1y - b * sx - d * sy];
-          }, effect);
+          }, effect, true);
         } else {
           imgObj && imgObj.kind === "plus-image" && imgObj.data;
         }
@@ -40886,15 +42278,15 @@ function compatBox(p, l, t, r, b, opts = {}) {
   return box;
 }
 function fixBoxOf(box, cornerExact, keepInverted = false) {
-  const fix = keepInverted ? axisBox(box.x0, box.y0, box.x1, box.y1) : axisBox(box.x0, box.y0, Math.max(box.x0, box.x1), Math.max(box.y0, box.y1));
+  const fix2 = keepInverted ? axisBox(box.x0, box.y0, box.x1, box.y1) : axisBox(box.x0, box.y0, Math.max(box.x0, box.x1), Math.max(box.y0, box.y1));
   if (box.halfX) {
-    fix.halfX = true;
-    fix.halfXCompat = true;
+    fix2.halfX = true;
+    fix2.halfXCompat = true;
   }
   if (cornerExact) {
-    fix.cornerExact = cornerExact;
+    fix2.cornerExact = cornerExact;
   }
-  return fix;
+  return fix2;
 }
 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 };