imagescript 3.1.0 → 3.2.1

package/dist/util/optimize.js

@@ -0,0 +1,264 @@
+const ALPHA = new Int32Array(new Uint8Array([0, 0, 0, 255]).buffer)[0];
+const ALPHA_COST = 4 / 3;
+export function optimize(frames, width, height, { replace, even, alpha, palette, cover }) {
+    const size = width * height * 4;
+    const canvas = new Uint8Array(size), canvas32 = new Int32Array(canvas.buffer);
+    const shown = new Uint8Array(size), shown32 = new Int32Array(shown.buffer);
+    const output = [];
+    const state = { canvas32, shown32, width, replace };
+    let opaque = true, denseTotal = 0, chosenTotal = 0;
+    const add = (duration) => {
+        let changed = bounds(state, { x: 0, y: 0, width, height });
+        if (!changed) {
+            if (output.length)
+                output[output.length - 1].duration += duration;
+            else {
+                output.push(empty(duration));
+                opaque = false;
+            }
+            return;
+        }
+        if (even)
+            changed = evenArea(changed);
+        let area = sparse(state, changed);
+        let blend = true;
+        if (area.unblendable && replace)
+            blend = false;
+        else if (area.unblendable) {
+            const last = output[output.length - 1];
+            grow(last, union(last, area.unblendable));
+            last.dispose = true;
+            clear(shown, width, last);
+            changed = bounds(state, { x: 0, y: 0, width, height });
+            if (!changed)
+                return void output.push(empty(duration));
+            if (even)
+                changed = evenArea(changed);
+            area = sparse(state, changed);
+        }
+        const { x, y, width: w, height: h } = changed;
+        const pixels = area.pixels;
+        if (!output.length && (w !== width || h !== height))
+            opaque = false;
+        if (!area.denseOpaque)
+            opaque = false;
+        const sparseCost = alpha === 'frame' && area.denseOpaque ? area.sparseChanges * ALPHA_COST : area.sparseChanges;
+        const dense = !blend || area.denseChanges < sparseCost
+            || (palette !== undefined && colors(new Int32Array(pixels.buffer), w, { x: 0, y: 0, width: w, height: h }, palette + 1) > palette
+                && colors(canvas32, width, changed, palette + 1) <= palette);
+        denseTotal += area.denseChanges;
+        chosenTotal += dense ? area.denseChanges : area.sparseChanges;
+        if (dense) {
+            for (let row = 0; row < h; row++)
+                pixels.set(canvas.subarray(((y + row) * width + x) * 4, ((y + row) * width + x + w) * 4), row * w * 4);
+            if (replace)
+                blend = false;
+        }
+        for (let row = 0; row < h; row++) {
+            const start = ((y + row) * width + x) * 4;
+            shown.set(canvas.subarray(start, start + w * 4), start);
+        }
+        output.push({ x, y, width: w, height: h, duration, dispose: false, blend, pixels });
+    };
+    let cleared = { x: 0, y: 0, width, height };
+    for (const f of frames) {
+        const saved = f.dispose === 2 ? canvas.slice() : null;
+        const area = clip(f, width, height);
+        if (cleared && contains(cleared, area))
+            copy(canvas, width, f, area);
+        else
+            draw(canvas, width, height, f);
+        cleared = null;
+        add(f.duration);
+        if (f.dispose === 1) {
+            clear(canvas, width, area);
+            cleared = area;
+        }
+        else if (saved)
+            canvas.set(saved);
+    }
+    if (typeof alpha === 'function' && opaque && output.some(f => f.blend) && denseTotal < chosenTotal * alpha(output)) {
+        shown.fill(0);
+        for (const f of output) {
+            const pixels32 = new Int32Array(f.pixels.buffer, f.pixels.byteOffset, f.width * f.height);
+            for (let row = 0, k = 0; row < f.height; row++, k += f.width) {
+                const start = (f.y + row) * width + f.x;
+                if (!f.blend)
+                    shown32.set(pixels32.subarray(k, k + f.width), start);
+                else
+                    for (let i = k, p = start, end = k + f.width; i < end; i++, p++) {
+                        if ((pixels32[i] & ALPHA) === 0)
+                            pixels32[i] = shown32[p];
+                        else
+                            shown32[p] = pixels32[i];
+                    }
+            }
+            f.blend = false;
+        }
+    }
+    if (cover && output.length)
+        grow(output[0], { x: 0, y: 0, width, height });
+    return output;
+}
+function colors(image32, width, { x, y, width: w, height: h }, limit) {
+    const seen = new Set();
+    for (let row = y; row < y + h; row++) {
+        let previous;
+        for (let p = row * width + x, end = p + w; p < end; p++) {
+            const value = image32[p];
+            if (value === previous)
+                continue;
+            previous = value;
+            seen.add(value);
+            if (seen.size >= limit)
+                return seen.size;
+        }
+    }
+    return seen.size;
+}
+const empty = (duration) => ({ x: 0, y: 0, width: 1, height: 1, duration, dispose: false, blend: true, pixels: new Uint8Array(4) });
+function clip(r, width, height) {
+    const x = Math.max(0, r.x), y = Math.max(0, r.y);
+    return { x, y, width: Math.max(0, Math.min(width, r.x + r.width) - x), height: Math.max(0, Math.min(height, r.y + r.height) - y) };
+}
+function contains(a, b) {
+    return b.x >= a.x && b.y >= a.y && b.x + b.width <= a.x + a.width && b.y + b.height <= a.y + a.height;
+}
+function union(a, b) {
+    const x = Math.min(a.x, b.x), y = Math.min(a.y, b.y);
+    return { x, y, width: Math.max(a.x + a.width, b.x + b.width) - x, height: Math.max(a.y + a.height, b.y + b.height) - y };
+}
+function evenArea({ x, y, width, height }) {
+    return { x: x & ~1, y: y & ~1, width: width + (x & 1), height: height + (y & 1) };
+}
+function sparse({ canvas32, shown32, width, replace }, { x, y, width: w, height: h }) {
+    const pixels = new Uint8Array(w * h * 4), pixels32 = new Int32Array(pixels.buffer);
+    let sparseChanges = 0, denseChanges = 0, lastSparse = -1, lastDense = -1;
+    let left = w, right = -1, top = h, bottom = -1, translucent = 0;
+    for (let row = 0, k = 0; row < h; row++) {
+        const start = (y + row) * width + x;
+        for (let i = 0, p = start; i < w; i++, p++, k++) {
+            const value = canvas32[p], before = shown32[p];
+            if (value === before || ((value | before) & ALPHA) === 0) {
+                if (lastSparse !== 0)
+                    sparseChanges++;
+                lastSparse = 0;
+            }
+            else {
+                pixels32[k] = value;
+                if (value !== lastSparse)
+                    sparseChanges++;
+                lastSparse = value;
+                if ((value & ALPHA) !== ALPHA && (replace || (before & ALPHA) !== 0)) {
+                    if (i < left)
+                        left = i;
+                    if (i > right)
+                        right = i;
+                    if (row < top)
+                        top = row;
+                    bottom = row;
+                }
+            }
+            if (value !== lastDense) {
+                denseChanges++;
+                translucent |= ~value & ALPHA;
+            }
+            lastDense = value;
+        }
+    }
+    const unblendable = right < 0 ? null : { x: x + left, y: y + top, width: right - left + 1, height: bottom - top + 1 };
+    return { pixels, sparseChanges, denseChanges, unblendable, denseOpaque: translucent === 0 };
+}
+function bounds({ canvas32, shown32, width }, area) {
+    const x0 = area.x, x1 = area.x + area.width, y0 = area.y, y1 = area.y + area.height;
+    const test = (p) => {
+        const c = canvas32[p], s = shown32[p];
+        return c !== s && ((c | s) & ALPHA) !== 0;
+    };
+    const rowHas = (y, from, to) => {
+        for (let x = from, p = y * width + from; x < to; x++, p++)
+            if (test(p))
+                return x;
+        return -1;
+    };
+    let top = y0, first = -1;
+    for (; top < y1; top++)
+        if ((first = rowHas(top, x0, x1)) >= 0)
+            break;
+    if (top === y1)
+        return null;
+    let bottom = y1 - 1;
+    while (bottom > top && rowHas(bottom, x0, x1) < 0)
+        bottom--;
+    let left = first, right = first;
+    for (let y = top; y <= bottom; y++) {
+        if (left > x0) {
+            const x = rowHas(y, x0, left);
+            if (x >= 0)
+                left = x;
+        }
+        for (let x = x1 - 1, p = y * width + x; x > right; x--, p--)
+            if (test(p)) {
+                right = x;
+                break;
+            }
+    }
+    return { x: left, y: top, width: right - left + 1, height: bottom - top + 1 };
+}
+function draw(canvas, width, height, f) {
+    const { x: x0, y: y0, width: w, height: h } = clip(f, width, height);
+    const pixels = f.pixels.byteOffset % 4 ? f.pixels.slice() : f.pixels;
+    const src = new Int32Array(pixels.buffer, pixels.byteOffset, f.width * f.height);
+    const dst = new Int32Array(canvas.buffer, canvas.byteOffset, width * height);
+    for (let y = y0; y < y0 + h; y++)
+        for (let x = x0, s = (y - f.y) * f.width + x - f.x, d = y * width + x; x < x0 + w; x++, s++, d++) {
+            let n = 0;
+            while (n < x0 + w - x && (src[s + n] & ALPHA) === ALPHA)
+                n++;
+            if (n) {
+                if (n >= 16)
+                    dst.set(src.subarray(s, s + n), d);
+                else
+                    for (let i = 0; i < n; i++)
+                        dst[d + i] = src[s + i];
+                x += n - 1;
+                s += n - 1;
+                d += n - 1;
+                continue;
+            }
+            const value = src[s], alpha = value & ALPHA;
+            if (alpha === 0)
+                continue;
+            if (alpha === ALPHA || (dst[d] & ALPHA) === 0)
+                dst[d] = value;
+            else {
+                const sa = pixels[s * 4 + 3], da = canvas[d * 4 + 3];
+                const u = sa * 255, v = (255 - sa) * da, al = u + v;
+                for (let c = 0; c < 3; c++)
+                    canvas[d * 4 + c] = (pixels[s * 4 + c] * u + canvas[d * 4 + c] * v) / al | 0;
+                canvas[d * 4 + 3] = al / 255 | 0;
+            }
+        }
+}
+function copy(canvas, width, f, { x, y, width: w, height: h }) {
+    const canvas32 = new Int32Array(canvas.buffer, canvas.byteOffset, width * (y + h));
+    for (let row = y; row < y + h; row++) {
+        const s = ((row - f.y) * f.width + x - f.x) * 4, d = row * width + x;
+        canvas.set(f.pixels.subarray(s, s + w * 4), d * 4);
+        for (let p = d; p < d + w; p++)
+            if ((canvas32[p] & ALPHA) === 0)
+                canvas32[p] = 0;
+    }
+}
+function clear(canvas, width, r) {
+    for (let y = r.y; y < r.y + r.height; y++)
+        canvas.fill(0, (y * width + r.x) * 4, (y * width + r.x + r.width) * 4);
+}
+function grow(frame, area) {
+    if (area.x === frame.x && area.y === frame.y && area.width === frame.width && area.height === frame.height)
+        return;
+    const pixels = new Uint8Array(area.width * area.height * 4);
+    for (let row = 0; row < frame.height; row++)
+        pixels.set(frame.pixels.subarray(row * frame.width * 4, (row + 1) * frame.width * 4), ((frame.y - area.y + row) * area.width + frame.x - area.x) * 4);
+    Object.assign(frame, area, { pixels });
+}

