emf-converter 4.14.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;
@@ -31225,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);
@@ -31232,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;
@@ -31251,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;
         }

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;
@@ -31223,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);
@@ -31230,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;
@@ -31249,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;
         }

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;
@@ -31226,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);
@@ -31233,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;
@@ -31252,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;
         }

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;
@@ -31224,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);
@@ -31231,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;
@@ -31250,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;
         }

package/package.json

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