emf-converter 4.6.3 → 4.6.5

package/dist/browser.js

@@ -15598,9 +15598,37 @@ function mix(c0, c1, f) {
     c0[3] + (c1[3] - c0[3]) * f
   ];
 }
+var f32Buffer = new Float32Array(1);
+var f32Bits = new Int32Array(f32Buffer.buffer);
+function truncF32(x) {
+  const r = Math.fround(x);
+  if (Math.abs(r) > Math.abs(x)) {
+    f32Buffer[0] = r;
+    f32Bits[0] -= 1;
+    return f32Buffer[0];
+  }
+  return r;
+}
+function blendFactor(positions, factors, t) {
+  const n = Math.min(positions.length, factors.length);
+  if (n === 0) {
+    return t;
+  }
+  if (t <= positions[0]) {
+    return factors[0];
+  }
+  for (let i = 1; i < n; i++) {
+    if (t <= positions[i]) {
+      const span = truncF32(positions[i] - positions[i - 1]);
+      const s = span > 0 ? truncF32(truncF32(t - positions[i - 1]) / span) : 1;
+      return truncF32(factors[i - 1] + truncF32(truncF32(factors[i] - factors[i - 1]) * s));
+    }
+  }
+  return factors[n - 1];
+}
 function mixBlend(c0, c1, f) {
-  const g = Math.fround(1 - f);
-  const ch = (a, b) => (Math.trunc(a * 256 * g) + Math.trunc(b * 256 * f)) / 256;
+  const g = truncF32(1 - f);
+  const ch = (a, b) => truncF32(truncF32(a * g) + truncF32(b * f));
   return [ch(c0[0], c1[0]), ch(c0[1], c1[1]), ch(c0[2], c1[2]), ch(c0[3], c1[3])];
 }
 function rampColorAt(ramp, t) {
@@ -15623,7 +15651,7 @@ function rampColorAt(ramp, t) {
   const start = premultiplied(ramp.startArgb, gamma);
   const end = premultiplied(ramp.endArgb, gamma);
   if (ramp.blend && !gamma) {
-    return mixBlend(start, end, piecewise(ramp.blend.positions, ramp.blend.factors, t));
+    return mixBlend(start, end, blendFactor(ramp.blend.positions, ramp.blend.factors, t));
   }
   return mix(start, end, ramp.blend ? piecewise(ramp.blend.positions, ramp.blend.factors, t) : t);
 }
@@ -31344,42 +31372,77 @@ function halftoneDespeckle(px, w, h) {
   const src = px.slice();
   const at = (x, y, c) => src[(y * w + x) * 3 + c];
   const over = (v) => v < -SPECKLE_OVERSHOOT * 4 || v > (255 + SPECKLE_OVERSHOOT) * 4;
+  const loneX = w > 2 && w % 2 === 1 ? w - 1 : -1;
+  const loneY = h > 2 && h % 2 === 1 ? h - 1 : -1;
+  const mirror2 = (i, n, d) => {
+    const j = i + d;
+    return j < 0 || j >= n ? i - d : j;
+  };
+  const vBlur = (x, y, c) => at(x, mirror2(y, h, -1), c) + 2 * at(x, y, c) + at(x, mirror2(y, h, 1), c) + 2 >> 2;
+  const hBlur = (x, y, c) => at(mirror2(x, w, -1), y, c) + 2 * at(x, y, c) + at(mirror2(x, w, 1), y, c) + 2 >> 2;
+  const differs = (x0, y0, x1, y1) => at(x0, y0, 0) !== at(x1, y1, 0) || at(x0, y0, 1) !== at(x1, y1, 1) || at(x0, y0, 2) !== at(x1, y1, 2);
+  const loneColumn = (y) => loneX > 0 && differs(loneX, y, loneX - 1, y);
+  const loneRow = (x) => loneY > 0 && differs(x, loneY, x, loneY - 1);
+  const loneColumnValue = (y, c) => y === loneY && loneRow(loneX) ? at(loneX, y - 1, c) + 3 * at(loneX, y, c) + 2 >> 2 : vBlur(loneX, y, c);
+  const loneRowValue = (x, c) => x === loneX && loneColumn(loneY) ? at(x - 1, loneY, c) + 3 * at(x, loneY, c) + 2 >> 2 : hBlur(x, loneY, c);
+  const speckled = (x, y) => {
+    const up = mirror2(y, h, -1);
+    const down = mirror2(y, h, 1);
+    const left = mirror2(x, w, -1);
+    const right = mirror2(x, w, 1);
+    let hClip = 0;
+    let vClip = 0;
+    let alternating = 0;
+    for (let c = 0; c < 3; c++) {
+      const v = at(x, y, c);
+      const axial = Math.max(
+        Math.abs(v - at(left, y, c)),
+        Math.abs(v - at(right, y, c)),
+        Math.abs(v - at(x, up, c)),
+        Math.abs(v - at(x, down, c))
+      );
+      const diagonal = Math.min(
+        Math.abs(v - at(left, up, c)),
+        Math.abs(v - at(right, up, c)),
+        Math.abs(v - at(left, down, c)),
+        Math.abs(v - at(right, down, c))
+      );
+      if (diagonal < axial) alternating++;
+      if (over(6 * v - at(left, y, c) - at(right, y, c))) {
+        hClip++;
+      }
+      if (over(6 * v - at(x, up, c) - at(x, down, c))) {
+        vClip++;
+      }
+    }
+    return hClip >= 2 && vClip >= 2 && alternating >= 2;
+  };
   for (let y = 0; y < h; y++) {
-    const up = y > 0 ? y - 1 : Math.min(h - 1, y + 1);
-    const down = y < h - 1 ? y + 1 : Math.max(0, y - 1);
     for (let x = 0; x < w; x++) {
-      const left = x > 0 ? x - 1 : Math.min(w - 1, x + 1);
-      const right = x < w - 1 ? x + 1 : Math.max(0, x - 1);
-      let hClip = 0;
-      let vClip = 0;
-      let alternating = 0;
-      for (let c = 0; c < 3; c++) {
-        const v = at(x, y, c);
-        const axial = Math.max(
-          Math.abs(v - at(left, y, c)),
-          Math.abs(v - at(right, y, c)),
-          Math.abs(v - at(x, up, c)),
-          Math.abs(v - at(x, down, c))
-        );
-        const diagonal = Math.min(
-          Math.abs(v - at(left, up, c)),
-          Math.abs(v - at(right, up, c)),
-          Math.abs(v - at(left, down, c)),
-          Math.abs(v - at(right, down, c))
-        );
-        if (diagonal < axial) alternating++;
-        if (over(6 * v - at(left, y, c) - at(right, y, c))) {
-          hClip++;
-        }
-        if (over(6 * v - at(x, up, c) - at(x, down, c))) {
-          vClip++;
-        }
-      }
-      if (hClip < 2 || vClip < 2 || alternating < 2) {
+      if (!speckled(x, y)) {
         continue;
       }
+      const left = mirror2(x, w, -1);
+      const right = mirror2(x, w, 1);
+      const up = mirror2(y, h, -1);
+      const down = mirror2(y, h, 1);
+      const lonelyColumn = x === loneX && loneColumn(y);
+      const lonelyRow = y === loneY && loneRow(x);
+      const nearLoneX = x === loneX - 1 && loneX > 0 && loneColumn(y) && !speckled(loneX, y);
+      const nearLoneY = y === loneY - 1 && loneY > 0 && loneRow(x) && !speckled(x, loneY);
+      const cornerRepeats = lonelyColumn && lonelyRow && (!speckled(x, y - 1) || !speckled(x - 1, y));
       for (let c = 0; c < 3; c++) {
-        px[(y * w + x) * 3 + c] = at(left, y, c) + 2 * at(x, y, c) + at(right, y, c) + 2 >> 2;
+        const v = at(x, y, c);
+        let r;
+        if (lonelyColumn && lonelyRow) {
+          r = cornerRepeats ? at(left, y, c) + 3 * v + 2 >> 2 : hBlur(x, y, c);
+        } else {
+          let sum = lonelyColumn ? at(x, up, c) + 2 * v + at(x, down, c) : at(left, y, c) + 2 * v + at(right, y, c);
+          if (nearLoneX) sum += loneColumnValue(y, c) - at(loneX, y, c);
+          if (nearLoneY) sum += loneRowValue(x, c) - at(x, loneY, c);
+          r = sum + 2 >> 2;
+        }
+        px[(y * w + x) * 3 + c] = r;
       }
     }
   }

package/dist/browser.mjs

@@ -15596,9 +15596,37 @@ function mix(c0, c1, f) {
     c0[3] + (c1[3] - c0[3]) * f
   ];
 }
+var f32Buffer = new Float32Array(1);
+var f32Bits = new Int32Array(f32Buffer.buffer);
+function truncF32(x) {
+  const r = Math.fround(x);
+  if (Math.abs(r) > Math.abs(x)) {
+    f32Buffer[0] = r;
+    f32Bits[0] -= 1;
+    return f32Buffer[0];
+  }
+  return r;
+}
+function blendFactor(positions, factors, t) {
+  const n = Math.min(positions.length, factors.length);
+  if (n === 0) {
+    return t;
+  }
+  if (t <= positions[0]) {
+    return factors[0];
+  }
+  for (let i = 1; i < n; i++) {
+    if (t <= positions[i]) {
+      const span = truncF32(positions[i] - positions[i - 1]);
+      const s = span > 0 ? truncF32(truncF32(t - positions[i - 1]) / span) : 1;
+      return truncF32(factors[i - 1] + truncF32(truncF32(factors[i] - factors[i - 1]) * s));
+    }
+  }
+  return factors[n - 1];
+}
 function mixBlend(c0, c1, f) {
-  const g = Math.fround(1 - f);
-  const ch = (a, b) => (Math.trunc(a * 256 * g) + Math.trunc(b * 256 * f)) / 256;
+  const g = truncF32(1 - f);
+  const ch = (a, b) => truncF32(truncF32(a * g) + truncF32(b * f));
   return [ch(c0[0], c1[0]), ch(c0[1], c1[1]), ch(c0[2], c1[2]), ch(c0[3], c1[3])];
 }
 function rampColorAt(ramp, t) {
@@ -15621,7 +15649,7 @@ function rampColorAt(ramp, t) {
   const start = premultiplied(ramp.startArgb, gamma);
   const end = premultiplied(ramp.endArgb, gamma);
   if (ramp.blend && !gamma) {
-    return mixBlend(start, end, piecewise(ramp.blend.positions, ramp.blend.factors, t));
+    return mixBlend(start, end, blendFactor(ramp.blend.positions, ramp.blend.factors, t));
   }
   return mix(start, end, ramp.blend ? piecewise(ramp.blend.positions, ramp.blend.factors, t) : t);
 }
@@ -31342,42 +31370,77 @@ function halftoneDespeckle(px, w, h) {
   const src = px.slice();
   const at = (x, y, c) => src[(y * w + x) * 3 + c];
   const over = (v) => v < -SPECKLE_OVERSHOOT * 4 || v > (255 + SPECKLE_OVERSHOOT) * 4;
+  const loneX = w > 2 && w % 2 === 1 ? w - 1 : -1;
+  const loneY = h > 2 && h % 2 === 1 ? h - 1 : -1;
+  const mirror2 = (i, n, d) => {
+    const j = i + d;
+    return j < 0 || j >= n ? i - d : j;
+  };
+  const vBlur = (x, y, c) => at(x, mirror2(y, h, -1), c) + 2 * at(x, y, c) + at(x, mirror2(y, h, 1), c) + 2 >> 2;
+  const hBlur = (x, y, c) => at(mirror2(x, w, -1), y, c) + 2 * at(x, y, c) + at(mirror2(x, w, 1), y, c) + 2 >> 2;
+  const differs = (x0, y0, x1, y1) => at(x0, y0, 0) !== at(x1, y1, 0) || at(x0, y0, 1) !== at(x1, y1, 1) || at(x0, y0, 2) !== at(x1, y1, 2);
+  const loneColumn = (y) => loneX > 0 && differs(loneX, y, loneX - 1, y);
+  const loneRow = (x) => loneY > 0 && differs(x, loneY, x, loneY - 1);
+  const loneColumnValue = (y, c) => y === loneY && loneRow(loneX) ? at(loneX, y - 1, c) + 3 * at(loneX, y, c) + 2 >> 2 : vBlur(loneX, y, c);
+  const loneRowValue = (x, c) => x === loneX && loneColumn(loneY) ? at(x - 1, loneY, c) + 3 * at(x, loneY, c) + 2 >> 2 : hBlur(x, loneY, c);
+  const speckled = (x, y) => {
+    const up = mirror2(y, h, -1);
+    const down = mirror2(y, h, 1);
+    const left = mirror2(x, w, -1);
+    const right = mirror2(x, w, 1);
+    let hClip = 0;
+    let vClip = 0;
+    let alternating = 0;
+    for (let c = 0; c < 3; c++) {
+      const v = at(x, y, c);
+      const axial = Math.max(
+        Math.abs(v - at(left, y, c)),
+        Math.abs(v - at(right, y, c)),
+        Math.abs(v - at(x, up, c)),
+        Math.abs(v - at(x, down, c))
+      );
+      const diagonal = Math.min(
+        Math.abs(v - at(left, up, c)),
+        Math.abs(v - at(right, up, c)),
+        Math.abs(v - at(left, down, c)),
+        Math.abs(v - at(right, down, c))
+      );
+      if (diagonal < axial) alternating++;
+      if (over(6 * v - at(left, y, c) - at(right, y, c))) {
+        hClip++;
+      }
+      if (over(6 * v - at(x, up, c) - at(x, down, c))) {
+        vClip++;
+      }
+    }
+    return hClip >= 2 && vClip >= 2 && alternating >= 2;
+  };
   for (let y = 0; y < h; y++) {
-    const up = y > 0 ? y - 1 : Math.min(h - 1, y + 1);
-    const down = y < h - 1 ? y + 1 : Math.max(0, y - 1);
     for (let x = 0; x < w; x++) {
-      const left = x > 0 ? x - 1 : Math.min(w - 1, x + 1);
-      const right = x < w - 1 ? x + 1 : Math.max(0, x - 1);
-      let hClip = 0;
-      let vClip = 0;
-      let alternating = 0;
-      for (let c = 0; c < 3; c++) {
-        const v = at(x, y, c);
-        const axial = Math.max(
-          Math.abs(v - at(left, y, c)),
-          Math.abs(v - at(right, y, c)),
-          Math.abs(v - at(x, up, c)),
-          Math.abs(v - at(x, down, c))
-        );
-        const diagonal = Math.min(
-          Math.abs(v - at(left, up, c)),
-          Math.abs(v - at(right, up, c)),
-          Math.abs(v - at(left, down, c)),
-          Math.abs(v - at(right, down, c))
-        );
-        if (diagonal < axial) alternating++;
-        if (over(6 * v - at(left, y, c) - at(right, y, c))) {
-          hClip++;
-        }
-        if (over(6 * v - at(x, up, c) - at(x, down, c))) {
-          vClip++;
-        }
-      }
-      if (hClip < 2 || vClip < 2 || alternating < 2) {
+      if (!speckled(x, y)) {
         continue;
       }
+      const left = mirror2(x, w, -1);
+      const right = mirror2(x, w, 1);
+      const up = mirror2(y, h, -1);
+      const down = mirror2(y, h, 1);
+      const lonelyColumn = x === loneX && loneColumn(y);
+      const lonelyRow = y === loneY && loneRow(x);
+      const nearLoneX = x === loneX - 1 && loneX > 0 && loneColumn(y) && !speckled(loneX, y);
+      const nearLoneY = y === loneY - 1 && loneY > 0 && loneRow(x) && !speckled(x, loneY);
+      const cornerRepeats = lonelyColumn && lonelyRow && (!speckled(x, y - 1) || !speckled(x - 1, y));
       for (let c = 0; c < 3; c++) {
-        px[(y * w + x) * 3 + c] = at(left, y, c) + 2 * at(x, y, c) + at(right, y, c) + 2 >> 2;
+        const v = at(x, y, c);
+        let r;
+        if (lonelyColumn && lonelyRow) {
+          r = cornerRepeats ? at(left, y, c) + 3 * v + 2 >> 2 : hBlur(x, y, c);
+        } else {
+          let sum = lonelyColumn ? at(x, up, c) + 2 * v + at(x, down, c) : at(left, y, c) + 2 * v + at(right, y, c);
+          if (nearLoneX) sum += loneColumnValue(y, c) - at(loneX, y, c);
+          if (nearLoneY) sum += loneRowValue(x, c) - at(x, loneY, c);
+          r = sum + 2 >> 2;
+        }
+        px[(y * w + x) * 3 + c] = r;
       }
     }
   }

package/dist/index.js

@@ -15599,9 +15599,37 @@ function mix(c0, c1, f) {
     c0[3] + (c1[3] - c0[3]) * f
   ];
 }
+var f32Buffer = new Float32Array(1);
+var f32Bits = new Int32Array(f32Buffer.buffer);
+function truncF32(x) {
+  const r = Math.fround(x);
+  if (Math.abs(r) > Math.abs(x)) {
+    f32Buffer[0] = r;
+    f32Bits[0] -= 1;
+    return f32Buffer[0];
+  }
+  return r;
+}
+function blendFactor(positions, factors, t) {
+  const n = Math.min(positions.length, factors.length);
+  if (n === 0) {
+    return t;
+  }
+  if (t <= positions[0]) {
+    return factors[0];
+  }
+  for (let i = 1; i < n; i++) {
+    if (t <= positions[i]) {
+      const span = truncF32(positions[i] - positions[i - 1]);
+      const s = span > 0 ? truncF32(truncF32(t - positions[i - 1]) / span) : 1;
+      return truncF32(factors[i - 1] + truncF32(truncF32(factors[i] - factors[i - 1]) * s));
+    }
+  }
+  return factors[n - 1];
+}
 function mixBlend(c0, c1, f) {
-  const g = Math.fround(1 - f);
-  const ch = (a, b) => (Math.trunc(a * 256 * g) + Math.trunc(b * 256 * f)) / 256;
+  const g = truncF32(1 - f);
+  const ch = (a, b) => truncF32(truncF32(a * g) + truncF32(b * f));
   return [ch(c0[0], c1[0]), ch(c0[1], c1[1]), ch(c0[2], c1[2]), ch(c0[3], c1[3])];
 }
 function rampColorAt(ramp, t) {
@@ -15624,7 +15652,7 @@ function rampColorAt(ramp, t) {
   const start = premultiplied(ramp.startArgb, gamma);
   const end = premultiplied(ramp.endArgb, gamma);
   if (ramp.blend && !gamma) {
-    return mixBlend(start, end, piecewise(ramp.blend.positions, ramp.blend.factors, t));
+    return mixBlend(start, end, blendFactor(ramp.blend.positions, ramp.blend.factors, t));
   }
   return mix(start, end, ramp.blend ? piecewise(ramp.blend.positions, ramp.blend.factors, t) : t);
 }
@@ -31345,42 +31373,77 @@ function halftoneDespeckle(px, w, h) {
   const src = px.slice();
   const at = (x, y, c) => src[(y * w + x) * 3 + c];
   const over = (v) => v < -SPECKLE_OVERSHOOT * 4 || v > (255 + SPECKLE_OVERSHOOT) * 4;
+  const loneX = w > 2 && w % 2 === 1 ? w - 1 : -1;
+  const loneY = h > 2 && h % 2 === 1 ? h - 1 : -1;
+  const mirror2 = (i, n, d) => {
+    const j = i + d;
+    return j < 0 || j >= n ? i - d : j;
+  };
+  const vBlur = (x, y, c) => at(x, mirror2(y, h, -1), c) + 2 * at(x, y, c) + at(x, mirror2(y, h, 1), c) + 2 >> 2;
+  const hBlur = (x, y, c) => at(mirror2(x, w, -1), y, c) + 2 * at(x, y, c) + at(mirror2(x, w, 1), y, c) + 2 >> 2;
+  const differs = (x0, y0, x1, y1) => at(x0, y0, 0) !== at(x1, y1, 0) || at(x0, y0, 1) !== at(x1, y1, 1) || at(x0, y0, 2) !== at(x1, y1, 2);
+  const loneColumn = (y) => loneX > 0 && differs(loneX, y, loneX - 1, y);
+  const loneRow = (x) => loneY > 0 && differs(x, loneY, x, loneY - 1);
+  const loneColumnValue = (y, c) => y === loneY && loneRow(loneX) ? at(loneX, y - 1, c) + 3 * at(loneX, y, c) + 2 >> 2 : vBlur(loneX, y, c);
+  const loneRowValue = (x, c) => x === loneX && loneColumn(loneY) ? at(x - 1, loneY, c) + 3 * at(x, loneY, c) + 2 >> 2 : hBlur(x, loneY, c);
+  const speckled = (x, y) => {
+    const up = mirror2(y, h, -1);
+    const down = mirror2(y, h, 1);
+    const left = mirror2(x, w, -1);
+    const right = mirror2(x, w, 1);
+    let hClip = 0;
+    let vClip = 0;
+    let alternating = 0;
+    for (let c = 0; c < 3; c++) {
+      const v = at(x, y, c);
+      const axial = Math.max(
+        Math.abs(v - at(left, y, c)),
+        Math.abs(v - at(right, y, c)),
+        Math.abs(v - at(x, up, c)),
+        Math.abs(v - at(x, down, c))
+      );
+      const diagonal = Math.min(
+        Math.abs(v - at(left, up, c)),
+        Math.abs(v - at(right, up, c)),
+        Math.abs(v - at(left, down, c)),
+        Math.abs(v - at(right, down, c))
+      );
+      if (diagonal < axial) alternating++;
+      if (over(6 * v - at(left, y, c) - at(right, y, c))) {
+        hClip++;
+      }
+      if (over(6 * v - at(x, up, c) - at(x, down, c))) {
+        vClip++;
+      }
+    }
+    return hClip >= 2 && vClip >= 2 && alternating >= 2;
+  };
   for (let y = 0; y < h; y++) {
-    const up = y > 0 ? y - 1 : Math.min(h - 1, y + 1);
-    const down = y < h - 1 ? y + 1 : Math.max(0, y - 1);
     for (let x = 0; x < w; x++) {
-      const left = x > 0 ? x - 1 : Math.min(w - 1, x + 1);
-      const right = x < w - 1 ? x + 1 : Math.max(0, x - 1);
-      let hClip = 0;
-      let vClip = 0;
-      let alternating = 0;
-      for (let c = 0; c < 3; c++) {
-        const v = at(x, y, c);
-        const axial = Math.max(
-          Math.abs(v - at(left, y, c)),
-          Math.abs(v - at(right, y, c)),
-          Math.abs(v - at(x, up, c)),
-          Math.abs(v - at(x, down, c))
-        );
-        const diagonal = Math.min(
-          Math.abs(v - at(left, up, c)),
-          Math.abs(v - at(right, up, c)),
-          Math.abs(v - at(left, down, c)),
-          Math.abs(v - at(right, down, c))
-        );
-        if (diagonal < axial) alternating++;
-        if (over(6 * v - at(left, y, c) - at(right, y, c))) {
-          hClip++;
-        }
-        if (over(6 * v - at(x, up, c) - at(x, down, c))) {
-          vClip++;
-        }
-      }
-      if (hClip < 2 || vClip < 2 || alternating < 2) {
+      if (!speckled(x, y)) {
         continue;
       }
+      const left = mirror2(x, w, -1);
+      const right = mirror2(x, w, 1);
+      const up = mirror2(y, h, -1);
+      const down = mirror2(y, h, 1);
+      const lonelyColumn = x === loneX && loneColumn(y);
+      const lonelyRow = y === loneY && loneRow(x);
+      const nearLoneX = x === loneX - 1 && loneX > 0 && loneColumn(y) && !speckled(loneX, y);
+      const nearLoneY = y === loneY - 1 && loneY > 0 && loneRow(x) && !speckled(x, loneY);
+      const cornerRepeats = lonelyColumn && lonelyRow && (!speckled(x, y - 1) || !speckled(x - 1, y));
       for (let c = 0; c < 3; c++) {
-        px[(y * w + x) * 3 + c] = at(left, y, c) + 2 * at(x, y, c) + at(right, y, c) + 2 >> 2;
+        const v = at(x, y, c);
+        let r;
+        if (lonelyColumn && lonelyRow) {
+          r = cornerRepeats ? at(left, y, c) + 3 * v + 2 >> 2 : hBlur(x, y, c);
+        } else {
+          let sum = lonelyColumn ? at(x, up, c) + 2 * v + at(x, down, c) : at(left, y, c) + 2 * v + at(right, y, c);
+          if (nearLoneX) sum += loneColumnValue(y, c) - at(loneX, y, c);
+          if (nearLoneY) sum += loneRowValue(x, c) - at(x, loneY, c);
+          r = sum + 2 >> 2;
+        }
+        px[(y * w + x) * 3 + c] = r;
       }
     }
   }

package/dist/index.mjs

@@ -15597,9 +15597,37 @@ function mix(c0, c1, f) {
     c0[3] + (c1[3] - c0[3]) * f
   ];
 }
+var f32Buffer = new Float32Array(1);
+var f32Bits = new Int32Array(f32Buffer.buffer);
+function truncF32(x) {
+  const r = Math.fround(x);
+  if (Math.abs(r) > Math.abs(x)) {
+    f32Buffer[0] = r;
+    f32Bits[0] -= 1;
+    return f32Buffer[0];
+  }
+  return r;
+}
+function blendFactor(positions, factors, t) {
+  const n = Math.min(positions.length, factors.length);
+  if (n === 0) {
+    return t;
+  }
+  if (t <= positions[0]) {
+    return factors[0];
+  }
+  for (let i = 1; i < n; i++) {
+    if (t <= positions[i]) {
+      const span = truncF32(positions[i] - positions[i - 1]);
+      const s = span > 0 ? truncF32(truncF32(t - positions[i - 1]) / span) : 1;
+      return truncF32(factors[i - 1] + truncF32(truncF32(factors[i] - factors[i - 1]) * s));
+    }
+  }
+  return factors[n - 1];
+}
 function mixBlend(c0, c1, f) {
-  const g = Math.fround(1 - f);
-  const ch = (a, b) => (Math.trunc(a * 256 * g) + Math.trunc(b * 256 * f)) / 256;
+  const g = truncF32(1 - f);
+  const ch = (a, b) => truncF32(truncF32(a * g) + truncF32(b * f));
   return [ch(c0[0], c1[0]), ch(c0[1], c1[1]), ch(c0[2], c1[2]), ch(c0[3], c1[3])];
 }
 function rampColorAt(ramp, t) {
@@ -15622,7 +15650,7 @@ function rampColorAt(ramp, t) {
   const start = premultiplied(ramp.startArgb, gamma);
   const end = premultiplied(ramp.endArgb, gamma);
   if (ramp.blend && !gamma) {
-    return mixBlend(start, end, piecewise(ramp.blend.positions, ramp.blend.factors, t));
+    return mixBlend(start, end, blendFactor(ramp.blend.positions, ramp.blend.factors, t));
   }
   return mix(start, end, ramp.blend ? piecewise(ramp.blend.positions, ramp.blend.factors, t) : t);
 }
@@ -31343,42 +31371,77 @@ function halftoneDespeckle(px, w, h) {
   const src = px.slice();
   const at = (x, y, c) => src[(y * w + x) * 3 + c];
   const over = (v) => v < -SPECKLE_OVERSHOOT * 4 || v > (255 + SPECKLE_OVERSHOOT) * 4;
+  const loneX = w > 2 && w % 2 === 1 ? w - 1 : -1;
+  const loneY = h > 2 && h % 2 === 1 ? h - 1 : -1;
+  const mirror2 = (i, n, d) => {
+    const j = i + d;
+    return j < 0 || j >= n ? i - d : j;
+  };
+  const vBlur = (x, y, c) => at(x, mirror2(y, h, -1), c) + 2 * at(x, y, c) + at(x, mirror2(y, h, 1), c) + 2 >> 2;
+  const hBlur = (x, y, c) => at(mirror2(x, w, -1), y, c) + 2 * at(x, y, c) + at(mirror2(x, w, 1), y, c) + 2 >> 2;
+  const differs = (x0, y0, x1, y1) => at(x0, y0, 0) !== at(x1, y1, 0) || at(x0, y0, 1) !== at(x1, y1, 1) || at(x0, y0, 2) !== at(x1, y1, 2);
+  const loneColumn = (y) => loneX > 0 && differs(loneX, y, loneX - 1, y);
+  const loneRow = (x) => loneY > 0 && differs(x, loneY, x, loneY - 1);
+  const loneColumnValue = (y, c) => y === loneY && loneRow(loneX) ? at(loneX, y - 1, c) + 3 * at(loneX, y, c) + 2 >> 2 : vBlur(loneX, y, c);
+  const loneRowValue = (x, c) => x === loneX && loneColumn(loneY) ? at(x - 1, loneY, c) + 3 * at(x, loneY, c) + 2 >> 2 : hBlur(x, loneY, c);
+  const speckled = (x, y) => {
+    const up = mirror2(y, h, -1);
+    const down = mirror2(y, h, 1);
+    const left = mirror2(x, w, -1);
+    const right = mirror2(x, w, 1);
+    let hClip = 0;
+    let vClip = 0;
+    let alternating = 0;
+    for (let c = 0; c < 3; c++) {
+      const v = at(x, y, c);
+      const axial = Math.max(
+        Math.abs(v - at(left, y, c)),
+        Math.abs(v - at(right, y, c)),
+        Math.abs(v - at(x, up, c)),
+        Math.abs(v - at(x, down, c))
+      );
+      const diagonal = Math.min(
+        Math.abs(v - at(left, up, c)),
+        Math.abs(v - at(right, up, c)),
+        Math.abs(v - at(left, down, c)),
+        Math.abs(v - at(right, down, c))
+      );
+      if (diagonal < axial) alternating++;
+      if (over(6 * v - at(left, y, c) - at(right, y, c))) {
+        hClip++;
+      }
+      if (over(6 * v - at(x, up, c) - at(x, down, c))) {
+        vClip++;
+      }
+    }
+    return hClip >= 2 && vClip >= 2 && alternating >= 2;
+  };
   for (let y = 0; y < h; y++) {
-    const up = y > 0 ? y - 1 : Math.min(h - 1, y + 1);
-    const down = y < h - 1 ? y + 1 : Math.max(0, y - 1);
     for (let x = 0; x < w; x++) {
-      const left = x > 0 ? x - 1 : Math.min(w - 1, x + 1);
-      const right = x < w - 1 ? x + 1 : Math.max(0, x - 1);
-      let hClip = 0;
-      let vClip = 0;
-      let alternating = 0;
-      for (let c = 0; c < 3; c++) {
-        const v = at(x, y, c);
-        const axial = Math.max(
-          Math.abs(v - at(left, y, c)),
-          Math.abs(v - at(right, y, c)),
-          Math.abs(v - at(x, up, c)),
-          Math.abs(v - at(x, down, c))
-        );
-        const diagonal = Math.min(
-          Math.abs(v - at(left, up, c)),
-          Math.abs(v - at(right, up, c)),
-          Math.abs(v - at(left, down, c)),
-          Math.abs(v - at(right, down, c))
-        );
-        if (diagonal < axial) alternating++;
-        if (over(6 * v - at(left, y, c) - at(right, y, c))) {
-          hClip++;
-        }
-        if (over(6 * v - at(x, up, c) - at(x, down, c))) {
-          vClip++;
-        }
-      }
-      if (hClip < 2 || vClip < 2 || alternating < 2) {
+      if (!speckled(x, y)) {
         continue;
       }
+      const left = mirror2(x, w, -1);
+      const right = mirror2(x, w, 1);
+      const up = mirror2(y, h, -1);
+      const down = mirror2(y, h, 1);
+      const lonelyColumn = x === loneX && loneColumn(y);
+      const lonelyRow = y === loneY && loneRow(x);
+      const nearLoneX = x === loneX - 1 && loneX > 0 && loneColumn(y) && !speckled(loneX, y);
+      const nearLoneY = y === loneY - 1 && loneY > 0 && loneRow(x) && !speckled(x, loneY);
+      const cornerRepeats = lonelyColumn && lonelyRow && (!speckled(x, y - 1) || !speckled(x - 1, y));
       for (let c = 0; c < 3; c++) {
-        px[(y * w + x) * 3 + c] = at(left, y, c) + 2 * at(x, y, c) + at(right, y, c) + 2 >> 2;
+        const v = at(x, y, c);
+        let r;
+        if (lonelyColumn && lonelyRow) {
+          r = cornerRepeats ? at(left, y, c) + 3 * v + 2 >> 2 : hBlur(x, y, c);
+        } else {
+          let sum = lonelyColumn ? at(x, up, c) + 2 * v + at(x, down, c) : at(left, y, c) + 2 * v + at(right, y, c);
+          if (nearLoneX) sum += loneColumnValue(y, c) - at(loneX, y, c);
+          if (nearLoneY) sum += loneRowValue(x, c) - at(x, loneY, c);
+          r = sum + 2 >> 2;
+        }
+        px[(y * w + x) * 3 + c] = r;
       }
     }
   }

package/package.json

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