npm - emf-converter - Versions diffs - 4.6.8 → 4.6.9 - Mend

emf-converter 4.6.8 → 4.6.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/dist/browser.js CHANGED Viewed

@@ -16485,11 +16485,11 @@ function mirror(p, n) {
   }
   return p;
 }
-function gdipBlur(src, w, h, radius, vRow = 0, vZeroAbove = false, fullVertical = false, edgeWidth = w, edgeHeight = h, verticalRows = Math.ceil(h / w)) {
+function gdipBlur(src, w, h, radius, vRow = 0, vZeroAbove = false, verticalRows = Math.ceil(h / w)) {
   const k = blurKernel(radius);
   const taps = (k.length - 1) / 2;
-  const horizontalIndex = taps >= edgeWidth ? (x) => Math.max(0, Math.min(w - 1, x)) : (x) => mirror(x, w);
-  const verticalIndex = taps >= edgeHeight ? (y) => Math.max(0, Math.min(h - 1, y)) : (y) => mirror(y, h);
+  const horizontalIndex = taps >= w ? (x) => Math.max(0, Math.min(w - 1, x)) : (x) => mirror(x, w);
+  const verticalIndex = taps >= h ? (y) => Math.max(0, Math.min(h - 1, y)) : (y) => mirror(y, h);
   const out = new Float64Array(w * h * 4);
   for (let y = 0; y < h; y++) {
     const row2 = y * w * 4;
@@ -16500,22 +16500,22 @@ function gdipBlur(src, w, h, radius, vRow = 0, vZeroAbove = false, fullVertical
       let s3 = 0;
       for (let j = -taps; j <= taps; j++) {
         const p = row2 + horizontalIndex(x + j) * 4;
-        const kw = k[j + taps];
-        s0 += kw * src[p];
-        s1 += kw * src[p + 1];
-        s2 += kw * src[p + 2];
-        s3 += kw * src[p + 3];
+        const kw = k[j + taps] * 256;
+        s0 += Math.round(kw * src[p]);
+        s1 += Math.round(kw * src[p + 1]);
+        s2 += Math.round(kw * src[p + 2]);
+        s3 += Math.round(kw * src[p + 3]);
       }
       const o = row2 + x * 4;
-      out[o] = Math.round(s0);
-      out[o + 1] = Math.round(s1);
-      out[o + 2] = Math.round(s2);
-      out[o + 3] = Math.round(s3);
+      out[o] = Math.floor((s0 + 128) / 256);
+      out[o + 1] = Math.floor((s1 + 128) / 256);
+      out[o + 2] = Math.floor((s2 + 128) / 256);
+      out[o + 3] = Math.floor((s3 + 128) / 256);
     }
   }
   if (taps > 0 && vRow >= 0 && vRow < h) {
     const horizontal = out.slice();
-    const endRow = fullVertical ? h : Math.min(h, vRow + verticalRows);
+    const endRow = Math.min(h, vRow + verticalRows);
     for (let row2 = vRow; row2 < endRow; row2++) {
       const col = new Float64Array(w * 4);
       for (let j = -taps; j <= taps; j++) {
@@ -16525,7 +16525,7 @@ function gdipBlur(src, w, h, radius, vRow = 0, vZeroAbove = false, fullVertical
         }
         const base = verticalIndex(yy) * w * 4;
         for (let i = 0; i < w * 4; i++) {
-          col[i] += k[j + taps] * horizontal[base + i];
+          col[i] += Math.round(k[j + taps] * horizontal[base + i] * 256) / 256;
         }
       }
       out.set(col, row2 * w * 4);
@@ -16536,48 +16536,56 @@ function gdipBlur(src, w, h, radius, vRow = 0, vZeroAbove = false, fullVertical
 function blurReduction(radius) {
   return radius < 20 ? 1 : radius < 40 ? 2 : radius <= 80 ? 4 : radius < 160 ? 8 : 16;
 }
-function effectBlur(src, width, height, radius, expanded = false) {
-  const factor = blurReduction(radius);
-  if (factor === 1 || (width < 4 || height < 4) && (width % factor !== 0 || height % factor !== 0)) {
-    return gdipBlur(src, width, height, radius);
-  }
-  const w = Math.ceil(width / factor);
-  const h = Math.ceil(height / factor);
-  const reduced = new Uint8ClampedArray(w * h * 4);
-  for (let y = 0; y < h; y++) for (let x = 0; x < w; x++) {
-    const x1 = Math.min(width, (x + 1) * factor), y1 = Math.min(height, (y + 1) * factor);
-    const count = (x1 - x * factor) * (y1 - y * factor);
-    for (let c = 0; c < 4; c++) {
+function blurAxis(length, lanes, factor, k, edgeLength, get, put, span = { start: 0, size: length, pad: 0 }) {
+  const inner = Math.ceil(span.size / factor);
+  const n = inner + 2 * span.pad;
+  const taps = (k.length - 1) / 2;
+  const index = taps >= edgeLength ? (i) => clamp(i, 0, n - 1) : (i) => mirror(i, n);
+  const reduced = new Float64Array(n);
+  const filtered = new Float64Array(n);
+  const k256 = k.map((w) => w * 256);
+  for (let lane = 0; lane < lanes; lane++) for (let c = 0; c < 4; c++) {
+    for (let b = span.pad; b < span.pad + inner; b++) {
+      const from = span.start + (b - span.pad) * factor;
+      const end = Math.min(span.start + span.size, from + factor);
       let sum = 0;
-      for (let yy = y * factor; yy < y1; yy++) for (let xx = x * factor; xx < x1; xx++) sum += src[(yy * width + xx) * 4 + c];
-      reduced[(y * w + x) * 4 + c] = Math.floor(sum / count);
+      for (let i = from; i < end; i++) sum += get(i, lane, c);
+      reduced[b] = Math.floor(sum / (end - from));
     }
-  }
-  const filtered = gdipBlur(reduced, w, h, radius / factor, 0, false, true, Math.floor(width / factor), Math.floor(height / factor));
-  if (!expanded) {
-    const out2 = new Float64Array(src.length);
-    for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) {
-      const px = clamp((x + 0.5) / factor - 0.5, 0, w - 1), py = clamp((y + 0.5) / factor - 0.5, 0, h - 1);
-      const ix = Math.floor(px), iy = Math.floor(py), fx = px - ix, fy = py - iy;
-      const x1 = Math.min(w - 1, ix + 1), y1 = Math.min(h - 1, iy + 1);
-      for (let c = 0; c < 4; c++) {
-        const at = (xx, yy) => filtered[(yy * w + xx) * 4 + c];
-        const top = Math.floor((1 - fx) * at(ix, iy) + fx * at(x1, iy));
-        const bottom = Math.floor((1 - fx) * at(ix, y1) + fx * at(x1, y1));
-        out2[(y * width + x) * 4 + c] = Math.floor((1 - fy) * top + fy * bottom);
+    for (let b = 0; b < n; b++) {
+      let sum = 0;
+      if (b >= taps && b + taps < n) {
+        for (let j = 0; j < k256.length; j++) sum += Math.round(k256[j] * reduced[b - taps + j]);
+      } else {
+        for (let j = 0; j < k256.length; j++) sum += Math.round(k256[j] * reduced[index(b - taps + j)]);
       }
+      filtered[b] = Math.floor((sum + 128) / 256);
+    }
+    for (let i = 0; i < length; i++) {
+      const p = (i - span.start + 0.5) / factor - 0.5 + span.pad;
+      const a = clamp(Math.floor(p), 0, Math.max(0, n - 2));
+      const t = p - a;
+      put(i, lane, c, clamp(Math.floor((1 - t) * filtered[a] + t * filtered[Math.min(n - 1, a + 1)] + 1e-9), 0, 255));
     }
-    return out2;
   }
-  for (let i = 0; i < filtered.length; i++) filtered[i] = Math.round(filtered[i]);
-  const out = new Float64Array(src.length);
-  for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) {
-    const px = clamp((x + 0.5) / factor - 0.5, 0, w - 1), py = clamp((y + 0.5) / factor - 0.5, 0, h - 1);
-    const ix = Math.floor(px), iy = Math.floor(py), fx = px - ix, fy = py - iy;
-    const a = (iy * w + ix) * 4, b = (iy * w + Math.min(w - 1, ix + 1)) * 4;
-    const d = (Math.min(h - 1, iy + 1) * w + ix) * 4, e = (Math.min(h - 1, iy + 1) * w + Math.min(w - 1, ix + 1)) * 4;
-    for (let c = 0; c < 4; c++) out[(y * width + x) * 4 + c] = Math.round((1 - fy) * ((1 - fx) * filtered[a + c] + fx * filtered[b + c]) + fy * ((1 - fx) * filtered[d + c] + fx * filtered[e + c]));
+}
+function effectBlur(src, width, height, radius, region) {
+  const factor = blurReduction(radius);
+  if (factor === 1) {
+    return gdipBlur(src, width, height, radius);
   }
+  const k = blurKernel(radius / factor);
+  const pad = region ? Math.ceil(Math.ceil(radius) / factor) : 0;
+  const spanX = region ? { start: region.x, size: region.w, pad } : void 0;
+  const spanY = region ? { start: region.y, size: region.h, pad } : void 0;
+  const rows = new Uint8Array(src.length);
+  blurAxis(width, height, factor, k, Math.floor(width / factor), (i, lane, c) => src[(lane * width + i) * 4 + c], (i, lane, c, v) => {
+    rows[(lane * width + i) * 4 + c] = v;
+  }, spanX);
+  const out = new Float64Array(src.length);
+  blurAxis(height, width, factor, k, Math.floor(height / factor), (i, lane, c) => rows[(i * width + lane) * 4 + c], (i, lane, c, v) => {
+    out[(i * width + lane) * 4 + c] = v;
+  }, spanY);
   return out;
 }
 function applyBlur(src, w, h, radius) {
@@ -16663,7 +16671,7 @@ function expandedBlur(rgba, width, height, radius, x0, y0, x1, y1, cropped) {
     const gy1 = Math.min(height, y1 + r);
     copyBlock(rgba, width, gx0, gy0, gx1 - gx0, gy1 - gy0, buf, bw, gx0 - (x0 - r), gy0 - (y0 - r));
   }
-  const blurred = blurReduction(radius) > 1 ? effectBlur(buf, bw, bh, radius, true) : gdipBlur(buf, bw, bh, radius, cropped ? r : 0, cropped, false, bw, bh, Math.ceil((y1 - y0) / (x1 - x0)));
+  const blurred = blurReduction(radius) > 1 ? effectBlur(buf, bw, bh, radius, cropped ? { x: r, y: r, w: x1 - x0, h: y1 - y0 } : void 0) : gdipBlur(buf, bw, bh, radius, cropped ? r : 0, cropped, Math.ceil((y1 - y0) / (x1 - x0)));
   const w = x1 - x0;
   const out = new Uint8ClampedArray(w * (y1 - y0) * 4);
   for (let y = 0; y < y1 - y0; y++) {

package/dist/browser.mjs CHANGED Viewed

@@ -16483,11 +16483,11 @@ function mirror(p, n) {
   }
   return p;
 }
-function gdipBlur(src, w, h, radius, vRow = 0, vZeroAbove = false, fullVertical = false, edgeWidth = w, edgeHeight = h, verticalRows = Math.ceil(h / w)) {
+function gdipBlur(src, w, h, radius, vRow = 0, vZeroAbove = false, verticalRows = Math.ceil(h / w)) {
   const k = blurKernel(radius);
   const taps = (k.length - 1) / 2;
-  const horizontalIndex = taps >= edgeWidth ? (x) => Math.max(0, Math.min(w - 1, x)) : (x) => mirror(x, w);
-  const verticalIndex = taps >= edgeHeight ? (y) => Math.max(0, Math.min(h - 1, y)) : (y) => mirror(y, h);
+  const horizontalIndex = taps >= w ? (x) => Math.max(0, Math.min(w - 1, x)) : (x) => mirror(x, w);
+  const verticalIndex = taps >= h ? (y) => Math.max(0, Math.min(h - 1, y)) : (y) => mirror(y, h);
   const out = new Float64Array(w * h * 4);
   for (let y = 0; y < h; y++) {
     const row2 = y * w * 4;
@@ -16498,22 +16498,22 @@ function gdipBlur(src, w, h, radius, vRow = 0, vZeroAbove = false, fullVertical
       let s3 = 0;
       for (let j = -taps; j <= taps; j++) {
         const p = row2 + horizontalIndex(x + j) * 4;
-        const kw = k[j + taps];
-        s0 += kw * src[p];
-        s1 += kw * src[p + 1];
-        s2 += kw * src[p + 2];
-        s3 += kw * src[p + 3];
+        const kw = k[j + taps] * 256;
+        s0 += Math.round(kw * src[p]);
+        s1 += Math.round(kw * src[p + 1]);
+        s2 += Math.round(kw * src[p + 2]);
+        s3 += Math.round(kw * src[p + 3]);
       }
       const o = row2 + x * 4;
-      out[o] = Math.round(s0);
-      out[o + 1] = Math.round(s1);
-      out[o + 2] = Math.round(s2);
-      out[o + 3] = Math.round(s3);
+      out[o] = Math.floor((s0 + 128) / 256);
+      out[o + 1] = Math.floor((s1 + 128) / 256);
+      out[o + 2] = Math.floor((s2 + 128) / 256);
+      out[o + 3] = Math.floor((s3 + 128) / 256);
     }
   }
   if (taps > 0 && vRow >= 0 && vRow < h) {
     const horizontal = out.slice();
-    const endRow = fullVertical ? h : Math.min(h, vRow + verticalRows);
+    const endRow = Math.min(h, vRow + verticalRows);
     for (let row2 = vRow; row2 < endRow; row2++) {
       const col = new Float64Array(w * 4);
       for (let j = -taps; j <= taps; j++) {
@@ -16523,7 +16523,7 @@ function gdipBlur(src, w, h, radius, vRow = 0, vZeroAbove = false, fullVertical
         }
         const base = verticalIndex(yy) * w * 4;
         for (let i = 0; i < w * 4; i++) {
-          col[i] += k[j + taps] * horizontal[base + i];
+          col[i] += Math.round(k[j + taps] * horizontal[base + i] * 256) / 256;
         }
       }
       out.set(col, row2 * w * 4);
@@ -16534,48 +16534,56 @@ function gdipBlur(src, w, h, radius, vRow = 0, vZeroAbove = false, fullVertical
 function blurReduction(radius) {
   return radius < 20 ? 1 : radius < 40 ? 2 : radius <= 80 ? 4 : radius < 160 ? 8 : 16;
 }
-function effectBlur(src, width, height, radius, expanded = false) {
-  const factor = blurReduction(radius);
-  if (factor === 1 || (width < 4 || height < 4) && (width % factor !== 0 || height % factor !== 0)) {
-    return gdipBlur(src, width, height, radius);
-  }
-  const w = Math.ceil(width / factor);
-  const h = Math.ceil(height / factor);
-  const reduced = new Uint8ClampedArray(w * h * 4);
-  for (let y = 0; y < h; y++) for (let x = 0; x < w; x++) {
-    const x1 = Math.min(width, (x + 1) * factor), y1 = Math.min(height, (y + 1) * factor);
-    const count = (x1 - x * factor) * (y1 - y * factor);
-    for (let c = 0; c < 4; c++) {
+function blurAxis(length, lanes, factor, k, edgeLength, get, put, span = { start: 0, size: length, pad: 0 }) {
+  const inner = Math.ceil(span.size / factor);
+  const n = inner + 2 * span.pad;
+  const taps = (k.length - 1) / 2;
+  const index = taps >= edgeLength ? (i) => clamp(i, 0, n - 1) : (i) => mirror(i, n);
+  const reduced = new Float64Array(n);
+  const filtered = new Float64Array(n);
+  const k256 = k.map((w) => w * 256);
+  for (let lane = 0; lane < lanes; lane++) for (let c = 0; c < 4; c++) {
+    for (let b = span.pad; b < span.pad + inner; b++) {
+      const from = span.start + (b - span.pad) * factor;
+      const end = Math.min(span.start + span.size, from + factor);
       let sum = 0;
-      for (let yy = y * factor; yy < y1; yy++) for (let xx = x * factor; xx < x1; xx++) sum += src[(yy * width + xx) * 4 + c];
-      reduced[(y * w + x) * 4 + c] = Math.floor(sum / count);
+      for (let i = from; i < end; i++) sum += get(i, lane, c);
+      reduced[b] = Math.floor(sum / (end - from));
     }
-  }
-  const filtered = gdipBlur(reduced, w, h, radius / factor, 0, false, true, Math.floor(width / factor), Math.floor(height / factor));
-  if (!expanded) {
-    const out2 = new Float64Array(src.length);
-    for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) {
-      const px = clamp((x + 0.5) / factor - 0.5, 0, w - 1), py = clamp((y + 0.5) / factor - 0.5, 0, h - 1);
-      const ix = Math.floor(px), iy = Math.floor(py), fx = px - ix, fy = py - iy;
-      const x1 = Math.min(w - 1, ix + 1), y1 = Math.min(h - 1, iy + 1);
-      for (let c = 0; c < 4; c++) {
-        const at = (xx, yy) => filtered[(yy * w + xx) * 4 + c];
-        const top = Math.floor((1 - fx) * at(ix, iy) + fx * at(x1, iy));
-        const bottom = Math.floor((1 - fx) * at(ix, y1) + fx * at(x1, y1));
-        out2[(y * width + x) * 4 + c] = Math.floor((1 - fy) * top + fy * bottom);
+    for (let b = 0; b < n; b++) {
+      let sum = 0;
+      if (b >= taps && b + taps < n) {
+        for (let j = 0; j < k256.length; j++) sum += Math.round(k256[j] * reduced[b - taps + j]);
+      } else {
+        for (let j = 0; j < k256.length; j++) sum += Math.round(k256[j] * reduced[index(b - taps + j)]);
       }
+      filtered[b] = Math.floor((sum + 128) / 256);
+    }
+    for (let i = 0; i < length; i++) {
+      const p = (i - span.start + 0.5) / factor - 0.5 + span.pad;
+      const a = clamp(Math.floor(p), 0, Math.max(0, n - 2));
+      const t = p - a;
+      put(i, lane, c, clamp(Math.floor((1 - t) * filtered[a] + t * filtered[Math.min(n - 1, a + 1)] + 1e-9), 0, 255));
     }
-    return out2;
   }
-  for (let i = 0; i < filtered.length; i++) filtered[i] = Math.round(filtered[i]);
-  const out = new Float64Array(src.length);
-  for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) {
-    const px = clamp((x + 0.5) / factor - 0.5, 0, w - 1), py = clamp((y + 0.5) / factor - 0.5, 0, h - 1);
-    const ix = Math.floor(px), iy = Math.floor(py), fx = px - ix, fy = py - iy;
-    const a = (iy * w + ix) * 4, b = (iy * w + Math.min(w - 1, ix + 1)) * 4;
-    const d = (Math.min(h - 1, iy + 1) * w + ix) * 4, e = (Math.min(h - 1, iy + 1) * w + Math.min(w - 1, ix + 1)) * 4;
-    for (let c = 0; c < 4; c++) out[(y * width + x) * 4 + c] = Math.round((1 - fy) * ((1 - fx) * filtered[a + c] + fx * filtered[b + c]) + fy * ((1 - fx) * filtered[d + c] + fx * filtered[e + c]));
+}
+function effectBlur(src, width, height, radius, region) {
+  const factor = blurReduction(radius);
+  if (factor === 1) {
+    return gdipBlur(src, width, height, radius);
   }
+  const k = blurKernel(radius / factor);
+  const pad = region ? Math.ceil(Math.ceil(radius) / factor) : 0;
+  const spanX = region ? { start: region.x, size: region.w, pad } : void 0;
+  const spanY = region ? { start: region.y, size: region.h, pad } : void 0;
+  const rows = new Uint8Array(src.length);
+  blurAxis(width, height, factor, k, Math.floor(width / factor), (i, lane, c) => src[(lane * width + i) * 4 + c], (i, lane, c, v) => {
+    rows[(lane * width + i) * 4 + c] = v;
+  }, spanX);
+  const out = new Float64Array(src.length);
+  blurAxis(height, width, factor, k, Math.floor(height / factor), (i, lane, c) => rows[(i * width + lane) * 4 + c], (i, lane, c, v) => {
+    out[(i * width + lane) * 4 + c] = v;
+  }, spanY);
   return out;
 }
 function applyBlur(src, w, h, radius) {
@@ -16661,7 +16669,7 @@ function expandedBlur(rgba, width, height, radius, x0, y0, x1, y1, cropped) {
     const gy1 = Math.min(height, y1 + r);
     copyBlock(rgba, width, gx0, gy0, gx1 - gx0, gy1 - gy0, buf, bw, gx0 - (x0 - r), gy0 - (y0 - r));
   }
-  const blurred = blurReduction(radius) > 1 ? effectBlur(buf, bw, bh, radius, true) : gdipBlur(buf, bw, bh, radius, cropped ? r : 0, cropped, false, bw, bh, Math.ceil((y1 - y0) / (x1 - x0)));
+  const blurred = blurReduction(radius) > 1 ? effectBlur(buf, bw, bh, radius, cropped ? { x: r, y: r, w: x1 - x0, h: y1 - y0 } : void 0) : gdipBlur(buf, bw, bh, radius, cropped ? r : 0, cropped, Math.ceil((y1 - y0) / (x1 - x0)));
   const w = x1 - x0;
   const out = new Uint8ClampedArray(w * (y1 - y0) * 4);
   for (let y = 0; y < y1 - y0; y++) {

package/dist/index.js CHANGED Viewed

@@ -16486,11 +16486,11 @@ function mirror(p, n) {
   }
   return p;
 }
-function gdipBlur(src, w, h, radius, vRow = 0, vZeroAbove = false, fullVertical = false, edgeWidth = w, edgeHeight = h, verticalRows = Math.ceil(h / w)) {
+function gdipBlur(src, w, h, radius, vRow = 0, vZeroAbove = false, verticalRows = Math.ceil(h / w)) {
   const k = blurKernel(radius);
   const taps = (k.length - 1) / 2;
-  const horizontalIndex = taps >= edgeWidth ? (x) => Math.max(0, Math.min(w - 1, x)) : (x) => mirror(x, w);
-  const verticalIndex = taps >= edgeHeight ? (y) => Math.max(0, Math.min(h - 1, y)) : (y) => mirror(y, h);
+  const horizontalIndex = taps >= w ? (x) => Math.max(0, Math.min(w - 1, x)) : (x) => mirror(x, w);
+  const verticalIndex = taps >= h ? (y) => Math.max(0, Math.min(h - 1, y)) : (y) => mirror(y, h);
   const out = new Float64Array(w * h * 4);
   for (let y = 0; y < h; y++) {
     const row2 = y * w * 4;
@@ -16501,22 +16501,22 @@ function gdipBlur(src, w, h, radius, vRow = 0, vZeroAbove = false, fullVertical
       let s3 = 0;
       for (let j = -taps; j <= taps; j++) {
         const p = row2 + horizontalIndex(x + j) * 4;
-        const kw = k[j + taps];
-        s0 += kw * src[p];
-        s1 += kw * src[p + 1];
-        s2 += kw * src[p + 2];
-        s3 += kw * src[p + 3];
+        const kw = k[j + taps] * 256;
+        s0 += Math.round(kw * src[p]);
+        s1 += Math.round(kw * src[p + 1]);
+        s2 += Math.round(kw * src[p + 2]);
+        s3 += Math.round(kw * src[p + 3]);
       }
       const o = row2 + x * 4;
-      out[o] = Math.round(s0);
-      out[o + 1] = Math.round(s1);
-      out[o + 2] = Math.round(s2);
-      out[o + 3] = Math.round(s3);
+      out[o] = Math.floor((s0 + 128) / 256);
+      out[o + 1] = Math.floor((s1 + 128) / 256);
+      out[o + 2] = Math.floor((s2 + 128) / 256);
+      out[o + 3] = Math.floor((s3 + 128) / 256);
     }
   }
   if (taps > 0 && vRow >= 0 && vRow < h) {
     const horizontal = out.slice();
-    const endRow = fullVertical ? h : Math.min(h, vRow + verticalRows);
+    const endRow = Math.min(h, vRow + verticalRows);
     for (let row2 = vRow; row2 < endRow; row2++) {
       const col = new Float64Array(w * 4);
       for (let j = -taps; j <= taps; j++) {
@@ -16526,7 +16526,7 @@ function gdipBlur(src, w, h, radius, vRow = 0, vZeroAbove = false, fullVertical
         }
         const base = verticalIndex(yy) * w * 4;
         for (let i = 0; i < w * 4; i++) {
-          col[i] += k[j + taps] * horizontal[base + i];
+          col[i] += Math.round(k[j + taps] * horizontal[base + i] * 256) / 256;
         }
       }
       out.set(col, row2 * w * 4);
@@ -16537,48 +16537,56 @@ function gdipBlur(src, w, h, radius, vRow = 0, vZeroAbove = false, fullVertical
 function blurReduction(radius) {
   return radius < 20 ? 1 : radius < 40 ? 2 : radius <= 80 ? 4 : radius < 160 ? 8 : 16;
 }
-function effectBlur(src, width, height, radius, expanded = false) {
-  const factor = blurReduction(radius);
-  if (factor === 1 || (width < 4 || height < 4) && (width % factor !== 0 || height % factor !== 0)) {
-    return gdipBlur(src, width, height, radius);
-  }
-  const w = Math.ceil(width / factor);
-  const h = Math.ceil(height / factor);
-  const reduced = new Uint8ClampedArray(w * h * 4);
-  for (let y = 0; y < h; y++) for (let x = 0; x < w; x++) {
-    const x1 = Math.min(width, (x + 1) * factor), y1 = Math.min(height, (y + 1) * factor);
-    const count = (x1 - x * factor) * (y1 - y * factor);
-    for (let c = 0; c < 4; c++) {
+function blurAxis(length, lanes, factor, k, edgeLength, get, put, span = { start: 0, size: length, pad: 0 }) {
+  const inner = Math.ceil(span.size / factor);
+  const n = inner + 2 * span.pad;
+  const taps = (k.length - 1) / 2;
+  const index = taps >= edgeLength ? (i) => clamp(i, 0, n - 1) : (i) => mirror(i, n);
+  const reduced = new Float64Array(n);
+  const filtered = new Float64Array(n);
+  const k256 = k.map((w) => w * 256);
+  for (let lane = 0; lane < lanes; lane++) for (let c = 0; c < 4; c++) {
+    for (let b = span.pad; b < span.pad + inner; b++) {
+      const from = span.start + (b - span.pad) * factor;
+      const end = Math.min(span.start + span.size, from + factor);
       let sum = 0;
-      for (let yy = y * factor; yy < y1; yy++) for (let xx = x * factor; xx < x1; xx++) sum += src[(yy * width + xx) * 4 + c];
-      reduced[(y * w + x) * 4 + c] = Math.floor(sum / count);
+      for (let i = from; i < end; i++) sum += get(i, lane, c);
+      reduced[b] = Math.floor(sum / (end - from));
     }
-  }
-  const filtered = gdipBlur(reduced, w, h, radius / factor, 0, false, true, Math.floor(width / factor), Math.floor(height / factor));
-  if (!expanded) {
-    const out2 = new Float64Array(src.length);
-    for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) {
-      const px = clamp((x + 0.5) / factor - 0.5, 0, w - 1), py = clamp((y + 0.5) / factor - 0.5, 0, h - 1);
-      const ix = Math.floor(px), iy = Math.floor(py), fx = px - ix, fy = py - iy;
-      const x1 = Math.min(w - 1, ix + 1), y1 = Math.min(h - 1, iy + 1);
-      for (let c = 0; c < 4; c++) {
-        const at = (xx, yy) => filtered[(yy * w + xx) * 4 + c];
-        const top = Math.floor((1 - fx) * at(ix, iy) + fx * at(x1, iy));
-        const bottom = Math.floor((1 - fx) * at(ix, y1) + fx * at(x1, y1));
-        out2[(y * width + x) * 4 + c] = Math.floor((1 - fy) * top + fy * bottom);
+    for (let b = 0; b < n; b++) {
+      let sum = 0;
+      if (b >= taps && b + taps < n) {
+        for (let j = 0; j < k256.length; j++) sum += Math.round(k256[j] * reduced[b - taps + j]);
+      } else {
+        for (let j = 0; j < k256.length; j++) sum += Math.round(k256[j] * reduced[index(b - taps + j)]);
       }
+      filtered[b] = Math.floor((sum + 128) / 256);
+    }
+    for (let i = 0; i < length; i++) {
+      const p = (i - span.start + 0.5) / factor - 0.5 + span.pad;
+      const a = clamp(Math.floor(p), 0, Math.max(0, n - 2));
+      const t = p - a;
+      put(i, lane, c, clamp(Math.floor((1 - t) * filtered[a] + t * filtered[Math.min(n - 1, a + 1)] + 1e-9), 0, 255));
     }
-    return out2;
   }
-  for (let i = 0; i < filtered.length; i++) filtered[i] = Math.round(filtered[i]);
-  const out = new Float64Array(src.length);
-  for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) {
-    const px = clamp((x + 0.5) / factor - 0.5, 0, w - 1), py = clamp((y + 0.5) / factor - 0.5, 0, h - 1);
-    const ix = Math.floor(px), iy = Math.floor(py), fx = px - ix, fy = py - iy;
-    const a = (iy * w + ix) * 4, b = (iy * w + Math.min(w - 1, ix + 1)) * 4;
-    const d = (Math.min(h - 1, iy + 1) * w + ix) * 4, e = (Math.min(h - 1, iy + 1) * w + Math.min(w - 1, ix + 1)) * 4;
-    for (let c = 0; c < 4; c++) out[(y * width + x) * 4 + c] = Math.round((1 - fy) * ((1 - fx) * filtered[a + c] + fx * filtered[b + c]) + fy * ((1 - fx) * filtered[d + c] + fx * filtered[e + c]));
+}
+function effectBlur(src, width, height, radius, region) {
+  const factor = blurReduction(radius);
+  if (factor === 1) {
+    return gdipBlur(src, width, height, radius);
   }
+  const k = blurKernel(radius / factor);
+  const pad = region ? Math.ceil(Math.ceil(radius) / factor) : 0;
+  const spanX = region ? { start: region.x, size: region.w, pad } : void 0;
+  const spanY = region ? { start: region.y, size: region.h, pad } : void 0;
+  const rows = new Uint8Array(src.length);
+  blurAxis(width, height, factor, k, Math.floor(width / factor), (i, lane, c) => src[(lane * width + i) * 4 + c], (i, lane, c, v) => {
+    rows[(lane * width + i) * 4 + c] = v;
+  }, spanX);
+  const out = new Float64Array(src.length);
+  blurAxis(height, width, factor, k, Math.floor(height / factor), (i, lane, c) => rows[(i * width + lane) * 4 + c], (i, lane, c, v) => {
+    out[(i * width + lane) * 4 + c] = v;
+  }, spanY);
   return out;
 }
 function applyBlur(src, w, h, radius) {
@@ -16664,7 +16672,7 @@ function expandedBlur(rgba, width, height, radius, x0, y0, x1, y1, cropped) {
     const gy1 = Math.min(height, y1 + r);
     copyBlock(rgba, width, gx0, gy0, gx1 - gx0, gy1 - gy0, buf, bw, gx0 - (x0 - r), gy0 - (y0 - r));
   }
-  const blurred = blurReduction(radius) > 1 ? effectBlur(buf, bw, bh, radius, true) : gdipBlur(buf, bw, bh, radius, cropped ? r : 0, cropped, false, bw, bh, Math.ceil((y1 - y0) / (x1 - x0)));
+  const blurred = blurReduction(radius) > 1 ? effectBlur(buf, bw, bh, radius, cropped ? { x: r, y: r, w: x1 - x0, h: y1 - y0 } : void 0) : gdipBlur(buf, bw, bh, radius, cropped ? r : 0, cropped, Math.ceil((y1 - y0) / (x1 - x0)));
   const w = x1 - x0;
   const out = new Uint8ClampedArray(w * (y1 - y0) * 4);
   for (let y = 0; y < y1 - y0; y++) {

package/dist/index.mjs CHANGED Viewed

@@ -16484,11 +16484,11 @@ function mirror(p, n) {
   }
   return p;
 }
-function gdipBlur(src, w, h, radius, vRow = 0, vZeroAbove = false, fullVertical = false, edgeWidth = w, edgeHeight = h, verticalRows = Math.ceil(h / w)) {
+function gdipBlur(src, w, h, radius, vRow = 0, vZeroAbove = false, verticalRows = Math.ceil(h / w)) {
   const k = blurKernel(radius);
   const taps = (k.length - 1) / 2;
-  const horizontalIndex = taps >= edgeWidth ? (x) => Math.max(0, Math.min(w - 1, x)) : (x) => mirror(x, w);
-  const verticalIndex = taps >= edgeHeight ? (y) => Math.max(0, Math.min(h - 1, y)) : (y) => mirror(y, h);
+  const horizontalIndex = taps >= w ? (x) => Math.max(0, Math.min(w - 1, x)) : (x) => mirror(x, w);
+  const verticalIndex = taps >= h ? (y) => Math.max(0, Math.min(h - 1, y)) : (y) => mirror(y, h);
   const out = new Float64Array(w * h * 4);
   for (let y = 0; y < h; y++) {
     const row2 = y * w * 4;
@@ -16499,22 +16499,22 @@ function gdipBlur(src, w, h, radius, vRow = 0, vZeroAbove = false, fullVertical
       let s3 = 0;
       for (let j = -taps; j <= taps; j++) {
         const p = row2 + horizontalIndex(x + j) * 4;
-        const kw = k[j + taps];
-        s0 += kw * src[p];
-        s1 += kw * src[p + 1];
-        s2 += kw * src[p + 2];
-        s3 += kw * src[p + 3];
+        const kw = k[j + taps] * 256;
+        s0 += Math.round(kw * src[p]);
+        s1 += Math.round(kw * src[p + 1]);
+        s2 += Math.round(kw * src[p + 2]);
+        s3 += Math.round(kw * src[p + 3]);
       }
       const o = row2 + x * 4;
-      out[o] = Math.round(s0);
-      out[o + 1] = Math.round(s1);
-      out[o + 2] = Math.round(s2);
-      out[o + 3] = Math.round(s3);
+      out[o] = Math.floor((s0 + 128) / 256);
+      out[o + 1] = Math.floor((s1 + 128) / 256);
+      out[o + 2] = Math.floor((s2 + 128) / 256);
+      out[o + 3] = Math.floor((s3 + 128) / 256);
     }
   }
   if (taps > 0 && vRow >= 0 && vRow < h) {
     const horizontal = out.slice();
-    const endRow = fullVertical ? h : Math.min(h, vRow + verticalRows);
+    const endRow = Math.min(h, vRow + verticalRows);
     for (let row2 = vRow; row2 < endRow; row2++) {
       const col = new Float64Array(w * 4);
       for (let j = -taps; j <= taps; j++) {
@@ -16524,7 +16524,7 @@ function gdipBlur(src, w, h, radius, vRow = 0, vZeroAbove = false, fullVertical
         }
         const base = verticalIndex(yy) * w * 4;
         for (let i = 0; i < w * 4; i++) {
-          col[i] += k[j + taps] * horizontal[base + i];
+          col[i] += Math.round(k[j + taps] * horizontal[base + i] * 256) / 256;
         }
       }
       out.set(col, row2 * w * 4);
@@ -16535,48 +16535,56 @@ function gdipBlur(src, w, h, radius, vRow = 0, vZeroAbove = false, fullVertical
 function blurReduction(radius) {
   return radius < 20 ? 1 : radius < 40 ? 2 : radius <= 80 ? 4 : radius < 160 ? 8 : 16;
 }
-function effectBlur(src, width, height, radius, expanded = false) {
-  const factor = blurReduction(radius);
-  if (factor === 1 || (width < 4 || height < 4) && (width % factor !== 0 || height % factor !== 0)) {
-    return gdipBlur(src, width, height, radius);
-  }
-  const w = Math.ceil(width / factor);
-  const h = Math.ceil(height / factor);
-  const reduced = new Uint8ClampedArray(w * h * 4);
-  for (let y = 0; y < h; y++) for (let x = 0; x < w; x++) {
-    const x1 = Math.min(width, (x + 1) * factor), y1 = Math.min(height, (y + 1) * factor);
-    const count = (x1 - x * factor) * (y1 - y * factor);
-    for (let c = 0; c < 4; c++) {
+function blurAxis(length, lanes, factor, k, edgeLength, get, put, span = { start: 0, size: length, pad: 0 }) {
+  const inner = Math.ceil(span.size / factor);
+  const n = inner + 2 * span.pad;
+  const taps = (k.length - 1) / 2;
+  const index = taps >= edgeLength ? (i) => clamp(i, 0, n - 1) : (i) => mirror(i, n);
+  const reduced = new Float64Array(n);
+  const filtered = new Float64Array(n);
+  const k256 = k.map((w) => w * 256);
+  for (let lane = 0; lane < lanes; lane++) for (let c = 0; c < 4; c++) {
+    for (let b = span.pad; b < span.pad + inner; b++) {
+      const from = span.start + (b - span.pad) * factor;
+      const end = Math.min(span.start + span.size, from + factor);
       let sum = 0;
-      for (let yy = y * factor; yy < y1; yy++) for (let xx = x * factor; xx < x1; xx++) sum += src[(yy * width + xx) * 4 + c];
-      reduced[(y * w + x) * 4 + c] = Math.floor(sum / count);
+      for (let i = from; i < end; i++) sum += get(i, lane, c);
+      reduced[b] = Math.floor(sum / (end - from));
     }
-  }
-  const filtered = gdipBlur(reduced, w, h, radius / factor, 0, false, true, Math.floor(width / factor), Math.floor(height / factor));
-  if (!expanded) {
-    const out2 = new Float64Array(src.length);
-    for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) {
-      const px = clamp((x + 0.5) / factor - 0.5, 0, w - 1), py = clamp((y + 0.5) / factor - 0.5, 0, h - 1);
-      const ix = Math.floor(px), iy = Math.floor(py), fx = px - ix, fy = py - iy;
-      const x1 = Math.min(w - 1, ix + 1), y1 = Math.min(h - 1, iy + 1);
-      for (let c = 0; c < 4; c++) {
-        const at = (xx, yy) => filtered[(yy * w + xx) * 4 + c];
-        const top = Math.floor((1 - fx) * at(ix, iy) + fx * at(x1, iy));
-        const bottom = Math.floor((1 - fx) * at(ix, y1) + fx * at(x1, y1));
-        out2[(y * width + x) * 4 + c] = Math.floor((1 - fy) * top + fy * bottom);
+    for (let b = 0; b < n; b++) {
+      let sum = 0;
+      if (b >= taps && b + taps < n) {
+        for (let j = 0; j < k256.length; j++) sum += Math.round(k256[j] * reduced[b - taps + j]);
+      } else {
+        for (let j = 0; j < k256.length; j++) sum += Math.round(k256[j] * reduced[index(b - taps + j)]);
       }
+      filtered[b] = Math.floor((sum + 128) / 256);
+    }
+    for (let i = 0; i < length; i++) {
+      const p = (i - span.start + 0.5) / factor - 0.5 + span.pad;
+      const a = clamp(Math.floor(p), 0, Math.max(0, n - 2));
+      const t = p - a;
+      put(i, lane, c, clamp(Math.floor((1 - t) * filtered[a] + t * filtered[Math.min(n - 1, a + 1)] + 1e-9), 0, 255));
     }
-    return out2;
   }
-  for (let i = 0; i < filtered.length; i++) filtered[i] = Math.round(filtered[i]);
-  const out = new Float64Array(src.length);
-  for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) {
-    const px = clamp((x + 0.5) / factor - 0.5, 0, w - 1), py = clamp((y + 0.5) / factor - 0.5, 0, h - 1);
-    const ix = Math.floor(px), iy = Math.floor(py), fx = px - ix, fy = py - iy;
-    const a = (iy * w + ix) * 4, b = (iy * w + Math.min(w - 1, ix + 1)) * 4;
-    const d = (Math.min(h - 1, iy + 1) * w + ix) * 4, e = (Math.min(h - 1, iy + 1) * w + Math.min(w - 1, ix + 1)) * 4;
-    for (let c = 0; c < 4; c++) out[(y * width + x) * 4 + c] = Math.round((1 - fy) * ((1 - fx) * filtered[a + c] + fx * filtered[b + c]) + fy * ((1 - fx) * filtered[d + c] + fx * filtered[e + c]));
+}
+function effectBlur(src, width, height, radius, region) {
+  const factor = blurReduction(radius);
+  if (factor === 1) {
+    return gdipBlur(src, width, height, radius);
   }
+  const k = blurKernel(radius / factor);
+  const pad = region ? Math.ceil(Math.ceil(radius) / factor) : 0;
+  const spanX = region ? { start: region.x, size: region.w, pad } : void 0;
+  const spanY = region ? { start: region.y, size: region.h, pad } : void 0;
+  const rows = new Uint8Array(src.length);
+  blurAxis(width, height, factor, k, Math.floor(width / factor), (i, lane, c) => src[(lane * width + i) * 4 + c], (i, lane, c, v) => {
+    rows[(lane * width + i) * 4 + c] = v;
+  }, spanX);
+  const out = new Float64Array(src.length);
+  blurAxis(height, width, factor, k, Math.floor(height / factor), (i, lane, c) => rows[(i * width + lane) * 4 + c], (i, lane, c, v) => {
+    out[(i * width + lane) * 4 + c] = v;
+  }, spanY);
   return out;
 }
 function applyBlur(src, w, h, radius) {
@@ -16662,7 +16670,7 @@ function expandedBlur(rgba, width, height, radius, x0, y0, x1, y1, cropped) {
     const gy1 = Math.min(height, y1 + r);
     copyBlock(rgba, width, gx0, gy0, gx1 - gx0, gy1 - gy0, buf, bw, gx0 - (x0 - r), gy0 - (y0 - r));
   }
-  const blurred = blurReduction(radius) > 1 ? effectBlur(buf, bw, bh, radius, true) : gdipBlur(buf, bw, bh, radius, cropped ? r : 0, cropped, false, bw, bh, Math.ceil((y1 - y0) / (x1 - x0)));
+  const blurred = blurReduction(radius) > 1 ? effectBlur(buf, bw, bh, radius, cropped ? { x: r, y: r, w: x1 - x0, h: y1 - y0 } : void 0) : gdipBlur(buf, bw, bh, radius, cropped ? r : 0, cropped, Math.ceil((y1 - y0) / (x1 - x0)));
   const w = x1 - x0;
   const out = new Uint8ClampedArray(w * (y1 - y0) * 4);
   for (let y = 0; y < y1 - y0; y++) {

package/package.json CHANGED Viewed

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