imagescript 3.2.0 → 3.3.0

package/dist/util/resample.js

@@ -1,3 +1,10 @@
+/*!
+ * The filter coefficients and the box, bilinear and bicubic filters are translated from Pillow's
+ * src/libImaging/Resample.c (precompute_coeffs, box_filter, bilinear_filter, bicubic_filter). Copyright © 1997-2011 by
+ * Secret Labs AB, © 1995-2011 by Fredrik Lundh and contributors, © 2010 by Jeffrey 'Alex' Clark and contributors,
+ * MIT-CMU License (see THIRD_PARTY_NOTICES.md)
+ */
+import { littleEndian, isOpaque, premultiply8, unpremultiply8 } from "./alpha.js";
 export const BOX = { support: 0.5, weight: x => x >= -0.5 && x < 0.5 ? 1 : 0 };
 export const TRIANGLE = { support: 1, weight: x => Math.max(0, 1 - Math.abs(x)) };
 export const CUBIC = {
@@ -12,106 +19,379 @@ export const CUBIC = {
         return 0;
     }
 };
-function coefficients(inSize, outSize, filter) {
+const BITS = 14;
+const ONE = 1 << BITS;
+function coefficients(inSize, outSize, filter, bits, pad = false) {
     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]);
+    }
+    if (pad)
+        taps = Math.min(inSize, taps <= 2 ? 2 : taps <= 4 ? 4 : taps);
+    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;
-        }
-        if (total !== 0)
-            for (let k = 0; k < max - min; k++)
-                weights[i * size + k] /= total;
-        start[i] = min;
-        count[i] = max - min;
+        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 (n)
+            weights[o + largest] += one - sum;
+    }
+    return { start, weights, taps };
+}
+const FAST_TAPS = 4;
+export function resample(src, width, height, outWidth, outHeight, filter, out, fast = false) {
+    if (littleEndian && filter.support <= 1) {
+        if (fast && resampleFast(src, width, height, outWidth, outHeight, filter, out))
+            return;
+        if (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 { start, count, weights, size };
+    return true;
 }
-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) {
+function packedSum(pixels, s, step, weights, w, taps) {
+    let rb = 0x800080, ga = 0x800080;
+    for (let k = 0; k < taps; k++, s += step) {
+        const p = pixels[s], wk = weights[w + k];
+        rb += Math.imul(p & 0xff00ff, wk);
+        ga += Math.imul(p >>> 8 & 0xff00ff, wk);
+    }
+    return (rb >>> 8 & 0xff00ff) | (ga & 0xff00ff00);
+}
+function verticalFast(pixels, rows, width, outHeight, { start, weights, taps }) {
+    let all = -1;
+    for (let y = 0, o = 0; y < outHeight; y++) {
+        const w = y * taps, r0 = start[y] * width;
+        if (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++) {
+                const p0 = pixels[r0 + x], p1 = pixels[r1 + x], p2 = pixels[r2 + x], p3 = pixels[r3 + x];
+                all &= p0 & p1 & p2 & p3;
+                const rb = Math.imul(p0 & 0xff00ff, w0) + Math.imul(p1 & 0xff00ff, w1) + Math.imul(p2 & 0xff00ff, w2) + Math.imul(p3 & 0xff00ff, w3) + 0x800080;
+                const ga = Math.imul(p0 >>> 8 & 0xff00ff, w0) + Math.imul(p1 >>> 8 & 0xff00ff, w1) + Math.imul(p2 >>> 8 & 0xff00ff, w2) + Math.imul(p3 >>> 8 & 0xff00ff, w3) + 0x800080;
+                rows[o] = (rb >>> 8 & 0xff00ff) | (ga & 0xff00ff00);
+            }
+        }
+        else if (taps === 2) {
+            const w0 = weights[w], w1 = weights[w + 1], r1 = r0 + width;
+            for (let x = 0; x < width; x++, o++) {
+                const p0 = pixels[r0 + x], p1 = pixels[r1 + x];
+                all &= p0 & p1;
+                const rb = Math.imul(p0 & 0xff00ff, w0) + Math.imul(p1 & 0xff00ff, w1) + 0x800080;
+                const ga = Math.imul(p0 >>> 8 & 0xff00ff, w0) + Math.imul(p1 >>> 8 & 0xff00ff, w1) + 0x800080;
+                rows[o] = (rb >>> 8 & 0xff00ff) | (ga & 0xff00ff00);
+            }
+        }
+        else {
+            for (let x = 0; x < width; x++, o++) {
+                for (let k = 0, s = r0 + x; k < taps; k++, s += width)
+                    all &= pixels[s];
+                rows[o] = packedSum(pixels, r0 + x, width, weights, w, taps);
+            }
+        }
+    }
+    return all;
+}
+function horizontalFast(rows, result, width, outWidth, outHeight, { start, weights, taps }) {
+    for (let y = 0, o = 0; y < outHeight; y++) {
+        const row = y * width;
+        if (taps === 4) {
+            for (let x = 0; x < outWidth; x++, o++) {
+                const s = row + start[x], w = x * 4;
+                const p0 = rows[s], p1 = rows[s + 1], p2 = rows[s + 2], p3 = rows[s + 3];
+                const w0 = weights[w], w1 = weights[w + 1], w2 = weights[w + 2], w3 = weights[w + 3];
+                const rb = Math.imul(p0 & 0xff00ff, w0) + Math.imul(p1 & 0xff00ff, w1) + Math.imul(p2 & 0xff00ff, w2) + Math.imul(p3 & 0xff00ff, w3) + 0x800080;
+                const ga = Math.imul(p0 >>> 8 & 0xff00ff, w0) + Math.imul(p1 >>> 8 & 0xff00ff, w1) + Math.imul(p2 >>> 8 & 0xff00ff, w2) + Math.imul(p3 >>> 8 & 0xff00ff, w3) + 0x800080;
+                result[o] = (rb >>> 8 & 0xff00ff) | (ga & 0xff00ff00);
+            }
+        }
+        else if (taps === 2) {
+            for (let x = 0; x < outWidth; x++, o++) {
+                const s = row + start[x], w = x * 2;
+                const p0 = rows[s], p1 = rows[s + 1], w0 = weights[w], w1 = weights[w + 1];
+                const rb = Math.imul(p0 & 0xff00ff, w0) + Math.imul(p1 & 0xff00ff, w1) + 0x800080;
+                const ga = Math.imul(p0 >>> 8 & 0xff00ff, w0) + Math.imul(p1 >>> 8 & 0xff00ff, w1) + 0x800080;
+                result[o] = (rb >>> 8 & 0xff00ff) | (ga & 0xff00ff00);
+            }
+        }
+        else {
+            for (let x = 0; x < outWidth; x++, o++)
+                result[o] = packedSum(rows, row + start[x], 1, weights, x * taps, taps);
+        }
+    }
+}
+function resampleFast(src, width, height, outWidth, outHeight, filter, out) {
+    const vertical = coefficients(height, outHeight, filter, 8, true), horizontal = coefficients(width, outWidth, filter, 8, true);
+    if (vertical.taps > FAST_TAPS || horizontal.taps > FAST_TAPS)
+        return false;
+    let pixels = new Int32Array(src.buffer, src.byteOffset, width * height), all = -1;
+    for (let x = 0, last = (height - 1) * width; x < width; x++)
+        all &= pixels[x] & pixels[last + x];
+    let opaque = all >>> 24 === 255 && (outHeight !== height || isOpaque(src));
+    const premultiplied = () => {
+        const bitmap = new Uint8ClampedArray(src.length);
+        premultiply8(src, bitmap);
+        return new Int32Array(bitmap.buffer);
+    };
+    if (!opaque)
+        pixels = premultiplied();
+    let rows = pixels;
+    if (outHeight !== height) {
+        rows = new Int32Array(width * outHeight);
+        if (verticalFast(pixels, rows, width, outHeight, vertical) >>> 24 !== 255 && opaque) {
+            opaque = false;
+            verticalFast(premultiplied(), rows, width, outHeight, vertical);
+        }
+    }
+    const result = new Int32Array(out.buffer, out.byteOffset, outWidth * outHeight);
+    if (outWidth === width)
+        result.set(rows);
+    else
+        horizontalFast(rows, result, width, outWidth, outHeight, horizontal);
+    if (!opaque)
+        unpremultiply8(out);
+    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/util/rotate.js

@@ -0,0 +1,43 @@
+import { littleEndian, isOpaque, premultiply8, unpremultiply8 } from "./alpha.js";
+function span(start, step, limit, from, to) {
+    if (step === 0)
+        return start >= 0 && start < limit ? [from, to] : [from, from];
+    const a = -start / step, b = (limit - start) / step;
+    const lo = Math.floor(Math.min(a, b)) - 1, hi = Math.ceil(Math.max(a, b)) + 1;
+    return [Math.max(from, lo), Math.max(Math.max(from, lo), Math.min(to, hi))];
+}
+export function rotateBilinear(src, width, height, out, outWidth, outHeight, sin, cos) {
+    if (!littleEndian)
+        return false;
+    let bitmap = src;
+    if (!isOpaque(src))
+        premultiply8(src, bitmap = new Uint8ClampedArray(src.length));
+    const pixels = new Int32Array(bitmap.buffer, bitmap.byteOffset, width * height);
+    const stride = width + 2;
+    const padded = new Int32Array(stride * (height + 2));
+    for (let y = 0; y < height; y++)
+        padded.set(pixels.subarray(y * width, (y + 1) * width), (y + 1) * stride + 1);
+    const result = new Int32Array(out.buffer, out.byteOffset, outWidth * outHeight);
+    const x0 = 0.5 - outWidth / 2, cx = width / 2 + 0.5, cy = height / 2 + 0.5;
+    for (let oy = 0; oy < outHeight; oy++) {
+        const dy = oy + 0.5 - outHeight / 2;
+        const sx0 = x0 * cos - dy * sin + cx, sy0 = x0 * sin + dy * cos + cy;
+        const [xFrom, xTo] = span(sx0, cos, width + 1, 0, outWidth);
+        const [from, to] = span(sy0, sin, height + 1, xFrom, xTo);
+        let o = oy * outWidth + from, sx = sx0 + from * cos, sy = sy0 + from * sin;
+        for (let ox = from; ox < to; ox++, o++, sx += cos, sy += sin) {
+            if (!(sx >= 0 && sy >= 0 && sx < width + 1 && sy < height + 1))
+                continue;
+            const ix = sx | 0, iy = sy | 0;
+            const fx = (sx - ix) * 256 + 0.5 | 0, fy = (sy - iy) * 256 + 0.5 | 0;
+            const w11 = fx * fy + 128 >> 8, w10 = fx - w11, w01 = fy - w11, w00 = 256 - fx - fy + w11;
+            const i = iy * stride + ix;
+            const p00 = padded[i], p10 = padded[i + 1], p01 = padded[i + stride], p11 = padded[i + stride + 1];
+            const rb = Math.imul(p00 & 0xff00ff, w00) + Math.imul(p10 & 0xff00ff, w10) + Math.imul(p01 & 0xff00ff, w01) + Math.imul(p11 & 0xff00ff, w11) + 0x800080;
+            const ga = Math.imul(p00 >>> 8 & 0xff00ff, w00) + Math.imul(p10 >>> 8 & 0xff00ff, w10) + Math.imul(p01 >>> 8 & 0xff00ff, w01) + Math.imul(p11 >>> 8 & 0xff00ff, w11) + 0x800080;
+            result[o] = (rb >>> 8 & 0xff00ff) | (ga & 0xff00ff00);
+        }
+    }
+    unpremultiply8(out);
+    return true;
+}

package/dist/version.js

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

package/licenses/HarfBuzz.txt

@@ -0,0 +1,42 @@
+HarfBuzz is licensed under the so-called "Old MIT" license.  Details follow.
+For parts of HarfBuzz that are licensed under different licenses see individual
+files names COPYING in subdirectories where applicable.
+
+Copyright © 2010-2022  Google, Inc.
+Copyright © 2015-2020  Ebrahim Byagowi
+Copyright © 2019,2020  Facebook, Inc.
+Copyright © 2012,2015  Mozilla Foundation
+Copyright © 2011  Codethink Limited
+Copyright © 2008,2010  Nokia Corporation and/or its subsidiary(-ies)
+Copyright © 2009  Keith Stribley
+Copyright © 2011  Martin Hosken and SIL International
+Copyright © 2007  Chris Wilson
+Copyright © 2005,2006,2020,2021,2022,2023  Behdad Esfahbod
+Copyright © 2004,2007,2008,2009,2010,2013,2021,2022,2023  Red Hat, Inc.
+Copyright © 1998-2005  David Turner and Werner Lemberg
+Copyright © 2016  Igalia S.L.
+Copyright © 2022  Matthias Clasen
+Copyright © 2018,2021  Khaled Hosny
+Copyright © 2018,2019,2020  Adobe, Inc
+Copyright © 2013-2015  Alexei Podtelezhnikov
+
+For full copyright notices consult the individual files in the package.
+
+
+Permission is hereby granted, without written agreement and without
+license or royalty fees, to use, copy, modify, and distribute this
+software and its documentation for any purpose, provided that the
+above copyright notice and the following two paragraphs appear in
+all copies of this software.
+
+IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
+DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
+ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
+IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGE.
+
+THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
+BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
+ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
+PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.

package/licenses/Unicode-3.0.txt

@@ -0,0 +1,39 @@
+UNICODE LICENSE V3
+
+COPYRIGHT AND PERMISSION NOTICE
+
+Copyright © 1991-2026 Unicode, Inc.
+
+NOTICE TO USER: Carefully read the following legal agreement. BY
+DOWNLOADING, INSTALLING, COPYING OR OTHERWISE USING DATA FILES, AND/OR
+SOFTWARE, YOU UNEQUIVOCALLY ACCEPT, AND AGREE TO BE BOUND BY, ALL OF THE
+TERMS AND CONDITIONS OF THIS AGREEMENT. IF YOU DO NOT AGREE, DO NOT
+DOWNLOAD, INSTALL, COPY, DISTRIBUTE OR USE THE DATA FILES OR SOFTWARE.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of data files and any associated documentation (the "Data Files") or
+software and any associated documentation (the "Software") to deal in the
+Data Files or Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, and/or sell
+copies of the Data Files or Software, and to permit persons to whom the
+Data Files or Software are furnished to do so, provided that either (a)
+this copyright and permission notice appear with all copies of the Data
+Files or Software, or (b) this copyright and permission notice appear in
+associated Documentation.
+
+THE DATA FILES AND SOFTWARE ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF
+THIRD PARTY RIGHTS.
+
+IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS NOTICE
+BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES,
+OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THE DATA
+FILES OR SOFTWARE.
+
+Except as contained in this notice, the name of a copyright holder shall
+not be used in advertising or otherwise to promote the sale, use or other
+dealings in these Data Files or Software without prior written
+authorization of the copyright holder.

package/package.json

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