imagescript 1.3.0 → 3.0.0

package/dist/image.js

@@ -0,0 +1,1118 @@
+import * as png from "./codecs/png.js";
+import * as jpeg from "./codecs/jpeg.js";
+import * as tiff from "./codecs/tiff.js";
+import * as quantize from "./codecs/quantize.js";
+import * as textRenderer from "./render/text.js";
+import * as svgRenderer from "./render/svg.js";
+import { view } from "./util/mem.js";
+import { ImageType } from "./image-type.js";
+import { TextLayout } from "./text-layout.js";
+import { VERSION } from "./version.js";
+import { resample, BOX, TRIANGLE, CUBIC } from "./util/resample.js";
+import { gaussianBlur, premultiply, unpremultiply } from "./util/blur.js";
+export class Image {
+    __width__;
+    __height__;
+    __view__;
+    __u32__;
+    __bitmap__;
+    constructor(width, height) {
+        width = ~~width;
+        height = ~~height;
+        if (width < 1)
+            throw new RangeError('Image has to be at least 1 pixel wide');
+        if (height < 1)
+            throw new RangeError('Image has to be at least 1 pixel high');
+        this.__width__ = width;
+        this.__height__ = height;
+        this.__set_bitmap__(new Uint8ClampedArray(width * height * 4));
+    }
+    get bitmap() {
+        return this.__bitmap__;
+    }
+    set bitmap(bitmap) {
+        if (!(bitmap instanceof Uint8ClampedArray || bitmap instanceof Uint8Array))
+            throw new TypeError('The bitmap has to be a Uint8ClampedArray or Uint8Array');
+        if (bitmap.length !== this.width * this.height * 4)
+            throw new RangeError(`The bitmap has to have ${this.width * this.height * 4} bytes (width * height * 4), got ${bitmap.length}`);
+        this.__set_bitmap__(bitmap instanceof Uint8ClampedArray ? bitmap : new Uint8ClampedArray(bitmap.buffer, bitmap.byteOffset, bitmap.length));
+    }
+    __set_bitmap__(bitmap) {
+        if (bitmap.byteOffset % 4)
+            bitmap = bitmap.slice();
+        this.__bitmap__ = bitmap;
+        this.__view__ = new DataView(bitmap.buffer, bitmap.byteOffset, bitmap.byteLength);
+        this.__u32__ = new Uint32Array(bitmap.buffer, bitmap.byteOffset, bitmap.length >> 2);
+    }
+    toString() {
+        return `Image<${this.width}x${this.height}>`;
+    }
+    get width() {
+        return this.__width__;
+    }
+    get height() {
+        return this.__height__;
+    }
+    *[Symbol.iterator]() {
+        for (let y = 0; y < this.height; y++)
+            for (let x = 0; x < this.width; x++)
+                yield [x, y];
+    }
+    *iterateWithColors() {
+        const view = new DataView(this.bitmap.buffer, this.bitmap.byteOffset, this.bitmap.byteLength);
+        let offset = 0;
+        for (let y = 0; y < this.height; y++)
+            for (let x = 0; x < this.width; x++, offset += 4)
+                yield [x, y, view.getUint32(offset, false)];
+    }
+    static rgbaToColor(r, g, b, a) {
+        return (channel(r) << 24 | channel(g) << 16 | channel(b) << 8 | channel(a)) >>> 0;
+    }
+    static rgbToColor(r, g, b) {
+        return Image.rgbaToColor(r, g, b, 0xff);
+    }
+    static hslaToColor(h, s, l, a) {
+        h = wrapHue(h);
+        s = Math.min(1, Math.max(0, s));
+        l = Math.min(1, Math.max(0, l));
+        a = Math.min(1, Math.max(0, a));
+        let r, g, b;
+        if (s === 0) {
+            r = g = b = l;
+        }
+        else {
+            const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+            const p = 2 * l - q;
+            r = hue2rgb(p, q, h + 1 / 3);
+            g = hue2rgb(p, q, h);
+            b = hue2rgb(p, q, h - 1 / 3);
+        }
+        return Image.rgbaToColor(Math.round(r * 255), Math.round(g * 255), Math.round(b * 255), Math.round(a * 255));
+    }
+    static hslToColor(h, s, l) {
+        return Image.hslaToColor(h, s, l, 1);
+    }
+    static rgbaToHSLA(r, g, b, a) {
+        r /= 255;
+        g /= 255;
+        b /= 255;
+        const max = Math.max(r, g, b), min = Math.min(r, g, b);
+        let h = 0, s;
+        const l = (max + min) / 2;
+        if (max === min) {
+            h = s = 0;
+        }
+        else {
+            const d = max - min;
+            s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+            switch (max) {
+                case r:
+                    h = (g - b) / d + (g < b ? 6 : 0);
+                    break;
+                case g:
+                    h = (b - r) / d + 2;
+                    break;
+                case b:
+                    h = (r - g) / d + 4;
+                    break;
+            }
+            h /= 6;
+        }
+        return [h, s, l, a / 255];
+    }
+    static colorToRGBA(color) {
+        return [(color >> 24) & 0xff, (color >> 16) & 0xff, (color >> 8) & 0xff, color & 0xff];
+    }
+    static colorToRGB(color) {
+        const [r, g, b] = Image.colorToRGBA(color);
+        return [r, g, b];
+    }
+    getPixelAt(x, y) {
+        x = ~~x;
+        y = ~~y;
+        this.__check_boundaries__(x, y);
+        return this.__view__.getUint32((y * this.width + x) * 4, false);
+    }
+    getRGBAAt(x, y) {
+        x = ~~x;
+        y = ~~y;
+        this.__check_boundaries__(x, y);
+        const idx = (y * this.width + x) * 4;
+        return this.bitmap.subarray(idx, idx + 4);
+    }
+    setPixelAt(x, y, pixelColor) {
+        x = ~~x;
+        y = ~~y;
+        this.__check_boundaries__(x, y);
+        this.__set_pixel__(x, y, pixelColor);
+        return this;
+    }
+    __set_pixel__(x, y, pixelColor) {
+        this.__view__.setUint32((y * this.width + x) * 4, pixelColor, false);
+    }
+    __check_boundaries__(x, y) {
+        if (isNaN(x))
+            throw new TypeError(`Invalid pixel coordinates (x=${x})`);
+        if (isNaN(y))
+            throw new TypeError(`Invalid pixel coordinates (y=${y})`);
+        if (x < 0)
+            throw new RangeError(`${Image.__out_of_bounds__} (x=${x})<0`);
+        if (x >= this.width)
+            throw new RangeError(`${Image.__out_of_bounds__} (x=${x})>=(width=${this.width})`);
+        if (y < 0)
+            throw new RangeError(`${Image.__out_of_bounds__} (y=${y})<0`);
+        if (y >= this.height)
+            throw new RangeError(`${Image.__out_of_bounds__} (y=${y})>=(height=${this.height})`);
+    }
+    static get __out_of_bounds__() {
+        return 'Tried referencing a pixel outside of the images boundaries:';
+    }
+    fill(color) {
+        const view = new DataView(this.bitmap.buffer, this.bitmap.byteOffset, this.bitmap.byteLength);
+        if (typeof color === 'function') {
+            let offset = 0;
+            for (let y = 0; y < this.height; y++)
+                for (let x = 0; x < this.width; x++, offset += 4)
+                    view.setUint32(offset, color(x, y), false);
+        }
+        else {
+            if (!this.bitmap.length)
+                return this;
+            view.setUint32(0, color, false);
+            const u32 = new Uint32Array(this.bitmap.buffer, this.bitmap.byteOffset, this.bitmap.byteLength / 4);
+            u32.fill(u32[0]);
+        }
+        return this;
+    }
+    clone() {
+        const image = new Image(this.width, this.height);
+        image.bitmap.set(this.bitmap);
+        return image;
+    }
+    static get RESIZE_NEAREST_NEIGHBOR() {
+        return 'RESIZE_NEAREST_NEIGHBOR';
+    }
+    static get RESIZE_BILINEAR() {
+        return 'RESIZE_BILINEAR';
+    }
+    static get RESIZE_BICUBIC() {
+        return 'RESIZE_BICUBIC';
+    }
+    static get RESIZE_AREA() {
+        return 'RESIZE_AREA';
+    }
+    static get RESIZE_AUTO() {
+        return -1;
+    }
+    scale(factor, mode = Image.RESIZE_BILINEAR) {
+        const image = this.__scale__(factor, mode);
+        return this.__apply__(image);
+    }
+    __scale__(factor, mode = Image.RESIZE_BILINEAR) {
+        if (factor === 1)
+            return this;
+        return this.__resize__(this.width * factor, this.height * factor, mode);
+    }
+    resize(width, height, mode = Image.RESIZE_BILINEAR) {
+        const image = this.__resize__(width, height, mode);
+        return this.__apply__(image);
+    }
+    contain(width, height, mode = Image.RESIZE_BILINEAR) {
+        width = Math.floor(width);
+        height = Math.floor(height);
+        const scale = Math.min(width / this.width, height / this.height);
+        return this.resize(Math.max(1, Math.min(width, Math.round(this.width * scale))), Math.max(1, Math.min(height, Math.round(this.height * scale))), mode);
+    }
+    fit(width, height, mode = Image.RESIZE_BILINEAR) {
+        const result = new Image(width, height);
+        this.contain(width, height, mode);
+        result.composite(this, (width - this.width) / 2, (height - this.height) / 2);
+        return this.__apply__(result);
+    }
+    cover(width, height, mode = Image.RESIZE_BILINEAR) {
+        width = Math.floor(width);
+        height = Math.floor(height);
+        const scale = Math.max(width / this.width, height / this.height);
+        this.resize(Math.max(width, Math.round(this.width * scale)), Math.max(height, Math.round(this.height * scale)), mode);
+        return this.crop((this.width - width) / 2, (this.height - height) / 2, width, height);
+    }
+    __resize__(width, height, mode = Image.RESIZE_BILINEAR) {
+        if (width === Image.RESIZE_AUTO && height === Image.RESIZE_AUTO)
+            throw new Error('RESIZE_AUTO can only be used for either width or height, not for both');
+        else if (width === Image.RESIZE_AUTO)
+            width = Math.max(1, Math.round(this.width / this.height * Math.floor(height)));
+        else if (height === Image.RESIZE_AUTO)
+            height = Math.max(1, Math.round(this.height / this.width * Math.floor(width)));
+        width = Math.floor(width);
+        height = Math.floor(height);
+        if (width < 1)
+            throw new RangeError('Image has to be at least 1 pixel wide');
+        if (height < 1)
+            throw new RangeError('Image has to be at least 1 pixel high');
+        if (mode === Image.RESIZE_NEAREST_NEIGHBOR)
+            return this.__resize_nearest_neighbor__(width, height);
+        const filter = mode === Image.RESIZE_BILINEAR ? TRIANGLE : mode === Image.RESIZE_BICUBIC ? CUBIC : mode === Image.RESIZE_AREA ? BOX : null;
+        if (!filter)
+            throw new Error('Invalid resize mode');
+        const image = new Image(width, height);
+        resample(this.bitmap, this.width, this.height, width, height, filter, image.bitmap);
+        return image;
+    }
+    __resize_nearest_neighbor__(width, height) {
+        const image = new Image(width, height);
+        const src = this.__u32__;
+        const dst = image.__u32__;
+        for (let y = 0; y < height; y++) {
+            const row = this.width * ((y + 0.5) * (this.height / height) | 0);
+            for (let x = 0; x < width; x++)
+                dst[y * width + x] = src[row + ((x + 0.5) * (this.width / width) | 0)];
+        }
+        return image;
+    }
+    crop(x, y, width, height) {
+        x = ~~x;
+        y = ~~y;
+        width = ~~width;
+        height = ~~height;
+        const left = Math.max(0, x), top = Math.max(0, y);
+        const right = Math.min(this.width, x + width), bottom = Math.min(this.height, y + height);
+        if (right <= left || bottom <= top)
+            throw new RangeError('Crop region does not overlap the image');
+        return this.__apply__(this.__crop__(left, top, right - left, bottom - top));
+    }
+    __crop__(x, y, width, height) {
+        x = ~~x;
+        y = ~~y;
+        const image = new Image(width, height);
+        for (let tY = 0; tY < height; tY++) {
+            const idx = (tY + y) * this.width + x;
+            image.__u32__.set(this.__u32__.subarray(idx, idx + width), tY * width);
+        }
+        return image;
+    }
+    drawBox(x, y, width, height, color) {
+        x = ~~x;
+        y = ~~y;
+        width = ~~width;
+        height = ~~height;
+        if (typeof color !== 'function')
+            return this.__fast_box__(x, y, width, height, color);
+        for (let tY = Math.max(0, -y); tY < height && tY + y < this.height; tY++)
+            for (let tX = Math.max(0, -x); tX < width && tX + x < this.width; tX++)
+                this.__set_pixel__(tX + x, tY + y, color(tX, tY));
+        return this;
+    }
+    __fast_box__(x, y, width, height, color) {
+        const left = Math.max(0, x), top = Math.max(0, y);
+        const right = Math.min(this.width, x + width), bottom = Math.min(this.height, y + height);
+        if (right <= left || bottom <= top)
+            return this;
+        for (let xPos = left; xPos < right; xPos++)
+            this.__view__.setUint32(4 * (xPos + top * this.width), color);
+        const start = 4 * (left + top * this.width);
+        const end = 4 * (right + top * this.width);
+        for (let row = top + 1; row < bottom; row++)
+            this.bitmap.copyWithin(4 * (left + row * this.width), start, end);
+        return this;
+    }
+    drawCircle(x, y, radius, color) {
+        x = ~~x;
+        y = ~~y;
+        const cx = x + 0.5, cy = y + 0.5;
+        for (let py = Math.max(0, Math.floor(cy - radius)); py < Math.min(this.height, Math.ceil(cy + radius)); py++) {
+            for (let px = Math.max(0, Math.floor(cx - radius)); px < Math.min(this.width, Math.ceil(cx + radius)); px++) {
+                const coverage = circleCoverage(px, py, cx, cy, radius);
+                if (coverage <= 0)
+                    continue;
+                const value = typeof color === 'function' ? color(px - x + radius, py - y + radius) : color;
+                if (coverage >= 1)
+                    this.__set_pixel__(px, py, value);
+                else
+                    this.__blend_pixel__(px, py, value, coverage);
+            }
+        }
+        return this;
+    }
+    __blend_pixel__(x, y, color, amount) {
+        const i = (y * this.width + x) * 4, b = this.bitmap;
+        const sa = (color & 0xff) / 255 * amount, da = b[i + 3] / 255 * (1 - amount);
+        const a = sa + da;
+        if (a <= 0) {
+            b[i] = b[i + 1] = b[i + 2] = b[i + 3] = 0;
+            return;
+        }
+        b[i] = ((color >>> 24) * sa + b[i] * da) / a;
+        b[i + 1] = ((color >> 16 & 0xff) * sa + b[i + 1] * da) / a;
+        b[i + 2] = ((color >> 8 & 0xff) * sa + b[i + 2] * da) / a;
+        b[i + 3] = a * 255;
+    }
+    cropCircle(maxOrOptions = false, featheringArgument = 0) {
+        const { max = false, feathering = 0 } = typeof maxOrOptions === 'object' && maxOrOptions !== null
+            ? maxOrOptions : { max: maxOrOptions, feathering: featheringArgument };
+        const radius = (max ? Math.max : Math.min)(this.width, this.height) / 2;
+        const cx = this.width / 2, cy = this.height / 2;
+        const band = Math.min(1, Math.max(0, feathering)) * radius;
+        for (let y = 0; y < this.height; y++) {
+            for (let x = 0; x < this.width; x++) {
+                const alpha = 4 * (y * this.width + x) + 3;
+                const dx = x + 0.5 - cx, dy = y + 0.5 - cy;
+                if (dx * dx + dy * dy <= (radius - Math.max(band, 1)) ** 2)
+                    continue;
+                const factor = band > 1
+                    ? Math.min(1, Math.max(0, (radius - Math.hypot(dx, dy)) / band))
+                    : circleCoverage(x, y, cx, cy, radius);
+                if (factor < 1)
+                    this.bitmap[alpha] *= factor;
+            }
+        }
+        return this;
+    }
+    opacity(opacity, absolute = false) {
+        if (isNaN(opacity) || opacity < 0)
+            throw new RangeError('Invalid opacity value');
+        this.__set_channel_value__(opacity, absolute, 3);
+        return this;
+    }
+    red(factor, absolute = false) {
+        if (isNaN(factor) || factor < 0)
+            throw new RangeError('Invalid red factor');
+        this.__set_channel_value__(factor, absolute, 0);
+        return this;
+    }
+    green(factor, absolute = false) {
+        if (isNaN(factor) || factor < 0)
+            throw new RangeError('Invalid green factor');
+        this.__set_channel_value__(factor, absolute, 1);
+        return this;
+    }
+    blue(factor, absolute = false) {
+        if (isNaN(factor) || factor < 0)
+            throw new RangeError('Invalid blue factor');
+        this.__set_channel_value__(factor, absolute, 2);
+        return this;
+    }
+    __set_channel_value__(value, absolute, offset) {
+        for (let i = offset; i < this.bitmap.length; i += 4)
+            this.bitmap[i] = value * (absolute ? 255 : this.bitmap[i]);
+    }
+    lightness(value, absolute = false) {
+        if (isNaN(value) || value < 0)
+            throw new RangeError('Invalid lightness value');
+        return this.__map_hsla__(c => { c.l = value * (absolute ? 1 : c.l); });
+    }
+    saturation(value, absolute = false) {
+        if (isNaN(value) || value < 0)
+            throw new RangeError('Invalid saturation value');
+        return this.__map_hsla__(c => { c.s = value * (absolute ? 1 : c.s); });
+    }
+    composite(source, x = 0, y = 0, options = {}) {
+        const { opacity = 1, mode = 'normal' } = options;
+        x |= 0;
+        y |= 0;
+        if (isNaN(opacity) || opacity < 0 || opacity > 1)
+            throw new RangeError('Invalid composite opacity');
+        const blend = BLEND_MODES[mode];
+        if (!blend || !Object.prototype.hasOwnProperty.call(BLEND_MODES, mode))
+            throw new RangeError(`Invalid blend mode: ${mode}`);
+        if (opacity !== 1 || mode !== 'normal')
+            return this.__blend__(source, x, y, opacity, blend);
+        const left = Math.max(0, x), top = Math.max(0, y);
+        const right = Math.min(this.width, x + source.width), bottom = Math.min(this.height, y + source.height);
+        const dst = this.bitmap, src = source.bitmap;
+        const dst32 = new Uint32Array(dst.buffer, dst.byteOffset, dst.length >> 2);
+        const src32 = new Uint32Array(src.buffer, src.byteOffset, src.length >> 2);
+        for (let row = top; row < bottom; row++) {
+            for (let column = left; column < right; column++) {
+                const sp = (row - y) * source.width + column - x, s = 4 * sp;
+                const sa = src[s + 3];
+                if (sa === 0)
+                    continue;
+                const dp = row * this.width + column, d = 4 * dp;
+                const da = dst[d + 3];
+                if (sa === 255 || da === 0) {
+                    dst32[dp] = src32[sp];
+                    continue;
+                }
+                const fa = sa / 255, ba = da / 255 * (1 - fa);
+                const a = fa + ba;
+                dst[d] = (src[s] * fa + dst[d] * ba) / a;
+                dst[d + 1] = (src[s + 1] * fa + dst[d + 1] * ba) / a;
+                dst[d + 2] = (src[s + 2] * fa + dst[d + 2] * ba) / a;
+                dst[d + 3] = a * 255;
+            }
+        }
+        return this;
+    }
+    __blend__(source, x, y, opacity, blend) {
+        const left = Math.max(0, x), top = Math.max(0, y);
+        const right = Math.min(this.width, x + source.width), bottom = Math.min(this.height, y + source.height);
+        const dst = this.bitmap, src = source.bitmap;
+        for (let row = top; row < bottom; row++) {
+            for (let column = left; column < right; column++) {
+                const s = 4 * ((row - y) * source.width + column - x);
+                const as = src[s + 3] / 255 * opacity;
+                if (as <= 0)
+                    continue;
+                const d = 4 * (row * this.width + column);
+                const ab = dst[d + 3] / 255;
+                const ao = as + ab * (1 - as);
+                for (let c = 0; c < 3; c++) {
+                    const cs = src[s + c] / 255, cb = dst[d + c] / 255;
+                    const cr = (1 - ab) * cs + ab * blend(cb, cs);
+                    dst[d + c] = (as * cr + ab * (1 - as) * cb) / ao * 255;
+                }
+                dst[d + 3] = ao * 255;
+            }
+        }
+        return this;
+    }
+    invert() {
+        const bitmap = this.bitmap;
+        for (let i = 0; i < bitmap.length; i += 4) {
+            bitmap[i] = 255 - bitmap[i];
+            bitmap[i + 1] = 255 - bitmap[i + 1];
+            bitmap[i + 2] = 255 - bitmap[i + 2];
+        }
+        return this;
+    }
+    invertLightness() {
+        return this.__map_hsla__(c => { c.l = 1 - c.l; });
+    }
+    invertValue() {
+        const bitmap = this.bitmap;
+        for (let i = 0; i < bitmap.length; i += 4) {
+            const max = Math.max(bitmap[i], bitmap[i + 1], bitmap[i + 2]);
+            if (max === 0) {
+                bitmap[i] = bitmap[i + 1] = bitmap[i + 2] = 255;
+                continue;
+            }
+            const factor = (255 - max) / max;
+            bitmap[i] *= factor;
+            bitmap[i + 1] *= factor;
+            bitmap[i + 2] *= factor;
+        }
+        return this;
+    }
+    hueShift(degrees) {
+        return this.__map_hsla__(c => { c.h += degrees / 360; });
+    }
+    __map_hsla__(map) {
+        const bitmap = this.bitmap;
+        const hsla = { h: 0, s: 0, l: 0, a: 0 };
+        const pixels = new Uint32Array(bitmap.buffer, bitmap.byteOffset, bitmap.length >> 2);
+        const keys = new Uint32Array(4096), values = new Uint32Array(4096);
+        keys[0] = 1;
+        for (let i = 0; i < bitmap.length; i += 4) {
+            const color = pixels[i >> 2];
+            const slot = Math.imul(color, 0x9e3779b1) >>> 20;
+            if (keys[slot] === color) {
+                pixels[i >> 2] = values[slot];
+                continue;
+            }
+            const r = bitmap[i] / 255, g = bitmap[i + 1] / 255, b = bitmap[i + 2] / 255;
+            const max = Math.max(r, g, b), min = Math.min(r, g, b);
+            const l = (max + min) / 2;
+            let h = 0, s = 0;
+            if (max !== min) {
+                const d = max - min;
+                s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+                if (max === r)
+                    h = (g - b) / d + (g < b ? 6 : 0);
+                else if (max === g)
+                    h = (b - r) / d + 2;
+                else
+                    h = (r - g) / d + 4;
+                h /= 6;
+            }
+            hsla.h = h;
+            hsla.s = s;
+            hsla.l = l;
+            hsla.a = bitmap[i + 3] / 255;
+            map(hsla);
+            const nh = wrapHue(hsla.h);
+            const ns = Math.min(1, Math.max(0, hsla.s));
+            const nl = Math.min(1, Math.max(0, hsla.l));
+            const na = Math.min(1, Math.max(0, hsla.a));
+            if (ns === 0)
+                bitmap[i] = bitmap[i + 1] = bitmap[i + 2] = Math.round(nl * 255);
+            else {
+                const q = nl < 0.5 ? nl * (1 + ns) : nl + ns - nl * ns;
+                const p = 2 * nl - q;
+                bitmap[i] = Math.round(hue2rgb(p, q, nh + 1 / 3) * 255);
+                bitmap[i + 1] = Math.round(hue2rgb(p, q, nh) * 255);
+                bitmap[i + 2] = Math.round(hue2rgb(p, q, nh - 1 / 3) * 255);
+            }
+            bitmap[i + 3] = Math.round(na * 255);
+            keys[slot] = color;
+            values[slot] = pixels[i >> 2];
+        }
+        return this;
+    }
+    blur(radius) {
+        if (isNaN(radius) || radius < 0)
+            throw new RangeError('Invalid blur radius');
+        const pixels = premultiply(this.bitmap);
+        gaussianBlur(pixels, this.width, this.height, radius);
+        unpremultiply(pixels, this.bitmap);
+        return this;
+    }
+    sharpen(amount = 1, radius = 1) {
+        if (isNaN(amount) || amount < 0)
+            throw new RangeError('Invalid sharpen amount');
+        if (isNaN(radius) || radius <= 0)
+            throw new RangeError('Invalid sharpen radius');
+        const blurred = premultiply(this.bitmap);
+        gaussianBlur(blurred, this.width, this.height, radius);
+        const bitmap = this.bitmap;
+        for (let i = 0; i < bitmap.length; i += 4) {
+            const a = blurred[i + 3];
+            if (a < 0.5 || bitmap[i + 3] === 0)
+                continue;
+            const f = 255 / a;
+            bitmap[i] += amount * (bitmap[i] - blurred[i] * f);
+            bitmap[i + 1] += amount * (bitmap[i + 1] - blurred[i + 1] * f);
+            bitmap[i + 2] += amount * (bitmap[i + 2] - blurred[i + 2] * f);
+        }
+        return this;
+    }
+    brightness(factor) {
+        if (isNaN(factor) || factor < 0)
+            throw new RangeError('Invalid brightness factor');
+        return this.__map_channels__(v => v * factor);
+    }
+    contrast(factor) {
+        if (isNaN(factor) || factor < 0)
+            throw new RangeError('Invalid contrast factor');
+        return this.__map_channels__(v => (v - 127.5) * factor + 127.5);
+    }
+    gamma(gamma) {
+        if (isNaN(gamma) || gamma <= 0)
+            throw new RangeError('Invalid gamma');
+        return this.__map_channels__(v => 255 * (v / 255) ** (1 / gamma));
+    }
+    greyscale() {
+        const bitmap = this.bitmap;
+        for (let i = 0; i < bitmap.length; i += 4)
+            bitmap[i] = bitmap[i + 1] = bitmap[i + 2] = bitmap[i] * 19595 + bitmap[i + 1] * 38470 + bitmap[i + 2] * 7471 + 0x8000 >> 16;
+        return this;
+    }
+    sepia() {
+        const bitmap = this.bitmap;
+        for (let i = 0; i < bitmap.length; i += 4) {
+            const r = bitmap[i], g = bitmap[i + 1], b = bitmap[i + 2];
+            bitmap[i] = 0.393 * r + 0.769 * g + 0.189 * b;
+            bitmap[i + 1] = 0.349 * r + 0.686 * g + 0.168 * b;
+            bitmap[i + 2] = 0.272 * r + 0.534 * g + 0.131 * b;
+        }
+        return this;
+    }
+    __map_channels__(map) {
+        const lut = new Uint8ClampedArray(256);
+        for (let v = 0; v < 256; v++)
+            lut[v] = map(v);
+        const bitmap = this.bitmap;
+        for (let i = 0; i < bitmap.length; i += 4) {
+            bitmap[i] = lut[bitmap[i]];
+            bitmap[i + 1] = lut[bitmap[i + 1]];
+            bitmap[i + 2] = lut[bitmap[i + 2]];
+        }
+        return this;
+    }
+    averageColor() {
+        let r = 0, g = 0, b = 0, weight = 0;
+        for (let i = 0; i < this.bitmap.length; i += 4) {
+            const a = this.bitmap[i + 3];
+            r += this.bitmap[i] * a;
+            g += this.bitmap[i + 1] * a;
+            b += this.bitmap[i + 2] * a;
+            weight += a;
+        }
+        if (!weight)
+            return Image.rgbaToColor(0, 0, 0, 0xff);
+        return Image.rgbaToColor(Math.round(r / weight), Math.round(g / weight), Math.round(b / weight), 0xff);
+    }
+    dominantColor(ignoreBlackOrOptions = true, ignoreWhiteArgument = true, thresholdArgument = 0xf) {
+        const { ignoreBlack = true, ignoreWhite = true, threshold: bwThreshold = 0xf } = typeof ignoreBlackOrOptions === 'object' && ignoreBlackOrOptions !== null
+            ? ignoreBlackOrOptions : { ignoreBlack: ignoreBlackOrOptions, ignoreWhite: ignoreWhiteArgument, threshold: thresholdArgument };
+        const threshold = Math.min(64, Math.max(0, bwThreshold)) * 4;
+        const pixels = this.__bytes__();
+        const color = quantize.dominantColor(pixels, (r, g, b) => !(ignoreBlack && Math.max(r, g, b) < threshold) && !(ignoreWhite && Math.min(r, g, b) > 255 - threshold))
+            || quantize.dominantColor(pixels, () => true);
+        return color ? Image.rgbToColor(...color) : Image.rgbaToColor(0, 0, 0, 0xff);
+    }
+    rotate(angle, resizeOrOptions = true) {
+        const { resize = true } = typeof resizeOrOptions === 'object' && resizeOrOptions !== null ? resizeOrOptions : { resize: resizeOrOptions };
+        angle = ((angle % 360) + 360) % 360;
+        if (angle === 0)
+            return this;
+        const { width, height } = this;
+        const src = this.__u32__;
+        if (angle === 90 || angle === 180 || angle === 270) {
+            const out = new Image(angle === 180 ? width : height, angle === 180 ? height : width);
+            const dst = out.__u32__;
+            for (let y = 0; y < height; y++)
+                for (let x = 0; x < width; x++) {
+                    const i = src[y * width + x];
+                    if (angle === 90)
+                        dst[(width - 1 - x) * height + y] = i;
+                    else if (angle === 180)
+                        dst[(height - 1 - y) * width + width - 1 - x] = i;
+                    else
+                        dst[x * height + height - 1 - y] = i;
+                }
+            return this.__apply__(out);
+        }
+        const rad = angle * Math.PI / 180;
+        const sin = Math.sin(rad), cos = Math.cos(rad);
+        const outWidth = resize ? Math.round(Math.abs(width * cos) + Math.abs(height * sin)) : width;
+        const outHeight = resize ? Math.round(Math.abs(width * sin) + Math.abs(height * cos)) : height;
+        const out = new Image(outWidth, outHeight);
+        const s8 = this.bitmap, d8 = out.bitmap;
+        for (let oy = 0; oy < outHeight; oy++) {
+            for (let ox = 0; ox < outWidth; ox++) {
+                const dx = ox + 0.5 - outWidth / 2, dy = oy + 0.5 - outHeight / 2;
+                const sx = dx * cos - dy * sin + width / 2 - 0.5;
+                const sy = dx * sin + dy * cos + height / 2 - 0.5;
+                const x0 = Math.floor(sx), y0 = Math.floor(sy);
+                if (x0 < -1 || y0 < -1 || x0 >= width || y0 >= height)
+                    continue;
+                const fx = sx - x0, fy = sy - y0;
+                const w00 = (1 - fx) * (1 - fy), w10 = fx * (1 - fy), w01 = (1 - fx) * fy, w11 = fx * fy;
+                let r = 0, g = 0, b = 0, a = 0;
+                const left = x0 >= 0, right = x0 + 1 < width, top = y0 >= 0, bottom = y0 + 1 < height;
+                let i = 4 * (y0 * width + x0);
+                if (top && left) {
+                    const wa = w00 * s8[i + 3];
+                    r += wa * s8[i];
+                    g += wa * s8[i + 1];
+                    b += wa * s8[i + 2];
+                    a += wa;
+                }
+                if (top && right) {
+                    const wa = w10 * s8[i + 7];
+                    r += wa * s8[i + 4];
+                    g += wa * s8[i + 5];
+                    b += wa * s8[i + 6];
+                    a += wa;
+                }
+                i += 4 * width;
+                if (bottom && left) {
+                    const wa = w01 * s8[i + 3];
+                    r += wa * s8[i];
+                    g += wa * s8[i + 1];
+                    b += wa * s8[i + 2];
+                    a += wa;
+                }
+                if (bottom && right) {
+                    const wa = w11 * s8[i + 7];
+                    r += wa * s8[i + 4];
+                    g += wa * s8[i + 5];
+                    b += wa * s8[i + 6];
+                    a += wa;
+                }
+                if (a <= 0)
+                    continue;
+                const o = 4 * (oy * outWidth + ox);
+                d8[o] = r / a;
+                d8[o + 1] = g / a;
+                d8[o + 2] = b / a;
+                d8[o + 3] = a;
+            }
+        }
+        return this.__apply__(out);
+    }
+    flip(direction) {
+        const u32 = this.__u32__;
+        const { width, height } = this;
+        if (direction === 'horizontal') {
+            for (let y = 0; y < height; y++)
+                u32.subarray(y * width, (y + 1) * width).reverse();
+        }
+        else if (direction === 'vertical') {
+            for (let y = 0; y < height >> 1; y++) {
+                const top = u32.slice(y * width, (y + 1) * width);
+                u32.copyWithin(y * width, (height - 1 - y) * width, (height - y) * width);
+                u32.set(top, (height - 1 - y) * width);
+            }
+        }
+        else
+            throw new RangeError('Invalid flip direction');
+        return this;
+    }
+    __bytes__() {
+        return new Uint8Array(this.bitmap.buffer, this.bitmap.byteOffset, this.bitmap.byteLength);
+    }
+    __apply__(image) {
+        this.__width__ = image.__width__;
+        this.__height__ = image.__height__;
+        this.__bitmap__ = image.__bitmap__;
+        this.__view__ = image.__view__;
+        this.__u32__ = image.__u32__;
+        return this;
+    }
+    static gradient(colors) {
+        const entries = Object.entries(colors).sort((a, b) => Number(a[0]) - Number(b[0]));
+        const positions = entries.map(e => parseFloat(e[0]));
+        const values = entries.map(e => e[1]);
+        if (positions.length === 0)
+            throw new RangeError('Invalid gradient point count');
+        else if (positions.length === 1) {
+            return () => values[0];
+        }
+        else if (positions.length === 2) {
+            const gradient = this.__gradient__(values[0], values[1]);
+            return position => {
+                if (position <= positions[0])
+                    return values[0];
+                if (position >= positions[1])
+                    return values[1];
+                return gradient((position - positions[0]) / (positions[1] - positions[0]));
+            };
+        }
+        const minDef = Math.min(...positions);
+        const maxDef = Math.max(...positions);
+        const gradients = [];
+        for (let i = 0; i < positions.length; i++) {
+            let minPos = positions[i - 1];
+            if (minPos === undefined)
+                continue;
+            let maxPos = positions[i];
+            let minVal = values[i - 1];
+            if (minVal === undefined)
+                minVal = values[i];
+            const maxVal = values[i];
+            const gradient = this.__gradient__(minVal, maxVal);
+            gradients.push({ min: minPos, max: maxPos, gradient });
+        }
+        return position => {
+            if (position <= minDef)
+                return gradients[0].gradient(0);
+            if (position >= maxDef)
+                return gradients[gradients.length - 1].gradient(1);
+            for (const gradient of gradients)
+                if (position >= gradient.min && position <= gradient.max)
+                    return gradient.gradient((position - gradient.min) / (gradient.max - gradient.min));
+            throw new RangeError(`Invalid gradient position: ${position}`);
+        };
+    }
+    roundCorners(radius = Math.min(this.width, this.height) / 4) {
+        radius = Math.max(0, Math.min(radius, this.width / 2, this.height / 2));
+        const size = Math.ceil(radius);
+        for (let y = 0; y < size; y++) {
+            for (let x = 0; x < size; x++) {
+                const coverage = pixelCoverage(x, y, (sx, sy) => sx >= radius || sy >= radius || (sx - radius) ** 2 + (sy - radius) ** 2 <= radius * radius);
+                if (coverage >= 1)
+                    continue;
+                const corners = new Set([[x, y], [this.width - 1 - x, y], [x, this.height - 1 - y], [this.width - 1 - x, this.height - 1 - y]].map(([px, py]) => py * this.width + px));
+                for (const pixel of corners)
+                    this.bitmap[pixel * 4 + 3] *= coverage;
+            }
+        }
+        return this;
+    }
+    static __gradient__(startColor, endColor) {
+        const sr = startColor >>> 24;
+        const sg = startColor >> 16 & 0xff;
+        const sb = startColor >> 8 & 0xff;
+        const sa = startColor & 0xff;
+        const er = (endColor >>> 24) - sr;
+        const eg = (endColor >> 16 & 0xff) - sg;
+        const eb = (endColor >> 8 & 0xff) - sb;
+        const ea = (endColor & 0xff) - sa;
+        return position => {
+            const r = sr + position * er;
+            const g = sg + position * eg;
+            const b = sb + position * eb;
+            const a = sa + position * ea;
+            return (((r & 0xff) << 24) | ((g & 0xff) << 16) | ((b & 0xff) << 8) | (a & 0xff)) >>> 0;
+        };
+    }
+    fisheye(strength = 2) {
+        const r = new Image(this.width, this.height);
+        const w = this.width;
+        const h = this.height;
+        const tu32 = this.__u32__;
+        const ru32 = r.__u32__;
+        for (let y = 0; y < h; y++) {
+            for (let x = 0; x < w; x++) {
+                const xco = (x + 0.5) / w - 0.5;
+                const yco = (y + 0.5) / h - 0.5;
+                const dfc = Math.sqrt(xco ** 2 + yco ** 2);
+                if (dfc === 0) {
+                    ru32[y * w + x] = tu32[y * w + x];
+                    continue;
+                }
+                const dis = 2 * dfc ** strength;
+                const nx = Math.floor((dis * xco / dfc + 0.5) * w);
+                const ny = Math.floor((dis * yco / dfc + 0.5) * h);
+                if (nx < 0 || nx >= w || ny < 0 || ny >= h)
+                    continue;
+                ru32[y * w + x] = tu32[ny * w + nx];
+            }
+        }
+        return this.__apply__(r);
+    }
+    async encode(compression = 1, metadata = {}) {
+        if (typeof compression === 'object' && compression !== null) {
+            metadata = compression;
+            compression = 1;
+        }
+        const level = Math.min(9, Math.max(0, ~~compression));
+        const { title, author, description, copyright, creationTime, software, disclaimer, warning, source, comment } = metadata || {};
+        return png.encodeRGBA(this.__bytes__(), this.width, this.height, level, {
+            Title: title,
+            Author: author,
+            Description: description,
+            Copyright: copyright,
+            'Creation Time': new Date(creationTime === undefined ? Date.now() : creationTime).toUTCString(),
+            Software: software === undefined ? `github.com/matmen/ImageScript v${VERSION}` : software,
+            Disclaimer: disclaimer,
+            Warning: warning,
+            Source: source,
+            Comment: comment
+        });
+    }
+    encodePNG(compression, metadata) {
+        return this.encode(compression, metadata);
+    }
+    async encodeJPEG(quality = 90) {
+        return jpeg.encode(this.__bytes__(), this.width, this.height, quality);
+    }
+    static async decode(input, options = {}) {
+        const { applyOrientation = true } = options;
+        const data = view(input);
+        const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        let decoded;
+        if (ImageType.isPNG(dataView))
+            decoded = await png.decode(data);
+        else if (ImageType.isJPEG(dataView))
+            decoded = jpeg.decode(data);
+        else if (ImageType.isTIFF(dataView))
+            decoded = await tiff.decode(data);
+        else
+            throw new Error('Unsupported image type');
+        const image = new Image(decoded.width, decoded.height);
+        image.bitmap.set(decoded.pixels);
+        return applyOrientation && decoded.orientation ? image.__orient__(decoded.orientation) : image;
+    }
+    __orient__(orientation) {
+        if (orientation <= 1 || orientation > 8)
+            return this;
+        const w = this.width, h = this.height;
+        const swap = orientation >= 5;
+        const out = new Image(swap ? h : w, swap ? w : h);
+        const src = this.__u32__, dst = out.__u32__;
+        const ow = out.width, oh = out.height;
+        for (let Y = 0; Y < oh; Y++) {
+            for (let X = 0; X < ow; X++) {
+                let x, y;
+                switch (orientation) {
+                    case 2:
+                        x = w - 1 - X;
+                        y = Y;
+                        break;
+                    case 3:
+                        x = w - 1 - X;
+                        y = h - 1 - Y;
+                        break;
+                    case 4:
+                        x = X;
+                        y = h - 1 - Y;
+                        break;
+                    case 5:
+                        x = Y;
+                        y = X;
+                        break;
+                    case 6:
+                        x = Y;
+                        y = h - 1 - X;
+                        break;
+                    case 7:
+                        x = w - 1 - Y;
+                        y = h - 1 - X;
+                        break;
+                    default:
+                        x = w - 1 - Y;
+                        y = X;
+                        break;
+                }
+                dst[Y * ow + X] = src[y * w + x];
+            }
+        }
+        return this.__apply__(out);
+    }
+    static get SVG_MODE_SCALE() {
+        return 1;
+    }
+    static get SVG_MODE_WIDTH() {
+        return 2;
+    }
+    static get SVG_MODE_HEIGHT() {
+        return 3;
+    }
+    static async renderSVG(svg, size = 1, mode = Image.SVG_MODE_SCALE) {
+        if (![1, 2, 3].includes(mode))
+            throw new Error('Invalid SVG scaling mode');
+        if (mode === Image.SVG_MODE_SCALE && size <= 0)
+            throw new RangeError('SVG scale must be > 0');
+        if (mode !== Image.SVG_MODE_SCALE && size < 1)
+            throw new RangeError('SVG size must be >= 1');
+        const { width, height, pixels } = svgRenderer.render(typeof svg === 'string' ? svg : view(svg), mode, size);
+        const image = new Image(width, height);
+        image.bitmap.set(pixels);
+        return image;
+    }
+    static async renderText(font, size, text, color = 0xffffffff, layout = new TextLayout(), style = {}) {
+        const { strokeWidth = 0, strokeColor = 0x000000ff } = style;
+        if (isNaN(strokeWidth) || strokeWidth < 0)
+            throw new RangeError('Invalid stroke width');
+        const rendered = textRenderer.render(view(font), size, text, layout);
+        const [r, g, b, a] = Image.colorToRGBA(color);
+        const pad = Math.ceil(strokeWidth);
+        const width = rendered.width + 2 * pad, height = rendered.height + 2 * pad;
+        const coverage = new Uint8Array(width * height);
+        for (let y = 0; y < rendered.height; y++)
+            coverage.set(rendered.coverage.subarray(y * rendered.width, (y + 1) * rendered.width), (y + pad) * width + pad);
+        const image = new Image(width, height);
+        const bitmap = image.bitmap;
+        if (!strokeWidth) {
+            for (let i = 0; i < coverage.length; i++) {
+                if (!coverage[i])
+                    continue;
+                bitmap[i * 4] = r;
+                bitmap[i * 4 + 1] = g;
+                bitmap[i * 4 + 2] = b;
+                bitmap[i * 4 + 3] = coverage[i] * a / 255;
+            }
+            return image;
+        }
+        const stroke = outline(coverage, width, height, strokeWidth);
+        const [sr, sg, sb, sa] = Image.colorToRGBA(strokeColor);
+        for (let i = 0; i < coverage.length; i++) {
+            const af = coverage[i] / 255 * a / 255, as = stroke[i] * sa / 255;
+            const ao = af + as * (1 - af);
+            if (ao <= 0)
+                continue;
+            bitmap[i * 4] = (r * af + sr * as * (1 - af)) / ao;
+            bitmap[i * 4 + 1] = (g * af + sg * as * (1 - af)) / ao;
+            bitmap[i * 4 + 2] = (b * af + sb * as * (1 - af)) / ao;
+            bitmap[i * 4 + 3] = ao * 255;
+        }
+        return image;
+    }
+}
+const SUBSAMPLES = 4;
+function pixelCoverage(px, py, inside) {
+    let count = 0;
+    for (let j = 0; j < SUBSAMPLES; j++)
+        for (let i = 0; i < SUBSAMPLES; i++)
+            if (inside(px + (i + 0.5) / SUBSAMPLES, py + (j + 0.5) / SUBSAMPLES))
+                count++;
+    return count / (SUBSAMPLES * SUBSAMPLES);
+}
+function circleCoverage(px, py, cx, cy, radius) {
+    const d = Math.hypot(px + 0.5 - cx, py + 0.5 - cy);
+    if (d <= radius - Math.SQRT1_2)
+        return 1;
+    if (d >= radius + Math.SQRT1_2)
+        return 0;
+    return pixelCoverage(px, py, (x, y) => (x - cx) ** 2 + (y - cy) ** 2 <= radius * radius);
+}
+function channel(value) {
+    return value > 255 ? 255 : value > 0 ? Math.round(value) : 0;
+}
+function wrapHue(h) {
+    const t = h - Math.trunc(h) + 1;
+    return t < 1 ? t : t < 2 ? t - 1 : 0;
+}
+function hue2rgb(p, q, t) {
+    if (t < 0)
+        t += 1;
+    if (t > 1)
+        t -= 1;
+    if (t < 1 / 6)
+        return p + (q - p) * 6 * t;
+    if (t < 1 / 2)
+        return q;
+    if (t < 2 / 3)
+        return p + (q - p) * (2 / 3 - t) * 6;
+    return p;
+}
+const hardLight = (b, s) => s <= 0.5 ? b * 2 * s : 1 - (1 - b) * (1 - (2 * s - 1));
+const BLEND_MODES = {
+    'normal': (_b, s) => s,
+    'multiply': (b, s) => b * s,
+    'screen': (b, s) => b + s - b * s,
+    'overlay': (b, s) => hardLight(s, b),
+    'darken': (b, s) => Math.min(b, s),
+    'lighten': (b, s) => Math.max(b, s),
+    'color-dodge': (b, s) => b === 0 ? 0 : s === 1 ? 1 : Math.min(1, b / (1 - s)),
+    'color-burn': (b, s) => b === 1 ? 1 : s === 0 ? 0 : 1 - Math.min(1, (1 - b) / s),
+    'hard-light': hardLight,
+    'soft-light': (b, s) => {
+        if (s <= 0.5)
+            return b - (1 - 2 * s) * b * (1 - b);
+        const d = b <= 0.25 ? ((16 * b - 12) * b + 4) * b : Math.sqrt(b);
+        return b + (2 * s - 1) * (d - b);
+    },
+    'difference': (b, s) => Math.abs(b - s),
+    'exclusion': (b, s) => b + s - 2 * b * s,
+    'add': (b, s) => Math.min(1, b + s)
+};
+function outline(coverage, width, height, radius) {
+    const count = width * height;
+    const distance = new Float64Array(count);
+    for (let i = 0; i < count; i++)
+        distance[i] = coverage[i] >= 128 ? 0 : Infinity;
+    const size = Math.max(width, height);
+    const line = new Float64Array(size), result = new Float64Array(size);
+    const parabolas = new Int32Array(size), bounds = new Float64Array(size + 1);
+    for (let x = 0; x < width; x++) {
+        for (let y = 0; y < height; y++)
+            line[y] = distance[y * width + x];
+        distanceTransform(line, height, result, parabolas, bounds);
+        for (let y = 0; y < height; y++)
+            distance[y * width + x] = result[y];
+    }
+    for (let y = 0; y < height; y++) {
+        const row = y * width;
+        for (let x = 0; x < width; x++)
+            line[x] = distance[row + x];
+        distanceTransform(line, width, result, parabolas, bounds);
+        for (let x = 0; x < width; x++)
+            distance[row + x] = result[x];
+    }
+    const out = new Float32Array(count);
+    for (let i = 0; i < count; i++) {
+        const d = Math.sqrt(distance[i]);
+        out[i] = Math.max(coverage[i] / 255, Math.min(1, Math.max(0, radius + 0.5 - d)));
+    }
+    return out;
+}
+function distanceTransform(f, n, d, v, z) {
+    let k = -1;
+    for (let q = 0; q < n; q++) {
+        if (f[q] === Infinity)
+            continue;
+        let s = 0;
+        while (k >= 0) {
+            s = (f[q] + q * q - (f[v[k]] + v[k] * v[k])) / (2 * q - 2 * v[k]);
+            if (s > z[k])
+                break;
+            k--;
+        }
+        k++;
+        v[k] = q;
+        z[k] = k === 0 ? -Infinity : s;
+        z[k + 1] = Infinity;
+    }
+    if (k < 0) {
+        d.fill(Infinity, 0, n);
+        return;
+    }
+    for (let q = 0, j = 0; q < n; q++) {
+        while (z[j + 1] < q)
+            j++;
+        d[q] = (q - v[j]) ** 2 + f[v[j]];
+    }
+}