imagescript 3.2.0 → 3.2.1

package/dist/animation.js

@@ -13,7 +13,7 @@ const fromPlays = (plays) => plays === 0 ? -1 : plays - 1;
 function canvasFrames(width, height, frames) {
     return frames.map(({ pixels, duration }) => {
         const frame = new Frame(width, height, duration, 0, 0, Frame.DISPOSAL_BACKGROUND);
-        frame.bitmap.set(pixels);
+        frame.bitmap = pixels;
         return frame;
     });
 }

package/dist/codecs/gif.js

@@ -188,23 +188,20 @@ export function decode(data, onlyFirstFrame = false) {
             control = null;
             if (!fw || !fh)
                 continue;
-            const pixels = new Uint8Array(fw * fh * 4);
-            const rows = interlaced ? interlacedRows(fh) : null;
-            const colors = new Uint8Array(256 * 4);
+            const colors = new Uint32Array(256), bytes = new Uint8Array(colors.buffer);
             for (let index = 0; index < 256; index++) {
-                if (index === transparentIndex)
-                    continue;
                 if (table && index * 3 + 2 < table.length)
-                    colors.set(table.subarray(index * 3, index * 3 + 3), index * 4);
-                colors[index * 4 + 3] = 0xff;
+                    bytes.set(table.subarray(index * 3, index * 3 + 3), index * 4);
+                bytes[index * 4 + 3] = 0xff;
             }
-            const lookup = new Uint32Array(colors.buffer), out = new Uint32Array(pixels.buffer);
-            for (let row = 0; row < fh; row++) {
-                const target = (rows ? rows[row] : row) * fw, source = row * fw;
-                for (let column = 0; column < fw; column++)
-                    out[target + column] = lookup[indices[source + column]];
+            let ordered = indices;
+            if (interlaced) {
+                const rows = interlacedRows(fh);
+                ordered = new Uint8Array(indices.length);
+                for (let row = 0; row < fh; row++)
+                    ordered.set(indices.subarray(row * fw, (row + 1) * fw), rows[row] * fw);
             }
-            frames.push({ x, y, width: fw, height: fh, delay, dispose, pixels });
+            frames.push({ x, y, width: fw, height: fh, delay, dispose, indices: ordered, colors, transparentIndex });
             if (onlyFirstFrame)
                 break;
         }
@@ -215,15 +212,21 @@ export function composite({ width, height, frames }) {
     const output = [];
     for (const frame of frames) {
         const previous = frame.dispose === 2 ? canvas.slice() : null;
-        const src = new Uint32Array(frame.pixels.buffer, frame.pixels.byteOffset, frame.width * frame.height);
+        const { indices, colors, transparentIndex } = frame;
         const x0 = Math.min(frame.x, width), x1 = Math.min(frame.x + frame.width, width);
         const y0 = Math.min(frame.y, height), y1 = Math.min(frame.y + frame.height, height);
         for (let y = y0; y < y1; y++) {
             const srcRow = (y - frame.y) * frame.width - frame.x;
             const dstRow = y * width;
-            for (let x = x0; x < x1; x++)
-                if (frame.pixels[(srcRow + x) * 4 + 3] !== 0)
-                    canvas[dstRow + x] = src[srcRow + x];
+            if (transparentIndex < 0)
+                for (let x = x0; x < x1; x++)
+                    canvas[dstRow + x] = colors[indices[srcRow + x]];
+            else
+                for (let x = x0; x < x1; x++) {
+                    const index = indices[srcRow + x];
+                    if (index !== transparentIndex)
+                        canvas[dstRow + x] = colors[index];
+                }
         }
         output.push({ pixels: new Uint8Array(canvas.slice().buffer), delay: frame.delay });
         if (frame.dispose === 3) {

package/dist/image.js

@@ -12,7 +12,7 @@ import { TextLayout } from "./text-layout.js";
 import { resolveMetadata, pngText, exifData } from "./metadata.js";
 import { encode as utf8 } from "./util/utf8.js";
 import { resample, BOX, TRIANGLE, CUBIC } from "./util/resample.js";
-import { gaussianBlur, premultiply, unpremultiply } from "./util/blur.js";
+import { gaussianBlur, boxBlurRGBA, premultiply, unpremultiply } from "./util/blur.js";
 import { isOptions } from "./util/options.js";
 export class Image {
     __width__;
@@ -189,8 +189,10 @@ export class Image {
         return this;
     }
     clone() {
-        const image = new Image(this.width, this.height);
-        image.bitmap.set(this.bitmap);
+        const image = new Image(1, 1);
+        image.__width__ = this.width;
+        image.__height__ = this.height;
+        image.__set_bitmap__(new Uint8ClampedArray(this.bitmap));
         return image;
     }
     static get RESIZE_NEAREST_NEIGHBOR() {
@@ -612,6 +614,8 @@ export class Image {
     blur(radius) {
         if (isNaN(radius) || radius < 0)
             throw new RangeError('Invalid blur radius');
+        if (boxBlurRGBA(this.bitmap, this.width, this.height, radius))
+            return this;
         const pixels = premultiply(this.bitmap);
         gaussianBlur(pixels, this.width, this.height, radius);
         unpremultiply(pixels, this.bitmap);

package/dist/util/blur.js

@@ -119,6 +119,94 @@ export function gaussianBlur(pixels, width, height, sigma) {
         boxPassRows(tmp, pixels, width, height, radius);
     }
 }
+function boxRowWords(src, dst, s, length, radius, mult) {
+    const last = length - 1;
+    const first = src[s], end = src[s + last];
+    let rb = (radius + 1) * (first & 0xff00ff), ga = (radius + 1) * (first >>> 8 & 0xff00ff);
+    for (let k = 1; k <= radius; k++) {
+        const p = src[s + (k < last ? k : last)];
+        rb += p & 0xff00ff;
+        ga += p >>> 8 & 0xff00ff;
+    }
+    for (let x = 0; x < length; x++) {
+        dst[s + x] = (Math.imul(rb & 0xffff, mult) + 32768 >>> 16) | (Math.imul(ga & 0xffff, mult) + 32768 >>> 16) << 8
+            | (Math.imul(rb >>> 16, mult) + 32768 >>> 16) << 16 | (Math.imul(ga >>> 16, mult) + 32768 >>> 16) << 24;
+        const add = x + radius + 1, remove = x - radius;
+        const entering = add < last ? src[s + add] : end, leaving = remove > 0 ? src[s + remove] : first;
+        rb += (entering & 0xff00ff) - (leaving & 0xff00ff);
+        ga += (entering >>> 8 & 0xff00ff) - (leaving >>> 8 & 0xff00ff);
+    }
+}
+function boxColumnsWords(src, dst, width, height, radius, mult, rbs, gas) {
+    for (let x = 0; x < width; x++) {
+        const p = src[x];
+        rbs[x] = (radius + 1) * (p & 0xff00ff);
+        gas[x] = (radius + 1) * (p >>> 8 & 0xff00ff);
+    }
+    for (let k = 1; k <= radius; k++) {
+        const o = Math.min(k, height - 1) * width;
+        for (let x = 0; x < width; x++) {
+            const p = src[o + x];
+            rbs[x] += p & 0xff00ff;
+            gas[x] += p >>> 8 & 0xff00ff;
+        }
+    }
+    for (let y = 0; y < height; y++) {
+        const o = y * width, add = Math.min(height - 1, y + radius + 1) * width, remove = Math.max(0, y - radius) * width;
+        for (let x = 0; x < width; x++) {
+            const rb = rbs[x], ga = gas[x];
+            dst[o + x] = (Math.imul(rb & 0xffff, mult) + 32768 >>> 16) | (Math.imul(ga & 0xffff, mult) + 32768 >>> 16) << 8
+                | (Math.imul(rb >>> 16, mult) + 32768 >>> 16) << 16 | (Math.imul(ga >>> 16, mult) + 32768 >>> 16) << 24;
+            const entering = src[add + x], leaving = src[remove + x];
+            rbs[x] = rb + (entering & 0xff00ff) - (leaving & 0xff00ff);
+            gas[x] = ga + (entering >>> 8 & 0xff00ff) - (leaving >>> 8 & 0xff00ff);
+        }
+    }
+}
+export function boxBlurRGBA(bitmap, width, height, sigma) {
+    const sizes = boxSizes(sigma);
+    if (!(sigma >= 2) || Math.max(...sizes) > 257)
+        return false;
+    let opaque = true;
+    for (let i = 3; i < bitmap.length; i += 4)
+        if (bitmap[i] !== 255) {
+            opaque = false;
+            break;
+        }
+    if (!opaque) {
+        for (let i = 0; i < bitmap.length; i += 4) {
+            const a = bitmap[i + 3];
+            bitmap[i] = (bitmap[i] * a + 128) * 257 >> 16;
+            bitmap[i + 1] = (bitmap[i + 1] * a + 128) * 257 >> 16;
+            bitmap[i + 2] = (bitmap[i + 2] * a + 128) * 257 >> 16;
+        }
+    }
+    const pixels = new Int32Array(bitmap.buffer, bitmap.byteOffset, width * height);
+    const tmp = new Int32Array(pixels.length), rbs = new Int32Array(width), gas = new Int32Array(width);
+    for (const size of sizes) {
+        const radius = (size - 1) / 2;
+        if (radius < 1)
+            continue;
+        const mult = Math.round(65536 / size);
+        for (let y = 0; y < height; y++)
+            boxRowWords(pixels, tmp, y * width, width, radius, mult);
+        boxColumnsWords(tmp, pixels, width, height, radius, mult, rbs, gas);
+    }
+    if (!opaque) {
+        for (let i = 0; i < bitmap.length; i += 4) {
+            const a = bitmap[i + 3];
+            if (a === 0) {
+                bitmap[i] = bitmap[i + 1] = bitmap[i + 2] = 0;
+                continue;
+            }
+            const f = 255 / a;
+            bitmap[i] *= f;
+            bitmap[i + 1] *= f;
+            bitmap[i + 2] *= f;
+        }
+    }
+    return true;
+}
 export function premultiply(rgba) {
     const out = new Float32Array(rgba.length);
     for (let i = 0; i < rgba.length; i += 4) {

package/dist/util/resample.js

@@ -12,106 +12,269 @@ export const CUBIC = {
         return 0;
     }
 };
-function coefficients(inSize, outSize, filter) {
+const BITS = 14;
+const ONE = 1 << BITS;
+function coefficients(inSize, outSize, filter, bits) {
     const scale = inSize / outSize;
     const filterScale = Math.max(1, scale);
     const support = filter.support * filterScale;
-    const size = Math.ceil(support) * 2 + 1;
-    const start = new Int32Array(outSize);
-    const count = new Int32Array(outSize);
-    const weights = new Float64Array(outSize * size);
+    const one = 1 << bits;
+    const mins = new Int32Array(outSize), maxs = new Int32Array(outSize);
+    let taps = 0;
     for (let i = 0; i < outSize; i++) {
         const center = (i + 0.5) * scale;
-        const min = Math.max(0, Math.floor(center - support + 0.5));
-        const max = Math.min(inSize, Math.floor(center + support + 0.5));
+        mins[i] = Math.max(0, Math.floor(center - support + 0.5));
+        maxs[i] = Math.min(inSize, Math.floor(center + support + 0.5));
+        taps = Math.max(taps, maxs[i] - mins[i]);
+    }
+    const start = new Int32Array(outSize);
+    const weights = new Int32Array(outSize * taps);
+    const w = new Float64Array(taps);
+    for (let i = 0; i < outSize; i++) {
+        const center = (i + 0.5) * scale, min = mins[i], n = maxs[i] - min;
         let total = 0;
-        for (let x = min; x < max; x++) {
-            const w = filter.weight((x - center + 0.5) / filterScale);
-            weights[i * size + x - min] = w;
-            total += w;
+        for (let k = 0; k < n; k++)
+            total += w[k] = filter.weight((min + k - center + 0.5) / filterScale);
+        const shift = Math.max(0, min + taps - inSize), o = i * taps + shift;
+        start[i] = min - shift;
+        let sum = 0, largest = 0;
+        for (let k = 0; k < n; k++) {
+            sum += weights[o + k] = Math.round(total ? w[k] / total * one : 0);
+            if (Math.abs(w[k]) > Math.abs(w[largest]))
+                largest = k;
         }
-        if (total !== 0)
-            for (let k = 0; k < max - min; k++)
-                weights[i * size + k] /= total;
-        start[i] = min;
-        count[i] = max - min;
+        if (n)
+            weights[o + largest] += one - sum;
     }
-    return { start, count, weights, size };
+    return { start, weights, taps };
 }
+const littleEndian = new Uint8Array(new Uint32Array([1]).buffer)[0] === 1;
 export function resample(src, width, height, outWidth, outHeight, filter, out) {
-    let plane = new Float32Array(outWidth * height * 4);
-    if (outWidth !== width) {
-        const { start, count, weights, size } = coefficients(width, outWidth, filter);
-        for (let y = 0, o = 0; y < height; y++) {
-            const row = y * width * 4;
-            for (let x = 0; x < outWidth; x++, o += 4) {
-                let r = 0, g = 0, b = 0, a = 0;
-                for (let k = 0, s = row + start[x] * 4, w = x * size, n = count[x]; k < n; k++, s += 4) {
+    if (littleEndian && filter.support <= 1 && resampleOpaque(src, width, height, outWidth, outHeight, filter, out))
+        return;
+    resamplePremultiplied(src, width, height, outWidth, outHeight, filter, out);
+}
+function resampleOpaque(src, width, height, outWidth, outHeight, filter, out) {
+    const pixels = new Int32Array(src.buffer, src.byteOffset, width * height);
+    let all = -1;
+    for (let x = 0, last = (height - 1) * width; x < width; x++)
+        all &= pixels[x] & pixels[last + x];
+    if (all >>> 24 !== 255)
+        return false;
+    const lanes = new Int32Array(width * outHeight * 2);
+    if (outHeight === height) {
+        for (let i = 0, o = 0; i < pixels.length; i++, o += 2) {
+            const p = pixels[i];
+            all &= p;
+            lanes[o] = (p & 0xff00ff) << 8;
+            lanes[o + 1] = (p & 0xff00) | 0;
+        }
+    }
+    else {
+        let coefficientsV = coefficients(height, outHeight, filter, 8);
+        const swar = coefficientsV.taps <= 4;
+        if (!swar)
+            coefficientsV = coefficients(height, outHeight, filter, BITS);
+        const { start, weights, taps } = coefficientsV;
+        for (let y = 0, o = 0; y < outHeight; y++) {
+            const w = y * taps, r0 = start[y] * width;
+            if (swar && taps === 4) {
+                const w0 = weights[w], w1 = weights[w + 1], w2 = weights[w + 2], w3 = weights[w + 3];
+                const r1 = r0 + width, r2 = r1 + width, r3 = r2 + width;
+                for (let x = 0; x < width; x++, o += 2) {
+                    const p0 = pixels[r0 + x], p1 = pixels[r1 + x], p2 = pixels[r2 + x], p3 = pixels[r3 + x];
+                    all &= p0 & p1 & p2 & p3;
+                    lanes[o] = Math.imul(p0 & 0xff00ff, w0) + Math.imul(p1 & 0xff00ff, w1) + Math.imul(p2 & 0xff00ff, w2) + Math.imul(p3 & 0xff00ff, w3);
+                    lanes[o + 1] = (p0 >> 8 & 255) * w0 + (p1 >> 8 & 255) * w1 + (p2 >> 8 & 255) * w2 + (p3 >> 8 & 255) * w3;
+                }
+            }
+            else if (swar && taps === 3) {
+                const w0 = weights[w], w1 = weights[w + 1], w2 = weights[w + 2], r1 = r0 + width, r2 = r1 + width;
+                for (let x = 0; x < width; x++, o += 2) {
+                    const p0 = pixels[r0 + x], p1 = pixels[r1 + x], p2 = pixels[r2 + x];
+                    all &= p0 & p1 & p2;
+                    lanes[o] = Math.imul(p0 & 0xff00ff, w0) + Math.imul(p1 & 0xff00ff, w1) + Math.imul(p2 & 0xff00ff, w2);
+                    lanes[o + 1] = (p0 >> 8 & 255) * w0 + (p1 >> 8 & 255) * w1 + (p2 >> 8 & 255) * w2;
+                }
+            }
+            else if (swar && taps === 2) {
+                const w0 = weights[w], w1 = weights[w + 1], r1 = r0 + width;
+                for (let x = 0; x < width; x++, o += 2) {
+                    const p0 = pixels[r0 + x], p1 = pixels[r1 + x];
+                    all &= p0 & p1;
+                    lanes[o] = Math.imul(p0 & 0xff00ff, w0) + Math.imul(p1 & 0xff00ff, w1);
+                    lanes[o + 1] = (p0 >> 8 & 255) * w0 + (p1 >> 8 & 255) * w1;
+                }
+            }
+            else if (swar) {
+                for (let x = 0; x < width; x++, o += 2) {
+                    let rb = 0, g = 0;
+                    for (let k = 0, s = r0 + x; k < taps; k++, s += width) {
+                        const p = pixels[s], wk = weights[w + k];
+                        all &= p;
+                        rb += Math.imul(p & 0xff00ff, wk);
+                        g += (p >> 8 & 255) * wk;
+                    }
+                    lanes[o] = rb;
+                    lanes[o + 1] = g;
+                }
+            }
+            else {
+                for (let x = 0; x < width; x++, o += 2) {
+                    let r = 0, g = 0, b = 0, k = 0, s = r0 + x;
+                    for (; k + 1 < taps; k += 2, s += width * 2) {
+                        const p = pixels[s], q = pixels[s + width], w0 = weights[w + k], w1 = weights[w + k + 1];
+                        all &= p & q;
+                        r += (p & 255) * w0 + (q & 255) * w1;
+                        g += (p >> 8 & 255) * w0 + (q >> 8 & 255) * w1;
+                        b += (p >> 16 & 255) * w0 + (q >> 16 & 255) * w1;
+                    }
+                    if (k < taps) {
+                        const p = pixels[s], w0 = weights[w + k];
+                        all &= p;
+                        r += (p & 255) * w0;
+                        g += (p >> 8 & 255) * w0;
+                        b += (p >> 16 & 255) * w0;
+                    }
+                    lanes[o] = (r + 32 >> 6) | (b + 32 >> 6) << 16;
+                    lanes[o + 1] = g + 32 >> 6;
+                }
+            }
+        }
+    }
+    if (all >>> 24 !== 255)
+        return false;
+    const result = new Int32Array(out.buffer, out.byteOffset, outWidth * outHeight);
+    if (outWidth === width) {
+        for (let i = 0, o = 0; i < result.length; i++, o += 2) {
+            const rb = lanes[o], g = lanes[o + 1];
+            result[i] = ((rb & 0xffff) + 128 >> 8) | (g + 128 >> 8) << 8 | ((rb >>> 16) + 128 >> 8) << 16 | 0xff000000;
+        }
+        return true;
+    }
+    const R = 1 << 7 + BITS, S = 8 + BITS;
+    const { start, weights, taps } = coefficients(width, outWidth, filter, BITS);
+    for (let y = 0, o = 0; y < outHeight; y++) {
+        const row = y * width * 2;
+        if (taps === 4) {
+            for (let x = 0; x < outWidth; x++, o++) {
+                const s = row + start[x] * 2, w = x * 4;
+                const a0 = lanes[s], a1 = lanes[s + 2], a2 = lanes[s + 4], a3 = lanes[s + 6];
+                const w0 = weights[w], w1 = weights[w + 1], w2 = weights[w + 2], w3 = weights[w + 3];
+                const r = (a0 & 0xffff) * w0 + (a1 & 0xffff) * w1 + (a2 & 0xffff) * w2 + (a3 & 0xffff) * w3;
+                const b = (a0 >>> 16) * w0 + (a1 >>> 16) * w1 + (a2 >>> 16) * w2 + (a3 >>> 16) * w3;
+                const g = lanes[s + 1] * w0 + lanes[s + 3] * w1 + lanes[s + 5] * w2 + lanes[s + 7] * w3;
+                result[o] = (r + R >> S) | (g + R >> S) << 8 | (b + R >> S) << 16 | 0xff000000;
+            }
+        }
+        else if (taps === 2) {
+            for (let x = 0; x < outWidth; x++, o++) {
+                const s = row + start[x] * 2, w = x * 2;
+                const a0 = lanes[s], a1 = lanes[s + 2], w0 = weights[w], w1 = weights[w + 1];
+                const r = (a0 & 0xffff) * w0 + (a1 & 0xffff) * w1;
+                const b = (a0 >>> 16) * w0 + (a1 >>> 16) * w1;
+                const g = lanes[s + 1] * w0 + lanes[s + 3] * w1;
+                result[o] = (r + R >> S) | (g + R >> S) << 8 | (b + R >> S) << 16 | 0xff000000;
+            }
+        }
+        else {
+            for (let x = 0; x < outWidth; x++, o++) {
+                let r = 0, g = 0, b = 0, k = 0, s = row + start[x] * 2, w = x * taps;
+                for (; k + 1 < taps; k += 2, s += 4) {
+                    const a0 = lanes[s], a1 = lanes[s + 2], w0 = weights[w + k], w1 = weights[w + k + 1];
+                    r += (a0 & 0xffff) * w0 + (a1 & 0xffff) * w1;
+                    b += (a0 >>> 16) * w0 + (a1 >>> 16) * w1;
+                    g += lanes[s + 1] * w0 + lanes[s + 3] * w1;
+                }
+                if (k < taps) {
+                    const a0 = lanes[s], w0 = weights[w + k];
+                    r += (a0 & 0xffff) * w0;
+                    b += (a0 >>> 16) * w0;
+                    g += lanes[s + 1] * w0;
+                }
+                result[o] = (r + R >> S) | (g + R >> S) << 8 | (b + R >> S) << 16 | 0xff000000;
+            }
+        }
+    }
+    return true;
+}
+function resamplePremultiplied(src, width, height, outWidth, outHeight, filter, out) {
+    const plane = new Int32Array(width * outHeight * 4);
+    if (outHeight === height) {
+        for (let s = 0; s < src.length; s += 4) {
+            const a = src[s + 3];
+            plane[s] = src[s] * a;
+            plane[s + 1] = src[s + 1] * a;
+            plane[s + 2] = src[s + 2] * a;
+            plane[s + 3] = a * 255;
+        }
+    }
+    else {
+        const { start, weights, taps } = coefficients(height, outHeight, filter, BITS);
+        const stride = width * 4, H = ONE >> 1;
+        for (let y = 0, o = 0; y < outHeight; y++) {
+            const w = y * taps, r0 = start[y] * stride;
+            for (let x = 0; x < stride; x += 4, o += 4) {
+                let r = 0, g = 0, b = 0, a = 0, k = 0, s = r0 + x;
+                for (; k + 1 < taps; k += 2, s += stride * 2) {
+                    const t = s + stride, wa = weights[w + k] * src[s + 3], wb = weights[w + k + 1] * src[t + 3];
+                    r += src[s] * wa + src[t] * wb;
+                    g += src[s + 1] * wa + src[t + 1] * wb;
+                    b += src[s + 2] * wa + src[t + 2] * wb;
+                    a += wa + wb;
+                }
+                if (k < taps) {
                     const wa = weights[w + k] * src[s + 3];
                     r += src[s] * wa;
                     g += src[s + 1] * wa;
                     b += src[s + 2] * wa;
                     a += wa;
                 }
-                plane[o] = r / 255;
-                plane[o + 1] = g / 255;
-                plane[o + 2] = b / 255;
-                plane[o + 3] = a;
+                plane[o] = r + H >> BITS;
+                plane[o + 1] = g + H >> BITS;
+                plane[o + 2] = b + H >> BITS;
+                plane[o + 3] = a * 255 + H >> BITS;
             }
         }
     }
-    else {
-        for (let s = 0; s < plane.length; s += 4) {
-            const a = src[s + 3];
-            plane[s] = src[s] * a / 255;
-            plane[s + 1] = src[s + 1] * a / 255;
-            plane[s + 2] = src[s + 2] * a / 255;
-            plane[s + 3] = a;
-        }
-    }
-    if (outHeight !== height) {
-        const { start, count, weights, size } = coefficients(height, outHeight, filter);
-        const next = new Float32Array(outWidth * outHeight * 4);
-        const stride = outWidth * 4;
-        for (let y = 0; y < outHeight; y++) {
-            const o = y * stride, n = count[y], w = y * size;
-            const s0 = start[y] * stride, s1 = s0 + stride, s2 = s1 + stride, s3 = s2 + stride;
-            const w0 = weights[w], w1 = weights[w + 1], w2 = weights[w + 2], w3 = weights[w + 3];
-            if (n === 1)
-                for (let x = 0; x < stride; x++)
-                    next[o + x] = 0 + plane[s0 + x] * w0;
-            else if (n === 2)
-                for (let x = 0; x < stride; x++)
-                    next[o + x] = Math.fround(0 + plane[s0 + x] * w0) + plane[s1 + x] * w1;
-            else if (n === 3) {
-                for (let x = 0; x < stride; x++)
-                    next[o + x] = Math.fround(Math.fround(0 + plane[s0 + x] * w0) + plane[s1 + x] * w1) + plane[s2 + x] * w2;
-            }
-            else if (n === 4) {
-                for (let x = 0; x < stride; x++)
-                    next[o + x] = Math.fround(Math.fround(Math.fround(0 + plane[s0 + x] * w0) + plane[s1 + x] * w1) + plane[s2 + x] * w2) + plane[s3 + x] * w3;
+    const { start, weights, taps } = outWidth === width ? { start: null, weights: null, taps: 0 } : coefficients(width, outWidth, filter, BITS);
+    for (let y = 0, o = 0; y < outHeight; y++) {
+        const row = y * width * 4;
+        for (let x = 0; x < outWidth; x++, o += 4) {
+            let r = 0, g = 0, b = 0, a = 0;
+            if (!start || !weights) {
+                const s = row + x * 4;
+                r = plane[s] * ONE;
+                g = plane[s + 1] * ONE;
+                b = plane[s + 2] * ONE;
+                a = plane[s + 3] * ONE;
             }
             else {
-                for (let x = 0; x < stride; x++) {
-                    let sum = 0;
-                    for (let k = 0, s = s0 + x; k < n; k++, s += stride)
-                        sum = Math.fround(sum + plane[s] * weights[w + k]);
-                    next[o + x] = sum;
+                let k = 0, s = row + start[x] * 4, w = x * taps;
+                for (; k + 1 < taps; k += 2, s += 8) {
+                    const w0 = weights[w + k], w1 = weights[w + k + 1];
+                    r += plane[s] * w0 + plane[s + 4] * w1;
+                    g += plane[s + 1] * w0 + plane[s + 5] * w1;
+                    b += plane[s + 2] * w0 + plane[s + 6] * w1;
+                    a += plane[s + 3] * w0 + plane[s + 7] * w1;
+                }
+                if (k < taps) {
+                    const w0 = weights[w + k];
+                    r += plane[s] * w0;
+                    g += plane[s + 1] * w0;
+                    b += plane[s + 2] * w0;
+                    a += plane[s + 3] * w0;
                 }
             }
+            if (a < 127.5 * ONE) {
+                out[o] = out[o + 1] = out[o + 2] = out[o + 3] = 0;
+                continue;
+            }
+            const f = 255 / Math.min(a, 65025 * ONE);
+            out[o] = r * f;
+            out[o + 1] = g * f;
+            out[o + 2] = b * f;
+            out[o + 3] = a / (255 * ONE);
         }
-        plane = next;
-    }
-    for (let i = 0; i < plane.length; i += 4) {
-        const a = plane[i + 3];
-        if (a < 0.5) {
-            out[i] = out[i + 1] = out[i + 2] = out[i + 3] = 0;
-            continue;
-        }
-        const f = 255 / Math.min(255, a);
-        out[i] = plane[i] * f;
-        out[i + 1] = plane[i + 1] * f;
-        out[i + 2] = plane[i + 2] * f;
-        out[i + 3] = a;
     }
 }

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '3.2.0';
+export const VERSION = '3.2.1';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "imagescript",
-  "version": "3.2.0",
+  "version": "3.2.1",
   "description": "zero-dependency javascript image manipulation",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",