imagescript 3.2.1 → 3.4.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 = {
@@ -14,7 +21,7 @@ export const CUBIC = {
 };
 const BITS = 14;
 const ONE = 1 << BITS;
-function coefficients(inSize, outSize, filter, bits) {
+function coefficients(inSize, outSize, filter, bits, pad = false) {
     const scale = inSize / outSize;
     const filterScale = Math.max(1, scale);
     const support = filter.support * filterScale;
@@ -27,6 +34,8 @@ function coefficients(inSize, outSize, filter, bits) {
         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);
@@ -48,10 +57,14 @@ function coefficients(inSize, outSize, filter, bits) {
     }
     return { start, weights, taps };
 }
-const littleEndian = new Uint8Array(new Uint32Array([1]).buffer)[0] === 1;
-export function resample(src, width, height, outWidth, outHeight, filter, out) {
-    if (littleEndian && filter.support <= 1 && resampleOpaque(src, width, height, outWidth, outHeight, filter, out))
-        return;
+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) {
@@ -179,7 +192,8 @@ function resampleOpaque(src, width, height, outWidth, outHeight, filter, out) {
         }
         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;
+                let r = 0, g = 0, b = 0, k = 0, s = row + start[x] * 2;
+                const 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;
@@ -198,6 +212,110 @@ function resampleOpaque(src, width, height, outWidth, outHeight, filter, out) {
     }
     return true;
 }
+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) {
@@ -250,7 +368,8 @@ function resamplePremultiplied(src, width, height, outWidth, outHeight, filter,
                 a = plane[s + 3] * ONE;
             }
             else {
-                let k = 0, s = row + start[x] * 4, w = x * taps;
+                let k = 0, s = row + start[x] * 4;
+                const 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;

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.1';
+export const VERSION = '3.4.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.1",
+  "version": "3.4.0",
   "description": "zero-dependency javascript image manipulation",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -24,8 +24,10 @@
   "scripts": {
     "build": "node scripts/build.js",
     "typecheck": "tsc -p tsconfig.json --noEmit",
+    "lint": "eslint",
     "docs": "node scripts/docs.js",
     "test": "npm run build && node ./tests/run.js",
+    "coverage": "node scripts/build.js --source-maps && c8 node ./tests/run.js && node scripts/coverage-report.js",
     "prepack": "npm run build",
     "version": "node scripts/version.js && git add src/version.ts jsr.json"
   },
@@ -49,9 +51,25 @@
     "picture",
     "thumbnail",
     "webp",
+    "avif",
+    "av1",
+    "jxl",
+    "jpeg xl",
     "apng",
     "tiff",
     "tga",
+    "bmp",
+    "ico",
+    "cur",
+    "qoi",
+    "netpbm",
+    "ppm",
+    "pgm",
+    "pbm",
+    "pam",
+    "pfm",
+    "hdr",
+    "radiance",
     "animation",
     "text rendering",
     "font"
@@ -66,7 +84,12 @@
     "node": ">=22.13.0"
   },
   "devDependencies": {
+    "@eslint/js": "9.39.5",
+    "c8": "12.0.0",
+    "eslint": "9.39.5",
+    "eslint-plugin-sonarjs": "4.2.2",
     "typedoc": "0.27.9",
-    "typescript": "5.7.3"
+    "typescript": "5.7.3",
+    "typescript-eslint": "8.72.0"
   }
 }