emf-converter 4.13.0 → 4.15.0

package/dist/browser.js

@@ -16513,6 +16513,45 @@ function lerpUniformPathArgb(a, b, t) {
   };
   return (alpha << 24 | ch(16) << 16 | ch(8) << 8 | ch(0)) >>> 0;
 }
+function pathGradientQuantum(boundary, matrix = IDENTITY) {
+  let x0 = Infinity;
+  let y0 = Infinity;
+  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);
+  }
+  const steps = Math.ceil(2 * Math.hypot(x1 - x0, y1 - y0));
+  return Number.isFinite(steps) && steps > 0 ? steps : 0;
+}
+var TIE_EPSILON = 1e-7;
+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;
+  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);
+  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);
+    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 quantisedPosition(pos, quantum) {
+  const scaled2 = pos * quantum;
+  const tie = Math.abs(scaled2 - Math.floor(scaled2) - 0.5) < TIE_EPSILON;
+  return (tie ? scaled2 : Math.floor(scaled2 + 0.5)) / quantum;
+}
 function piecewise2(xs, ys, x) {
   const n = Math.min(xs.length, ys.length);
   if (n === 0) {
@@ -16547,11 +16586,13 @@ function stopColorAt(stops, t) {
   }
   return stops[stops.length - 1].argb;
 }
-function pathGradientColorAt(shape, x, y, focusPoint) {
+function pathGradientColorAt(shape, x, y, focusPoint, quantum) {
   const { center, boundary, boundaryArgb } = shape;
   const n = boundary.length;
   const px = x - center.x;
   const py = y - center.y;
+  const ux = (focusPoint?.x ?? x) - center.x;
+  const uy = (focusPoint?.y ?? y) - center.y;
   let found = -1;
   let bestS = 0;
   let bestU = 0;
@@ -16573,8 +16614,10 @@ function pathGradientColorAt(shape, x, y, focusPoint) {
       continue;
     }
     found = i;
-    bestS = Math.max(0, alpha);
-    bestU = alpha > 0 ? Math.min(1, Math.max(0, beta / alpha)) : 0;
+    const alphaU = quantum ? (ux * ey - uy * ex) / det : alpha;
+    const betaU = quantum ? (ax * uy - ay * ux) / det : beta;
+    bestS = Math.max(0, alphaU);
+    bestU = alphaU > 0 ? Math.min(1, Math.max(0, betaU / alphaU)) : 0;
   }
   let s = found < 0 ? Infinity : bestS;
   if (shape.focus) {
@@ -16649,7 +16692,8 @@ function pathGradientColorAt(shape, x, y, focusPoint) {
     }
   }
   if (found < 0 || !Number.isFinite(s)) return null;
-  const pos = 1 - s;
+  const exactPos = 1 - s;
+  const pos = quantum && quantum > 0 ? quantisedPosition(exactPos, quantum) : exactPos;
   if (shape.preset && shape.preset.positions.length > 0) {
     const { positions, argb } = shape.preset;
     if (pos <= positions[0]) {
@@ -16668,6 +16712,9 @@ function pathGradientColorAt(shape, x, y, focusPoint) {
   const surround = lerpArgb(c0, c1, bestU);
   const factor = shape.blend ? piecewise2(shape.blend.positions, shape.blend.factors, pos) : pos;
   const t = Math.min(1, Math.max(0, factor));
+  if (quantum && quantum > 0 && !shape.blend && boundaryArgb.every((color) => color === boundaryArgb[0])) {
+    return quantisedPathArgb(surround, shape.centerArgb, Math.min(1, Math.max(0, exactPos)), quantum);
+  }
   return surround >>> 24 !== shape.centerArgb >>> 24 && boundaryArgb.every((color) => color === boundaryArgb[0]) ? lerpUniformPathArgb(surround, shape.centerArgb, t) : lerpArgb(surround, shape.centerArgb, t);
 }
 var MAX_TILE = 2048;
@@ -29941,23 +29988,35 @@ function perpendicularVectors(width, dx0, dy0, height = width, matrixPen) {
   const vx = rounded[0], vy = rounded[1];
   return { v: flip ? [-vx, -vy] : [vx, vy], ray: flip ? [-x, -y] : [x, y] };
 }
-function squareExtension(width, dx, dy, scale = 1, height = width, matrix, wholePixelNorm = false, symmetric = wholePixelNorm) {
+function norm(x, y) {
+  return Math.sqrt(x * x + y * y);
+}
+function squareExtension(width, dx, dy, scale = 1, height = width, matrix, wholePixelNorm = false, symmetric = wholePixelNorm, logicalScale = 1) {
+  const slack = 8;
   if (matrix) {
     const det = matrix[0] * matrix[3] - matrix[1] * matrix[2];
     const lx = (matrix[3] * dx - matrix[2] * dy) / det;
     const ly = (-matrix[1] * dx + matrix[0] * dy) / det;
-    const l = Math.hypot(lx, ly);
+    let l = Math.hypot(lx, ly);
+    if (wholePixelNorm) {
+      l = norm(Math.floor((lx + slack) / 16) * 16, Math.floor((ly + slack) / 16) * 16);
+      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)];
   }
-  let len = width === height ? Math.hypot(dx, dy) : Math.hypot(dx, dy * width / height);
-  if (wholePixelNorm && width === height) {
-    const whole = Math.hypot(Math.floor(dx / 16), Math.floor(dy / 16)) * 16;
-    if (whole === 0) return [0, 0];
-    len = whole;
-  }
+  const [ax, ay] = typeof logicalScale === "number" ? [logicalScale, logicalScale] : logicalScale;
   const r = width / 2 * scale;
   const round = symmetric ? (v) => Math.sign(v) * Math.floor(Math.abs(v) + 0.5) : (v) => Math.floor(v + 0.5);
+  if (wholePixelNorm && (width === height || ax !== ay)) {
+    const lx = dx / ax;
+    const ly = dy / ay;
+    const cut = ax === 1 && ay === 1 ? 0 : slack;
+    const whole = norm(Math.floor((lx + cut) / 16) * 16, Math.floor((ly + cut) / 16) * 16);
+    if (whole === 0) return [0, 0];
+    return [round(lx / whole * r), round(ly * ay / ax / whole * r)];
+  }
+  const len = width === height ? norm(dx, dy) : norm(dx, dy * width / height);
   return [round(dx / len * r), round(dy / len * r)];
 }
 function turnSign(ax, ay, bx, by) {
@@ -29997,7 +30056,7 @@ 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.width, perpendicular[0], perpendicular[1], 1, this.opts.height, nibMatrix, !!this.opts.wholePixelDashVectors), pe: [perpendicular[0], perpendicular[1]], curveEnd: !!drawDir, role: drawDir?.[2] ?? 3, tangentLength: drawDir ? drawDir[0] * drawDir[0] + drawDir[1] * drawDir[1] : 0, curve };
+    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 };
   }
   push(p, v) {
     this.pts.push([p[0] + v[0], p[1] + v[1]]);
@@ -30315,8 +30374,8 @@ function dashPieces(P, tangents, curveFlags, pattern, shorten, wholePixelVectors
     const [x1, y1] = P[i + 1];
     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]) : Math.hypot(dir[0], dir[1]);
-    const len = metric || matrix ? real : wholePixelVectors ? Math.hypot(Math.floor(dir[0] / 16), Math.floor(dir[1] / 16)) * 16 : Math.hypot(dir[0], dir[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]);
     if (len === 0) {
       if (on && cur) {
         cur.pts.push(P[i + 1]);
@@ -30424,26 +30483,16 @@ function widenPath(path, opts) {
       const runTangents = closed ? [...dirs, void 0] : dirs;
       const runCurves = closed ? [...curves, !!fig.roundWiden] : curves;
       for (const piece of dashPieces(run, runTangents, runCurves, opts.dashes, shorten, !!opts.wholePixelDashVectors, opts.dashMetric, opts.deviceNib ? opts.matrix : void 0)) {
-        const pts = [piece.pts[0]];
-        const pdirs = [];
-        const pdraws = [];
-        const pcurves = [];
-        for (let i = 1; i < piece.pts.length; i++) {
-          const q = piece.pts[i];
-          const last = pts[pts.length - 1];
-          if (q[0] !== last[0] || q[1] !== last[1]) {
-            pts.push(q);
-            pdirs.push(piece.dirs[i - 1]);
-            pdraws.push(piece.draws[i - 1]);
-            pcurves.push(piece.curves[i - 1]);
-          }
-        }
+        const pts = piece.pts;
+        const pdirs = piece.dirs;
+        const pdraws = piece.draws;
+        const pcurves = piece.curves;
         outliner.open(pts, pdirs.length > 0 ? pdirs : [piece.dirs[0]], pdirs.length > 0 ? pdraws : [piece.draws[0]], pdirs.length > 0 ? pcurves : [piece.curves[0]], piece.startScale, piece.endScale);
       }
     } else if (closed && P.length >= 3) {
       outliner.closed(P, dirs, curves);
     } else if (closed && P.length === 2) {
-      outliner.open([P[0], P[1], P[0]]);
+      outliner.closed(P, dirs, curves);
     } else {
       outliner.open(P, void 0, dirs, curves);
     }
@@ -30706,11 +30755,17 @@ function penWidenOptions(rCtx, opts = {}) {
       join: opts.roundPen ? "round" : opts.rectangle && !state.penExtended ? "miter" : !state.penExtended || joinBits === 0 ? "round" : joinBits === 4096 ? "bevel" : "miter",
       miterLimit: state.miterLimit ?? 10,
       dashes: dashes ? dashes.map((v) => v * 16) : null,
-      shortenDashes: (flags & 15) !== 7
+      shortenDashes: (flags & 15) !== 7,
+      // Under a rotation the device vector is converted back to logical units for a square cap's extension.
+      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;
+  const nibWidth = uniform ? Math.max(1, Math.floor(widthPx + 0.5)) : widthPx;
   return {
-    width: Math.round((ellipse ? state.penWidth * Math.abs(matrix[0]) : widthPx) * 16),
+    width: Math.round((ellipse ? state.penWidth * Math.abs(matrix[0]) : nibWidth) * 16),
     ...ellipse ? { height: Math.round(state.penWidth * Math.abs(matrix[3]) * 16) } : {},
     cap: opts.roundPen || !state.penExtended || capBits === 0 ? "round" : capBits === 256 ? "square" : "flat",
     join: opts.roundPen ? "round" : opts.rectangle && !state.penExtended ? "miter" : !state.penExtended || joinBits === 0 ? "round" : joinBits === 4096 ? "bevel" : "miter",
@@ -30720,7 +30775,13 @@ function penWidenOptions(rCtx, opts = {}) {
     shortenDashes: (flags & 15) !== 7,
     // 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
+    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 ? {
+      cutToLogicalUnits: true,
+      logicalScale: ellipse ? [Math.abs(matrix[0]), Math.abs(matrix[3])] : Math.abs(matrix[0]),
+      // The pen rounds to whole pixels, but a square cap extends by half the unrounded width.
+      ...uniform ? { capWidth: state.penWidth * Math.abs(matrix[0]) * 16 } : {}
+    } : {}
   };
 }
 function hatchBackgroundMask(hatch) {
@@ -31211,6 +31272,21 @@ function foldIntoTile(v, origin, size, mirror2, lag) {
   }
   return origin + local;
 }
+function pixelAligned(boundary, m) {
+  let x0 = Infinity;
+  let y0 = Infinity;
+  let x1 = -Infinity;
+  let y1 = -Infinity;
+  for (const p of boundary) {
+    const x = m[0] * p.x + m[2] * p.y + m[4];
+    const y = m[1] * p.x + m[3] * p.y + m[5];
+    x0 = Math.min(x0, x);
+    y0 = Math.min(y0, y);
+    x1 = Math.max(x1, x);
+    y1 = Math.max(y1, y);
+  }
+  return [x0, y0, x1, y1].every((v) => Math.abs(v - Math.round(v)) < 1e-6);
+}
 function pathGradientSampler(shape, wrap, device) {
   const box = boundaryBox2(shape.boundary);
   const full = mulMatrix(device, shape.transform ?? IDENTITY4);
@@ -31218,6 +31294,10 @@ function pathGradientSampler(shape, wrap, device) {
   if (!box || !inv2) {
     return null;
   }
+  const anisotropicFocus = !!shape.focus && Math.abs(shape.focus.x - shape.focus.y) > 1e-9;
+  const uniformSurround = shape.boundaryArgb.every((color) => color === shape.boundaryArgb[0]);
+  const smooth = !uniformSurround && !shape.preset || anisotropicFocus || wrap !== "clamp" && !pixelAligned(shape.boundary, full);
+  const quantum = smooth ? 0 : pathGradientQuantum(shape.boundary, full);
   const pxX = Math.hypot(full[0], full[1]);
   const pxY = Math.hypot(full[2], full[3]);
   const lagX = pxX > 0 ? 1 / pxX : 0;
@@ -31237,8 +31317,8 @@ function pathGradientSampler(shape, wrap, device) {
           by = foldIntoTile(by, box.y, box.h, mirrorY, lagY);
         }
         if (wrap === "clamp" && by >= box.y + box.h) continue;
-        const focusPoint = bias && shape.focus?.x === 0 ? { x: bx - inv2[0] * bias, y: by - inv2[1] * bias } : void 0;
-        const c = pathGradientColorAt(shape, bx, by, focusPoint);
+        const focusPoint = bias ? { x: bx - inv2[0] * bias, y: by - inv2[1] * bias } : void 0;
+        const c = pathGradientColorAt(shape, bx, by, focusPoint, quantum);
         if (c === null) {
           continue;
         }
@@ -32012,8 +32092,14 @@ function handleRoundRect(rCtx, dataOff, recSize) {
     const cornerFixW = inset ? Math.abs(cornerW * devM[0]) * 16 : fixExtent(rCtx, cornerW, 0);
     const cornerFixH = inset ? Math.abs(cornerH * devM[3]) * 16 : fixExtent(rCtx, cornerH, 1);
     const cornerOnFrame = (fix, size, framedSize) => inset && size !== 0 ? Math.floor(Math.min(fix, size) * framedSize / size) : fix;
-    const cw = cornerOnFrame(cornerFixW, Math.abs((r - l) * devM[0]) * 16, Math.abs(framed.exx));
-    const ch = cornerOnFrame(cornerFixH, Math.abs((b - t) * devM[3]) * 16, Math.abs(framed.eyy));
+    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));
+    if (!inset && rCtx.state.penStyle !== 6 && cornerW !== 0 && cornerH !== 0 && Math.abs(devM[1]) < 1e-9 && Math.abs(devM[2]) < 1e-9 && rCtx.state.penStyle !== 5 && !penIsCosmetic(rCtx) && rCtx.state.worldTransform.every((v, i) => v === [1, 0, 0, 1, 0, 0][i])) {
+      const fullW = (Math.abs(r - l) + 1) * Math.abs(devM[0]) * 16;
+      const fullH = (Math.abs(b - t) + 1) * Math.abs(devM[3]) * 16;
+      cw = Math.floor(Math.min(cornerFixW, fullW) * Math.abs(framed.exx) / fullW);
+      ch = Math.floor(Math.min(cornerFixH, fullH) * Math.abs(framed.eyy) / fullH);
+    }
     const drawRoundRect = inset ? (c) => appendRoundRectPath(
       c,
       Math.min(framed.ax, framed.ax + framed.exx) / 16,

package/dist/browser.mjs

@@ -16511,6 +16511,45 @@ function lerpUniformPathArgb(a, b, t) {
   };
   return (alpha << 24 | ch(16) << 16 | ch(8) << 8 | ch(0)) >>> 0;
 }
+function pathGradientQuantum(boundary, matrix = IDENTITY) {
+  let x0 = Infinity;
+  let y0 = Infinity;
+  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);
+  }
+  const steps = Math.ceil(2 * Math.hypot(x1 - x0, y1 - y0));
+  return Number.isFinite(steps) && steps > 0 ? steps : 0;
+}
+var TIE_EPSILON = 1e-7;
+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;
+  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);
+  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);
+    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 quantisedPosition(pos, quantum) {
+  const scaled2 = pos * quantum;
+  const tie = Math.abs(scaled2 - Math.floor(scaled2) - 0.5) < TIE_EPSILON;
+  return (tie ? scaled2 : Math.floor(scaled2 + 0.5)) / quantum;
+}
 function piecewise2(xs, ys, x) {
   const n = Math.min(xs.length, ys.length);
   if (n === 0) {
@@ -16545,11 +16584,13 @@ function stopColorAt(stops, t) {
   }
   return stops[stops.length - 1].argb;
 }
-function pathGradientColorAt(shape, x, y, focusPoint) {
+function pathGradientColorAt(shape, x, y, focusPoint, quantum) {
   const { center, boundary, boundaryArgb } = shape;
   const n = boundary.length;
   const px = x - center.x;
   const py = y - center.y;
+  const ux = (focusPoint?.x ?? x) - center.x;
+  const uy = (focusPoint?.y ?? y) - center.y;
   let found = -1;
   let bestS = 0;
   let bestU = 0;
@@ -16571,8 +16612,10 @@ function pathGradientColorAt(shape, x, y, focusPoint) {
       continue;
     }
     found = i;
-    bestS = Math.max(0, alpha);
-    bestU = alpha > 0 ? Math.min(1, Math.max(0, beta / alpha)) : 0;
+    const alphaU = quantum ? (ux * ey - uy * ex) / det : alpha;
+    const betaU = quantum ? (ax * uy - ay * ux) / det : beta;
+    bestS = Math.max(0, alphaU);
+    bestU = alphaU > 0 ? Math.min(1, Math.max(0, betaU / alphaU)) : 0;
   }
   let s = found < 0 ? Infinity : bestS;
   if (shape.focus) {
@@ -16647,7 +16690,8 @@ function pathGradientColorAt(shape, x, y, focusPoint) {
     }
   }
   if (found < 0 || !Number.isFinite(s)) return null;
-  const pos = 1 - s;
+  const exactPos = 1 - s;
+  const pos = quantum && quantum > 0 ? quantisedPosition(exactPos, quantum) : exactPos;
   if (shape.preset && shape.preset.positions.length > 0) {
     const { positions, argb } = shape.preset;
     if (pos <= positions[0]) {
@@ -16666,6 +16710,9 @@ function pathGradientColorAt(shape, x, y, focusPoint) {
   const surround = lerpArgb(c0, c1, bestU);
   const factor = shape.blend ? piecewise2(shape.blend.positions, shape.blend.factors, pos) : pos;
   const t = Math.min(1, Math.max(0, factor));
+  if (quantum && quantum > 0 && !shape.blend && boundaryArgb.every((color) => color === boundaryArgb[0])) {
+    return quantisedPathArgb(surround, shape.centerArgb, Math.min(1, Math.max(0, exactPos)), quantum);
+  }
   return surround >>> 24 !== shape.centerArgb >>> 24 && boundaryArgb.every((color) => color === boundaryArgb[0]) ? lerpUniformPathArgb(surround, shape.centerArgb, t) : lerpArgb(surround, shape.centerArgb, t);
 }
 var MAX_TILE = 2048;
@@ -29939,23 +29986,35 @@ function perpendicularVectors(width, dx0, dy0, height = width, matrixPen) {
   const vx = rounded[0], vy = rounded[1];
   return { v: flip ? [-vx, -vy] : [vx, vy], ray: flip ? [-x, -y] : [x, y] };
 }
-function squareExtension(width, dx, dy, scale = 1, height = width, matrix, wholePixelNorm = false, symmetric = wholePixelNorm) {
+function norm(x, y) {
+  return Math.sqrt(x * x + y * y);
+}
+function squareExtension(width, dx, dy, scale = 1, height = width, matrix, wholePixelNorm = false, symmetric = wholePixelNorm, logicalScale = 1) {
+  const slack = 8;
   if (matrix) {
     const det = matrix[0] * matrix[3] - matrix[1] * matrix[2];
     const lx = (matrix[3] * dx - matrix[2] * dy) / det;
     const ly = (-matrix[1] * dx + matrix[0] * dy) / det;
-    const l = Math.hypot(lx, ly);
+    let l = Math.hypot(lx, ly);
+    if (wholePixelNorm) {
+      l = norm(Math.floor((lx + slack) / 16) * 16, Math.floor((ly + slack) / 16) * 16);
+      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)];
   }
-  let len = width === height ? Math.hypot(dx, dy) : Math.hypot(dx, dy * width / height);
-  if (wholePixelNorm && width === height) {
-    const whole = Math.hypot(Math.floor(dx / 16), Math.floor(dy / 16)) * 16;
-    if (whole === 0) return [0, 0];
-    len = whole;
-  }
+  const [ax, ay] = typeof logicalScale === "number" ? [logicalScale, logicalScale] : logicalScale;
   const r = width / 2 * scale;
   const round = symmetric ? (v) => Math.sign(v) * Math.floor(Math.abs(v) + 0.5) : (v) => Math.floor(v + 0.5);
+  if (wholePixelNorm && (width === height || ax !== ay)) {
+    const lx = dx / ax;
+    const ly = dy / ay;
+    const cut = ax === 1 && ay === 1 ? 0 : slack;
+    const whole = norm(Math.floor((lx + cut) / 16) * 16, Math.floor((ly + cut) / 16) * 16);
+    if (whole === 0) return [0, 0];
+    return [round(lx / whole * r), round(ly * ay / ax / whole * r)];
+  }
+  const len = width === height ? norm(dx, dy) : norm(dx, dy * width / height);
   return [round(dx / len * r), round(dy / len * r)];
 }
 function turnSign(ax, ay, bx, by) {
@@ -29995,7 +30054,7 @@ 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.width, perpendicular[0], perpendicular[1], 1, this.opts.height, nibMatrix, !!this.opts.wholePixelDashVectors), pe: [perpendicular[0], perpendicular[1]], curveEnd: !!drawDir, role: drawDir?.[2] ?? 3, tangentLength: drawDir ? drawDir[0] * drawDir[0] + drawDir[1] * drawDir[1] : 0, curve };
+    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 };
   }
   push(p, v) {
     this.pts.push([p[0] + v[0], p[1] + v[1]]);
@@ -30313,8 +30372,8 @@ function dashPieces(P, tangents, curveFlags, pattern, shorten, wholePixelVectors
     const [x1, y1] = P[i + 1];
     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]) : Math.hypot(dir[0], dir[1]);
-    const len = metric || matrix ? real : wholePixelVectors ? Math.hypot(Math.floor(dir[0] / 16), Math.floor(dir[1] / 16)) * 16 : Math.hypot(dir[0], dir[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]);
     if (len === 0) {
       if (on && cur) {
         cur.pts.push(P[i + 1]);
@@ -30422,26 +30481,16 @@ function widenPath(path, opts) {
       const runTangents = closed ? [...dirs, void 0] : dirs;
       const runCurves = closed ? [...curves, !!fig.roundWiden] : curves;
       for (const piece of dashPieces(run, runTangents, runCurves, opts.dashes, shorten, !!opts.wholePixelDashVectors, opts.dashMetric, opts.deviceNib ? opts.matrix : void 0)) {
-        const pts = [piece.pts[0]];
-        const pdirs = [];
-        const pdraws = [];
-        const pcurves = [];
-        for (let i = 1; i < piece.pts.length; i++) {
-          const q = piece.pts[i];
-          const last = pts[pts.length - 1];
-          if (q[0] !== last[0] || q[1] !== last[1]) {
-            pts.push(q);
-            pdirs.push(piece.dirs[i - 1]);
-            pdraws.push(piece.draws[i - 1]);
-            pcurves.push(piece.curves[i - 1]);
-          }
-        }
+        const pts = piece.pts;
+        const pdirs = piece.dirs;
+        const pdraws = piece.draws;
+        const pcurves = piece.curves;
         outliner.open(pts, pdirs.length > 0 ? pdirs : [piece.dirs[0]], pdirs.length > 0 ? pdraws : [piece.draws[0]], pdirs.length > 0 ? pcurves : [piece.curves[0]], piece.startScale, piece.endScale);
       }
     } else if (closed && P.length >= 3) {
       outliner.closed(P, dirs, curves);
     } else if (closed && P.length === 2) {
-      outliner.open([P[0], P[1], P[0]]);
+      outliner.closed(P, dirs, curves);
     } else {
       outliner.open(P, void 0, dirs, curves);
     }
@@ -30704,11 +30753,17 @@ function penWidenOptions(rCtx, opts = {}) {
       join: opts.roundPen ? "round" : opts.rectangle && !state.penExtended ? "miter" : !state.penExtended || joinBits === 0 ? "round" : joinBits === 4096 ? "bevel" : "miter",
       miterLimit: state.miterLimit ?? 10,
       dashes: dashes ? dashes.map((v) => v * 16) : null,
-      shortenDashes: (flags & 15) !== 7
+      shortenDashes: (flags & 15) !== 7,
+      // Under a rotation the device vector is converted back to logical units for a square cap's extension.
+      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;
+  const nibWidth = uniform ? Math.max(1, Math.floor(widthPx + 0.5)) : widthPx;
   return {
-    width: Math.round((ellipse ? state.penWidth * Math.abs(matrix[0]) : widthPx) * 16),
+    width: Math.round((ellipse ? state.penWidth * Math.abs(matrix[0]) : nibWidth) * 16),
     ...ellipse ? { height: Math.round(state.penWidth * Math.abs(matrix[3]) * 16) } : {},
     cap: opts.roundPen || !state.penExtended || capBits === 0 ? "round" : capBits === 256 ? "square" : "flat",
     join: opts.roundPen ? "round" : opts.rectangle && !state.penExtended ? "miter" : !state.penExtended || joinBits === 0 ? "round" : joinBits === 4096 ? "bevel" : "miter",
@@ -30718,7 +30773,13 @@ function penWidenOptions(rCtx, opts = {}) {
     shortenDashes: (flags & 15) !== 7,
     // 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
+    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 ? {
+      cutToLogicalUnits: true,
+      logicalScale: ellipse ? [Math.abs(matrix[0]), Math.abs(matrix[3])] : Math.abs(matrix[0]),
+      // The pen rounds to whole pixels, but a square cap extends by half the unrounded width.
+      ...uniform ? { capWidth: state.penWidth * Math.abs(matrix[0]) * 16 } : {}
+    } : {}
   };
 }
 function hatchBackgroundMask(hatch) {
@@ -31209,6 +31270,21 @@ function foldIntoTile(v, origin, size, mirror2, lag) {
   }
   return origin + local;
 }
+function pixelAligned(boundary, m) {
+  let x0 = Infinity;
+  let y0 = Infinity;
+  let x1 = -Infinity;
+  let y1 = -Infinity;
+  for (const p of boundary) {
+    const x = m[0] * p.x + m[2] * p.y + m[4];
+    const y = m[1] * p.x + m[3] * p.y + m[5];
+    x0 = Math.min(x0, x);
+    y0 = Math.min(y0, y);
+    x1 = Math.max(x1, x);
+    y1 = Math.max(y1, y);
+  }
+  return [x0, y0, x1, y1].every((v) => Math.abs(v - Math.round(v)) < 1e-6);
+}
 function pathGradientSampler(shape, wrap, device) {
   const box = boundaryBox2(shape.boundary);
   const full = mulMatrix(device, shape.transform ?? IDENTITY4);
@@ -31216,6 +31292,10 @@ function pathGradientSampler(shape, wrap, device) {
   if (!box || !inv2) {
     return null;
   }
+  const anisotropicFocus = !!shape.focus && Math.abs(shape.focus.x - shape.focus.y) > 1e-9;
+  const uniformSurround = shape.boundaryArgb.every((color) => color === shape.boundaryArgb[0]);
+  const smooth = !uniformSurround && !shape.preset || anisotropicFocus || wrap !== "clamp" && !pixelAligned(shape.boundary, full);
+  const quantum = smooth ? 0 : pathGradientQuantum(shape.boundary, full);
   const pxX = Math.hypot(full[0], full[1]);
   const pxY = Math.hypot(full[2], full[3]);
   const lagX = pxX > 0 ? 1 / pxX : 0;
@@ -31235,8 +31315,8 @@ function pathGradientSampler(shape, wrap, device) {
           by = foldIntoTile(by, box.y, box.h, mirrorY, lagY);
         }
         if (wrap === "clamp" && by >= box.y + box.h) continue;
-        const focusPoint = bias && shape.focus?.x === 0 ? { x: bx - inv2[0] * bias, y: by - inv2[1] * bias } : void 0;
-        const c = pathGradientColorAt(shape, bx, by, focusPoint);
+        const focusPoint = bias ? { x: bx - inv2[0] * bias, y: by - inv2[1] * bias } : void 0;
+        const c = pathGradientColorAt(shape, bx, by, focusPoint, quantum);
         if (c === null) {
           continue;
         }
@@ -32010,8 +32090,14 @@ function handleRoundRect(rCtx, dataOff, recSize) {
     const cornerFixW = inset ? Math.abs(cornerW * devM[0]) * 16 : fixExtent(rCtx, cornerW, 0);
     const cornerFixH = inset ? Math.abs(cornerH * devM[3]) * 16 : fixExtent(rCtx, cornerH, 1);
     const cornerOnFrame = (fix, size, framedSize) => inset && size !== 0 ? Math.floor(Math.min(fix, size) * framedSize / size) : fix;
-    const cw = cornerOnFrame(cornerFixW, Math.abs((r - l) * devM[0]) * 16, Math.abs(framed.exx));
-    const ch = cornerOnFrame(cornerFixH, Math.abs((b - t) * devM[3]) * 16, Math.abs(framed.eyy));
+    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));
+    if (!inset && rCtx.state.penStyle !== 6 && cornerW !== 0 && cornerH !== 0 && Math.abs(devM[1]) < 1e-9 && Math.abs(devM[2]) < 1e-9 && rCtx.state.penStyle !== 5 && !penIsCosmetic(rCtx) && rCtx.state.worldTransform.every((v, i) => v === [1, 0, 0, 1, 0, 0][i])) {
+      const fullW = (Math.abs(r - l) + 1) * Math.abs(devM[0]) * 16;
+      const fullH = (Math.abs(b - t) + 1) * Math.abs(devM[3]) * 16;
+      cw = Math.floor(Math.min(cornerFixW, fullW) * Math.abs(framed.exx) / fullW);
+      ch = Math.floor(Math.min(cornerFixH, fullH) * Math.abs(framed.eyy) / fullH);
+    }
     const drawRoundRect = inset ? (c) => appendRoundRectPath(
       c,
       Math.min(framed.ax, framed.ax + framed.exx) / 16,

package/dist/index.js

@@ -16514,6 +16514,45 @@ function lerpUniformPathArgb(a, b, t) {
   };
   return (alpha << 24 | ch(16) << 16 | ch(8) << 8 | ch(0)) >>> 0;
 }
+function pathGradientQuantum(boundary, matrix = IDENTITY) {
+  let x0 = Infinity;
+  let y0 = Infinity;
+  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);
+  }
+  const steps = Math.ceil(2 * Math.hypot(x1 - x0, y1 - y0));
+  return Number.isFinite(steps) && steps > 0 ? steps : 0;
+}
+var TIE_EPSILON = 1e-7;
+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;
+  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);
+  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);
+    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 quantisedPosition(pos, quantum) {
+  const scaled2 = pos * quantum;
+  const tie = Math.abs(scaled2 - Math.floor(scaled2) - 0.5) < TIE_EPSILON;
+  return (tie ? scaled2 : Math.floor(scaled2 + 0.5)) / quantum;
+}
 function piecewise2(xs, ys, x) {
   const n = Math.min(xs.length, ys.length);
   if (n === 0) {
@@ -16548,11 +16587,13 @@ function stopColorAt(stops, t) {
   }
   return stops[stops.length - 1].argb;
 }
-function pathGradientColorAt(shape, x, y, focusPoint) {
+function pathGradientColorAt(shape, x, y, focusPoint, quantum) {
   const { center, boundary, boundaryArgb } = shape;
   const n = boundary.length;
   const px = x - center.x;
   const py = y - center.y;
+  const ux = (focusPoint?.x ?? x) - center.x;
+  const uy = (focusPoint?.y ?? y) - center.y;
   let found = -1;
   let bestS = 0;
   let bestU = 0;
@@ -16574,8 +16615,10 @@ function pathGradientColorAt(shape, x, y, focusPoint) {
       continue;
     }
     found = i;
-    bestS = Math.max(0, alpha);
-    bestU = alpha > 0 ? Math.min(1, Math.max(0, beta / alpha)) : 0;
+    const alphaU = quantum ? (ux * ey - uy * ex) / det : alpha;
+    const betaU = quantum ? (ax * uy - ay * ux) / det : beta;
+    bestS = Math.max(0, alphaU);
+    bestU = alphaU > 0 ? Math.min(1, Math.max(0, betaU / alphaU)) : 0;
   }
   let s = found < 0 ? Infinity : bestS;
   if (shape.focus) {
@@ -16650,7 +16693,8 @@ function pathGradientColorAt(shape, x, y, focusPoint) {
     }
   }
   if (found < 0 || !Number.isFinite(s)) return null;
-  const pos = 1 - s;
+  const exactPos = 1 - s;
+  const pos = quantum && quantum > 0 ? quantisedPosition(exactPos, quantum) : exactPos;
   if (shape.preset && shape.preset.positions.length > 0) {
     const { positions, argb } = shape.preset;
     if (pos <= positions[0]) {
@@ -16669,6 +16713,9 @@ function pathGradientColorAt(shape, x, y, focusPoint) {
   const surround = lerpArgb(c0, c1, bestU);
   const factor = shape.blend ? piecewise2(shape.blend.positions, shape.blend.factors, pos) : pos;
   const t = Math.min(1, Math.max(0, factor));
+  if (quantum && quantum > 0 && !shape.blend && boundaryArgb.every((color) => color === boundaryArgb[0])) {
+    return quantisedPathArgb(surround, shape.centerArgb, Math.min(1, Math.max(0, exactPos)), quantum);
+  }
   return surround >>> 24 !== shape.centerArgb >>> 24 && boundaryArgb.every((color) => color === boundaryArgb[0]) ? lerpUniformPathArgb(surround, shape.centerArgb, t) : lerpArgb(surround, shape.centerArgb, t);
 }
 var MAX_TILE = 2048;
@@ -29942,23 +29989,35 @@ function perpendicularVectors(width, dx0, dy0, height = width, matrixPen) {
   const vx = rounded[0], vy = rounded[1];
   return { v: flip ? [-vx, -vy] : [vx, vy], ray: flip ? [-x, -y] : [x, y] };
 }
-function squareExtension(width, dx, dy, scale = 1, height = width, matrix, wholePixelNorm = false, symmetric = wholePixelNorm) {
+function norm(x, y) {
+  return Math.sqrt(x * x + y * y);
+}
+function squareExtension(width, dx, dy, scale = 1, height = width, matrix, wholePixelNorm = false, symmetric = wholePixelNorm, logicalScale = 1) {
+  const slack = 8;
   if (matrix) {
     const det = matrix[0] * matrix[3] - matrix[1] * matrix[2];
     const lx = (matrix[3] * dx - matrix[2] * dy) / det;
     const ly = (-matrix[1] * dx + matrix[0] * dy) / det;
-    const l = Math.hypot(lx, ly);
+    let l = Math.hypot(lx, ly);
+    if (wholePixelNorm) {
+      l = norm(Math.floor((lx + slack) / 16) * 16, Math.floor((ly + slack) / 16) * 16);
+      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)];
   }
-  let len = width === height ? Math.hypot(dx, dy) : Math.hypot(dx, dy * width / height);
-  if (wholePixelNorm && width === height) {
-    const whole = Math.hypot(Math.floor(dx / 16), Math.floor(dy / 16)) * 16;
-    if (whole === 0) return [0, 0];
-    len = whole;
-  }
+  const [ax, ay] = typeof logicalScale === "number" ? [logicalScale, logicalScale] : logicalScale;
   const r = width / 2 * scale;
   const round = symmetric ? (v) => Math.sign(v) * Math.floor(Math.abs(v) + 0.5) : (v) => Math.floor(v + 0.5);
+  if (wholePixelNorm && (width === height || ax !== ay)) {
+    const lx = dx / ax;
+    const ly = dy / ay;
+    const cut = ax === 1 && ay === 1 ? 0 : slack;
+    const whole = norm(Math.floor((lx + cut) / 16) * 16, Math.floor((ly + cut) / 16) * 16);
+    if (whole === 0) return [0, 0];
+    return [round(lx / whole * r), round(ly * ay / ax / whole * r)];
+  }
+  const len = width === height ? norm(dx, dy) : norm(dx, dy * width / height);
   return [round(dx / len * r), round(dy / len * r)];
 }
 function turnSign(ax, ay, bx, by) {
@@ -29998,7 +30057,7 @@ 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.width, perpendicular[0], perpendicular[1], 1, this.opts.height, nibMatrix, !!this.opts.wholePixelDashVectors), pe: [perpendicular[0], perpendicular[1]], curveEnd: !!drawDir, role: drawDir?.[2] ?? 3, tangentLength: drawDir ? drawDir[0] * drawDir[0] + drawDir[1] * drawDir[1] : 0, curve };
+    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 };
   }
   push(p, v) {
     this.pts.push([p[0] + v[0], p[1] + v[1]]);
@@ -30316,8 +30375,8 @@ function dashPieces(P, tangents, curveFlags, pattern, shorten, wholePixelVectors
     const [x1, y1] = P[i + 1];
     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]) : Math.hypot(dir[0], dir[1]);
-    const len = metric || matrix ? real : wholePixelVectors ? Math.hypot(Math.floor(dir[0] / 16), Math.floor(dir[1] / 16)) * 16 : Math.hypot(dir[0], dir[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]);
     if (len === 0) {
       if (on && cur) {
         cur.pts.push(P[i + 1]);
@@ -30425,26 +30484,16 @@ function widenPath(path, opts) {
       const runTangents = closed ? [...dirs, void 0] : dirs;
       const runCurves = closed ? [...curves, !!fig.roundWiden] : curves;
       for (const piece of dashPieces(run, runTangents, runCurves, opts.dashes, shorten, !!opts.wholePixelDashVectors, opts.dashMetric, opts.deviceNib ? opts.matrix : void 0)) {
-        const pts = [piece.pts[0]];
-        const pdirs = [];
-        const pdraws = [];
-        const pcurves = [];
-        for (let i = 1; i < piece.pts.length; i++) {
-          const q = piece.pts[i];
-          const last = pts[pts.length - 1];
-          if (q[0] !== last[0] || q[1] !== last[1]) {
-            pts.push(q);
-            pdirs.push(piece.dirs[i - 1]);
-            pdraws.push(piece.draws[i - 1]);
-            pcurves.push(piece.curves[i - 1]);
-          }
-        }
+        const pts = piece.pts;
+        const pdirs = piece.dirs;
+        const pdraws = piece.draws;
+        const pcurves = piece.curves;
         outliner.open(pts, pdirs.length > 0 ? pdirs : [piece.dirs[0]], pdirs.length > 0 ? pdraws : [piece.draws[0]], pdirs.length > 0 ? pcurves : [piece.curves[0]], piece.startScale, piece.endScale);
       }
     } else if (closed && P.length >= 3) {
       outliner.closed(P, dirs, curves);
     } else if (closed && P.length === 2) {
-      outliner.open([P[0], P[1], P[0]]);
+      outliner.closed(P, dirs, curves);
     } else {
       outliner.open(P, void 0, dirs, curves);
     }
@@ -30707,11 +30756,17 @@ function penWidenOptions(rCtx, opts = {}) {
       join: opts.roundPen ? "round" : opts.rectangle && !state.penExtended ? "miter" : !state.penExtended || joinBits === 0 ? "round" : joinBits === 4096 ? "bevel" : "miter",
       miterLimit: state.miterLimit ?? 10,
       dashes: dashes ? dashes.map((v) => v * 16) : null,
-      shortenDashes: (flags & 15) !== 7
+      shortenDashes: (flags & 15) !== 7,
+      // Under a rotation the device vector is converted back to logical units for a square cap's extension.
+      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;
+  const nibWidth = uniform ? Math.max(1, Math.floor(widthPx + 0.5)) : widthPx;
   return {
-    width: Math.round((ellipse ? state.penWidth * Math.abs(matrix[0]) : widthPx) * 16),
+    width: Math.round((ellipse ? state.penWidth * Math.abs(matrix[0]) : nibWidth) * 16),
     ...ellipse ? { height: Math.round(state.penWidth * Math.abs(matrix[3]) * 16) } : {},
     cap: opts.roundPen || !state.penExtended || capBits === 0 ? "round" : capBits === 256 ? "square" : "flat",
     join: opts.roundPen ? "round" : opts.rectangle && !state.penExtended ? "miter" : !state.penExtended || joinBits === 0 ? "round" : joinBits === 4096 ? "bevel" : "miter",
@@ -30721,7 +30776,13 @@ function penWidenOptions(rCtx, opts = {}) {
     shortenDashes: (flags & 15) !== 7,
     // 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
+    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 ? {
+      cutToLogicalUnits: true,
+      logicalScale: ellipse ? [Math.abs(matrix[0]), Math.abs(matrix[3])] : Math.abs(matrix[0]),
+      // The pen rounds to whole pixels, but a square cap extends by half the unrounded width.
+      ...uniform ? { capWidth: state.penWidth * Math.abs(matrix[0]) * 16 } : {}
+    } : {}
   };
 }
 function hatchBackgroundMask(hatch) {
@@ -31212,6 +31273,21 @@ function foldIntoTile(v, origin, size, mirror2, lag) {
   }
   return origin + local;
 }
+function pixelAligned(boundary, m) {
+  let x0 = Infinity;
+  let y0 = Infinity;
+  let x1 = -Infinity;
+  let y1 = -Infinity;
+  for (const p of boundary) {
+    const x = m[0] * p.x + m[2] * p.y + m[4];
+    const y = m[1] * p.x + m[3] * p.y + m[5];
+    x0 = Math.min(x0, x);
+    y0 = Math.min(y0, y);
+    x1 = Math.max(x1, x);
+    y1 = Math.max(y1, y);
+  }
+  return [x0, y0, x1, y1].every((v) => Math.abs(v - Math.round(v)) < 1e-6);
+}
 function pathGradientSampler(shape, wrap, device) {
   const box = boundaryBox2(shape.boundary);
   const full = mulMatrix(device, shape.transform ?? IDENTITY4);
@@ -31219,6 +31295,10 @@ function pathGradientSampler(shape, wrap, device) {
   if (!box || !inv2) {
     return null;
   }
+  const anisotropicFocus = !!shape.focus && Math.abs(shape.focus.x - shape.focus.y) > 1e-9;
+  const uniformSurround = shape.boundaryArgb.every((color) => color === shape.boundaryArgb[0]);
+  const smooth = !uniformSurround && !shape.preset || anisotropicFocus || wrap !== "clamp" && !pixelAligned(shape.boundary, full);
+  const quantum = smooth ? 0 : pathGradientQuantum(shape.boundary, full);
   const pxX = Math.hypot(full[0], full[1]);
   const pxY = Math.hypot(full[2], full[3]);
   const lagX = pxX > 0 ? 1 / pxX : 0;
@@ -31238,8 +31318,8 @@ function pathGradientSampler(shape, wrap, device) {
           by = foldIntoTile(by, box.y, box.h, mirrorY, lagY);
         }
         if (wrap === "clamp" && by >= box.y + box.h) continue;
-        const focusPoint = bias && shape.focus?.x === 0 ? { x: bx - inv2[0] * bias, y: by - inv2[1] * bias } : void 0;
-        const c = pathGradientColorAt(shape, bx, by, focusPoint);
+        const focusPoint = bias ? { x: bx - inv2[0] * bias, y: by - inv2[1] * bias } : void 0;
+        const c = pathGradientColorAt(shape, bx, by, focusPoint, quantum);
         if (c === null) {
           continue;
         }
@@ -32013,8 +32093,14 @@ function handleRoundRect(rCtx, dataOff, recSize) {
     const cornerFixW = inset ? Math.abs(cornerW * devM[0]) * 16 : fixExtent(rCtx, cornerW, 0);
     const cornerFixH = inset ? Math.abs(cornerH * devM[3]) * 16 : fixExtent(rCtx, cornerH, 1);
     const cornerOnFrame = (fix, size, framedSize) => inset && size !== 0 ? Math.floor(Math.min(fix, size) * framedSize / size) : fix;
-    const cw = cornerOnFrame(cornerFixW, Math.abs((r - l) * devM[0]) * 16, Math.abs(framed.exx));
-    const ch = cornerOnFrame(cornerFixH, Math.abs((b - t) * devM[3]) * 16, Math.abs(framed.eyy));
+    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));
+    if (!inset && rCtx.state.penStyle !== 6 && cornerW !== 0 && cornerH !== 0 && Math.abs(devM[1]) < 1e-9 && Math.abs(devM[2]) < 1e-9 && rCtx.state.penStyle !== 5 && !penIsCosmetic(rCtx) && rCtx.state.worldTransform.every((v, i) => v === [1, 0, 0, 1, 0, 0][i])) {
+      const fullW = (Math.abs(r - l) + 1) * Math.abs(devM[0]) * 16;
+      const fullH = (Math.abs(b - t) + 1) * Math.abs(devM[3]) * 16;
+      cw = Math.floor(Math.min(cornerFixW, fullW) * Math.abs(framed.exx) / fullW);
+      ch = Math.floor(Math.min(cornerFixH, fullH) * Math.abs(framed.eyy) / fullH);
+    }
     const drawRoundRect = inset ? (c) => appendRoundRectPath(
       c,
       Math.min(framed.ax, framed.ax + framed.exx) / 16,

package/dist/index.mjs

@@ -16512,6 +16512,45 @@ function lerpUniformPathArgb(a, b, t) {
   };
   return (alpha << 24 | ch(16) << 16 | ch(8) << 8 | ch(0)) >>> 0;
 }
+function pathGradientQuantum(boundary, matrix = IDENTITY) {
+  let x0 = Infinity;
+  let y0 = Infinity;
+  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);
+  }
+  const steps = Math.ceil(2 * Math.hypot(x1 - x0, y1 - y0));
+  return Number.isFinite(steps) && steps > 0 ? steps : 0;
+}
+var TIE_EPSILON = 1e-7;
+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;
+  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);
+  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);
+    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 quantisedPosition(pos, quantum) {
+  const scaled2 = pos * quantum;
+  const tie = Math.abs(scaled2 - Math.floor(scaled2) - 0.5) < TIE_EPSILON;
+  return (tie ? scaled2 : Math.floor(scaled2 + 0.5)) / quantum;
+}
 function piecewise2(xs, ys, x) {
   const n = Math.min(xs.length, ys.length);
   if (n === 0) {
@@ -16546,11 +16585,13 @@ function stopColorAt(stops, t) {
   }
   return stops[stops.length - 1].argb;
 }
-function pathGradientColorAt(shape, x, y, focusPoint) {
+function pathGradientColorAt(shape, x, y, focusPoint, quantum) {
   const { center, boundary, boundaryArgb } = shape;
   const n = boundary.length;
   const px = x - center.x;
   const py = y - center.y;
+  const ux = (focusPoint?.x ?? x) - center.x;
+  const uy = (focusPoint?.y ?? y) - center.y;
   let found = -1;
   let bestS = 0;
   let bestU = 0;
@@ -16572,8 +16613,10 @@ function pathGradientColorAt(shape, x, y, focusPoint) {
       continue;
     }
     found = i;
-    bestS = Math.max(0, alpha);
-    bestU = alpha > 0 ? Math.min(1, Math.max(0, beta / alpha)) : 0;
+    const alphaU = quantum ? (ux * ey - uy * ex) / det : alpha;
+    const betaU = quantum ? (ax * uy - ay * ux) / det : beta;
+    bestS = Math.max(0, alphaU);
+    bestU = alphaU > 0 ? Math.min(1, Math.max(0, betaU / alphaU)) : 0;
   }
   let s = found < 0 ? Infinity : bestS;
   if (shape.focus) {
@@ -16648,7 +16691,8 @@ function pathGradientColorAt(shape, x, y, focusPoint) {
     }
   }
   if (found < 0 || !Number.isFinite(s)) return null;
-  const pos = 1 - s;
+  const exactPos = 1 - s;
+  const pos = quantum && quantum > 0 ? quantisedPosition(exactPos, quantum) : exactPos;
   if (shape.preset && shape.preset.positions.length > 0) {
     const { positions, argb } = shape.preset;
     if (pos <= positions[0]) {
@@ -16667,6 +16711,9 @@ function pathGradientColorAt(shape, x, y, focusPoint) {
   const surround = lerpArgb(c0, c1, bestU);
   const factor = shape.blend ? piecewise2(shape.blend.positions, shape.blend.factors, pos) : pos;
   const t = Math.min(1, Math.max(0, factor));
+  if (quantum && quantum > 0 && !shape.blend && boundaryArgb.every((color) => color === boundaryArgb[0])) {
+    return quantisedPathArgb(surround, shape.centerArgb, Math.min(1, Math.max(0, exactPos)), quantum);
+  }
   return surround >>> 24 !== shape.centerArgb >>> 24 && boundaryArgb.every((color) => color === boundaryArgb[0]) ? lerpUniformPathArgb(surround, shape.centerArgb, t) : lerpArgb(surround, shape.centerArgb, t);
 }
 var MAX_TILE = 2048;
@@ -29940,23 +29987,35 @@ function perpendicularVectors(width, dx0, dy0, height = width, matrixPen) {
   const vx = rounded[0], vy = rounded[1];
   return { v: flip ? [-vx, -vy] : [vx, vy], ray: flip ? [-x, -y] : [x, y] };
 }
-function squareExtension(width, dx, dy, scale = 1, height = width, matrix, wholePixelNorm = false, symmetric = wholePixelNorm) {
+function norm(x, y) {
+  return Math.sqrt(x * x + y * y);
+}
+function squareExtension(width, dx, dy, scale = 1, height = width, matrix, wholePixelNorm = false, symmetric = wholePixelNorm, logicalScale = 1) {
+  const slack = 8;
   if (matrix) {
     const det = matrix[0] * matrix[3] - matrix[1] * matrix[2];
     const lx = (matrix[3] * dx - matrix[2] * dy) / det;
     const ly = (-matrix[1] * dx + matrix[0] * dy) / det;
-    const l = Math.hypot(lx, ly);
+    let l = Math.hypot(lx, ly);
+    if (wholePixelNorm) {
+      l = norm(Math.floor((lx + slack) / 16) * 16, Math.floor((ly + slack) / 16) * 16);
+      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)];
   }
-  let len = width === height ? Math.hypot(dx, dy) : Math.hypot(dx, dy * width / height);
-  if (wholePixelNorm && width === height) {
-    const whole = Math.hypot(Math.floor(dx / 16), Math.floor(dy / 16)) * 16;
-    if (whole === 0) return [0, 0];
-    len = whole;
-  }
+  const [ax, ay] = typeof logicalScale === "number" ? [logicalScale, logicalScale] : logicalScale;
   const r = width / 2 * scale;
   const round = symmetric ? (v) => Math.sign(v) * Math.floor(Math.abs(v) + 0.5) : (v) => Math.floor(v + 0.5);
+  if (wholePixelNorm && (width === height || ax !== ay)) {
+    const lx = dx / ax;
+    const ly = dy / ay;
+    const cut = ax === 1 && ay === 1 ? 0 : slack;
+    const whole = norm(Math.floor((lx + cut) / 16) * 16, Math.floor((ly + cut) / 16) * 16);
+    if (whole === 0) return [0, 0];
+    return [round(lx / whole * r), round(ly * ay / ax / whole * r)];
+  }
+  const len = width === height ? norm(dx, dy) : norm(dx, dy * width / height);
   return [round(dx / len * r), round(dy / len * r)];
 }
 function turnSign(ax, ay, bx, by) {
@@ -29996,7 +30055,7 @@ 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.width, perpendicular[0], perpendicular[1], 1, this.opts.height, nibMatrix, !!this.opts.wholePixelDashVectors), pe: [perpendicular[0], perpendicular[1]], curveEnd: !!drawDir, role: drawDir?.[2] ?? 3, tangentLength: drawDir ? drawDir[0] * drawDir[0] + drawDir[1] * drawDir[1] : 0, curve };
+    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 };
   }
   push(p, v) {
     this.pts.push([p[0] + v[0], p[1] + v[1]]);
@@ -30314,8 +30373,8 @@ function dashPieces(P, tangents, curveFlags, pattern, shorten, wholePixelVectors
     const [x1, y1] = P[i + 1];
     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]) : Math.hypot(dir[0], dir[1]);
-    const len = metric || matrix ? real : wholePixelVectors ? Math.hypot(Math.floor(dir[0] / 16), Math.floor(dir[1] / 16)) * 16 : Math.hypot(dir[0], dir[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]);
     if (len === 0) {
       if (on && cur) {
         cur.pts.push(P[i + 1]);
@@ -30423,26 +30482,16 @@ function widenPath(path, opts) {
       const runTangents = closed ? [...dirs, void 0] : dirs;
       const runCurves = closed ? [...curves, !!fig.roundWiden] : curves;
       for (const piece of dashPieces(run, runTangents, runCurves, opts.dashes, shorten, !!opts.wholePixelDashVectors, opts.dashMetric, opts.deviceNib ? opts.matrix : void 0)) {
-        const pts = [piece.pts[0]];
-        const pdirs = [];
-        const pdraws = [];
-        const pcurves = [];
-        for (let i = 1; i < piece.pts.length; i++) {
-          const q = piece.pts[i];
-          const last = pts[pts.length - 1];
-          if (q[0] !== last[0] || q[1] !== last[1]) {
-            pts.push(q);
-            pdirs.push(piece.dirs[i - 1]);
-            pdraws.push(piece.draws[i - 1]);
-            pcurves.push(piece.curves[i - 1]);
-          }
-        }
+        const pts = piece.pts;
+        const pdirs = piece.dirs;
+        const pdraws = piece.draws;
+        const pcurves = piece.curves;
         outliner.open(pts, pdirs.length > 0 ? pdirs : [piece.dirs[0]], pdirs.length > 0 ? pdraws : [piece.draws[0]], pdirs.length > 0 ? pcurves : [piece.curves[0]], piece.startScale, piece.endScale);
       }
     } else if (closed && P.length >= 3) {
       outliner.closed(P, dirs, curves);
     } else if (closed && P.length === 2) {
-      outliner.open([P[0], P[1], P[0]]);
+      outliner.closed(P, dirs, curves);
     } else {
       outliner.open(P, void 0, dirs, curves);
     }
@@ -30705,11 +30754,17 @@ function penWidenOptions(rCtx, opts = {}) {
       join: opts.roundPen ? "round" : opts.rectangle && !state.penExtended ? "miter" : !state.penExtended || joinBits === 0 ? "round" : joinBits === 4096 ? "bevel" : "miter",
       miterLimit: state.miterLimit ?? 10,
       dashes: dashes ? dashes.map((v) => v * 16) : null,
-      shortenDashes: (flags & 15) !== 7
+      shortenDashes: (flags & 15) !== 7,
+      // Under a rotation the device vector is converted back to logical units for a square cap's extension.
+      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;
+  const nibWidth = uniform ? Math.max(1, Math.floor(widthPx + 0.5)) : widthPx;
   return {
-    width: Math.round((ellipse ? state.penWidth * Math.abs(matrix[0]) : widthPx) * 16),
+    width: Math.round((ellipse ? state.penWidth * Math.abs(matrix[0]) : nibWidth) * 16),
     ...ellipse ? { height: Math.round(state.penWidth * Math.abs(matrix[3]) * 16) } : {},
     cap: opts.roundPen || !state.penExtended || capBits === 0 ? "round" : capBits === 256 ? "square" : "flat",
     join: opts.roundPen ? "round" : opts.rectangle && !state.penExtended ? "miter" : !state.penExtended || joinBits === 0 ? "round" : joinBits === 4096 ? "bevel" : "miter",
@@ -30719,7 +30774,13 @@ function penWidenOptions(rCtx, opts = {}) {
     shortenDashes: (flags & 15) !== 7,
     // 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
+    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 ? {
+      cutToLogicalUnits: true,
+      logicalScale: ellipse ? [Math.abs(matrix[0]), Math.abs(matrix[3])] : Math.abs(matrix[0]),
+      // The pen rounds to whole pixels, but a square cap extends by half the unrounded width.
+      ...uniform ? { capWidth: state.penWidth * Math.abs(matrix[0]) * 16 } : {}
+    } : {}
   };
 }
 function hatchBackgroundMask(hatch) {
@@ -31210,6 +31271,21 @@ function foldIntoTile(v, origin, size, mirror2, lag) {
   }
   return origin + local;
 }
+function pixelAligned(boundary, m) {
+  let x0 = Infinity;
+  let y0 = Infinity;
+  let x1 = -Infinity;
+  let y1 = -Infinity;
+  for (const p of boundary) {
+    const x = m[0] * p.x + m[2] * p.y + m[4];
+    const y = m[1] * p.x + m[3] * p.y + m[5];
+    x0 = Math.min(x0, x);
+    y0 = Math.min(y0, y);
+    x1 = Math.max(x1, x);
+    y1 = Math.max(y1, y);
+  }
+  return [x0, y0, x1, y1].every((v) => Math.abs(v - Math.round(v)) < 1e-6);
+}
 function pathGradientSampler(shape, wrap, device) {
   const box = boundaryBox2(shape.boundary);
   const full = mulMatrix(device, shape.transform ?? IDENTITY4);
@@ -31217,6 +31293,10 @@ function pathGradientSampler(shape, wrap, device) {
   if (!box || !inv2) {
     return null;
   }
+  const anisotropicFocus = !!shape.focus && Math.abs(shape.focus.x - shape.focus.y) > 1e-9;
+  const uniformSurround = shape.boundaryArgb.every((color) => color === shape.boundaryArgb[0]);
+  const smooth = !uniformSurround && !shape.preset || anisotropicFocus || wrap !== "clamp" && !pixelAligned(shape.boundary, full);
+  const quantum = smooth ? 0 : pathGradientQuantum(shape.boundary, full);
   const pxX = Math.hypot(full[0], full[1]);
   const pxY = Math.hypot(full[2], full[3]);
   const lagX = pxX > 0 ? 1 / pxX : 0;
@@ -31236,8 +31316,8 @@ function pathGradientSampler(shape, wrap, device) {
           by = foldIntoTile(by, box.y, box.h, mirrorY, lagY);
         }
         if (wrap === "clamp" && by >= box.y + box.h) continue;
-        const focusPoint = bias && shape.focus?.x === 0 ? { x: bx - inv2[0] * bias, y: by - inv2[1] * bias } : void 0;
-        const c = pathGradientColorAt(shape, bx, by, focusPoint);
+        const focusPoint = bias ? { x: bx - inv2[0] * bias, y: by - inv2[1] * bias } : void 0;
+        const c = pathGradientColorAt(shape, bx, by, focusPoint, quantum);
         if (c === null) {
           continue;
         }
@@ -32011,8 +32091,14 @@ function handleRoundRect(rCtx, dataOff, recSize) {
     const cornerFixW = inset ? Math.abs(cornerW * devM[0]) * 16 : fixExtent(rCtx, cornerW, 0);
     const cornerFixH = inset ? Math.abs(cornerH * devM[3]) * 16 : fixExtent(rCtx, cornerH, 1);
     const cornerOnFrame = (fix, size, framedSize) => inset && size !== 0 ? Math.floor(Math.min(fix, size) * framedSize / size) : fix;
-    const cw = cornerOnFrame(cornerFixW, Math.abs((r - l) * devM[0]) * 16, Math.abs(framed.exx));
-    const ch = cornerOnFrame(cornerFixH, Math.abs((b - t) * devM[3]) * 16, Math.abs(framed.eyy));
+    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));
+    if (!inset && rCtx.state.penStyle !== 6 && cornerW !== 0 && cornerH !== 0 && Math.abs(devM[1]) < 1e-9 && Math.abs(devM[2]) < 1e-9 && rCtx.state.penStyle !== 5 && !penIsCosmetic(rCtx) && rCtx.state.worldTransform.every((v, i) => v === [1, 0, 0, 1, 0, 0][i])) {
+      const fullW = (Math.abs(r - l) + 1) * Math.abs(devM[0]) * 16;
+      const fullH = (Math.abs(b - t) + 1) * Math.abs(devM[3]) * 16;
+      cw = Math.floor(Math.min(cornerFixW, fullW) * Math.abs(framed.exx) / fullW);
+      ch = Math.floor(Math.min(cornerFixH, fullH) * Math.abs(framed.eyy) / fullH);
+    }
     const drawRoundRect = inset ? (c) => appendRoundRectPath(
       c,
       Math.min(framed.ax, framed.ax + framed.exx) / 16,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "emf-converter",
-	"version": "4.13.0",
+	"version": "4.15.0",
 	"description": "Convert EMF/WMF metafile binaries to PNG data URLs or SVG (markup, data URL, React/JSX)",
 	"keywords": [
 		"canvas",