package/dist/util/options.js

@@ -0,0 +1,3 @@
+export function isOptions(value) {
+    return typeof value === 'object' && value !== null && !ArrayBuffer.isView(value);
+}

package/dist/util/resample.js

@@ -12,88 +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);
-    const horizontal = outWidth !== width ? coefficients(width, outWidth, filter) : null;
-    for (let y = 0; y < height; y++) {
-        const row = y * width * 4;
-        for (let x = 0; x < outWidth; x++) {
-            let r = 0, g = 0, b = 0, a = 0;
-            if (horizontal) {
-                const { start, count, weights, size } = horizontal;
-                for (let k = 0, s = row + start[x] * 4; k < count[x]; k++, s += 4) {
-                    const wa = weights[x * size + k] * src[s + 3];
-                    r += src[s] * wa;
-                    g += src[s + 1] * wa;
-                    b += src[s + 2] * wa;
-                    a += wa;
+    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 {
-                const s = row + x * 4;
-                a = src[s + 3];
-                r = src[s] * a;
-                g = src[s + 1] * a;
-                b = src[s + 2] * a;
+                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;
             }
-            const o = (y * outWidth + x) * 4;
-            plane[o] = r / 255;
-            plane[o + 1] = g / 255;
-            plane[o + 2] = b / 255;
-            plane[o + 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;
-            for (let k = 0; k < count[y]; k++) {
-                const w = weights[y * size + k];
-                const s = (start[y] + k) * stride;
-                for (let x = 0; x < stride; x++)
-                    next[o + x] += plane[s + x] * w;
+    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 + H >> BITS;
+                plane[o + 1] = g + H >> BITS;
+                plane[o + 2] = b + H >> BITS;
+                plane[o + 3] = a * 255 + H >> BITS;
             }
         }
-        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 { 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 {
+                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);
         }
-        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/util/utf8.js

@@ -1,55 +1,8 @@
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
 export function encode(text) {
-    const out = [];
-    for (const char of text) {
-        const c = char.codePointAt(0);
-        if (c < 0x80)
-            out.push(c);
-        else if (c < 0x800)
-            out.push(0xc0 | c >> 6, 0x80 | c & 63);
-        else if (c < 0x10000)
-            out.push(0xe0 | c >> 12, 0x80 | c >> 6 & 63, 0x80 | c & 63);
-        else
-            out.push(0xf0 | c >> 18, 0x80 | c >> 12 & 63, 0x80 | c >> 6 & 63, 0x80 | c & 63);
-    }
-    return Uint8Array.from(out);
+    return encoder.encode(text);
 }
 export function decode(bytes) {
-    let out = '';
-    let i = bytes[0] === 0xef && bytes[1] === 0xbb && bytes[2] === 0xbf ? 3 : 0;
-    while (i < bytes.length) {
-        const b = bytes[i++];
-        let c, extra;
-        if (b < 0x80) {
-            c = b;
-            extra = 0;
-        }
-        else if (b >= 0xc2 && b < 0xe0) {
-            c = b & 31;
-            extra = 1;
-        }
-        else if (b >= 0xe0 && b < 0xf0) {
-            c = b & 15;
-            extra = 2;
-        }
-        else if (b >= 0xf0 && b < 0xf5) {
-            c = b & 7;
-            extra = 3;
-        }
-        else {
-            out += '�';
-            continue;
-        }
-        let valid = true;
-        for (let k = 0; k < extra; k++) {
-            const next = bytes[i];
-            if (next === undefined || (next & 0xc0) !== 0x80) {
-                valid = false;
-                break;
-            }
-            c = c << 6 | next & 63;
-            i++;
-        }
-        out += valid && c <= 0x10ffff ? String.fromCodePoint(c) : '�';
-    }
-    return out;
+    return decoder.decode(bytes);
 }

package/dist/version.js

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