imagescript 3.3.0 → 3.4.0

package/dist/codecs/webp.js

@@ -4,6 +4,8 @@
  */
 import * as vp8l from "./vp8l.js";
 import * as vp8 from "./vp8.js";
+import { encodeVP8, encodeAlpha } from "./vp8-enc.js";
+import { rgbaToYUV } from "./vp8-enc-dsp.js";
 import { orientation as exifOrientation } from "./exif.js";
 import { MAX_PIXELS, checkPixels } from "../util/limits.js";
 const fourCC = (s) => s.charCodeAt(0) | s.charCodeAt(1) << 8 | s.charCodeAt(2) << 16 | s.charCodeAt(3) << 24;
@@ -218,6 +220,15 @@ function riffChunk(type, body) {
     out.set(body, 8);
     return out;
 }
+function concat(parts) {
+    const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
+    let offset = 0;
+    for (const p of parts) {
+        out.set(p, offset);
+        offset += p.length;
+    }
+    return out;
+}
 function riff(chunks) {
     let size = 4;
     for (const c of chunks)
@@ -257,7 +268,29 @@ export function encode(rgba, width, height, exif) {
     set24(vp8x, 7, height - 1);
     return riff([riffChunk('VP8X', vp8x), bitstream, riffChunk('EXIF', exif)]);
 }
-export function encodeAnimation(frames, width, height, plays, exif) {
+export function encodeLossy(rgba, width, height, quality, exif, method = 4) {
+    const { alpha, chunks } = lossyChunks(rgba, width, height, quality, method);
+    if (!alpha && !exif)
+        return riff(chunks);
+    const vp8x = new Uint8Array(10);
+    vp8x[0] = (exif ? 8 : 0) | (alpha ? 16 : 0);
+    set24(vp8x, 4, width - 1);
+    set24(vp8x, 7, height - 1);
+    return riff([riffChunk('VP8X', vp8x), ...chunks, ...exif ? [riffChunk('EXIF', exif)] : []]);
+}
+function lossyChunks(rgba, width, height, quality, method) {
+    if (width > 16383 || height > 16383)
+        throw new RangeError('WebP: lossy images can be at most 16383 pixels wide and high');
+    const picture = rgbaToYUV(rgba, width, height);
+    const frame = encodeVP8(picture, quality, method);
+    const padded = new Uint8Array(frame.length + (frame.length & 1));
+    padded.set(frame);
+    const chunks = [riffChunk('VP8 ', padded)];
+    if (picture.a)
+        chunks.unshift(riffChunk('ALPH', encodeAlpha(picture.a, width, height, method)));
+    return { alpha: !!picture.a, chunks };
+}
+export function encodeAnimation(frames, width, height, plays, exif, quality, method = 4) {
     if (!frames.length)
         throw new Error('WebP: an animation needs at least one frame');
     if (width > 1 << 24 || height > 1 << 24)
@@ -276,7 +309,8 @@ export function encodeAnimation(frames, width, height, plays, exif) {
     for (const f of frames) {
         if (f.x & 1 || f.y & 1)
             throw new RangeError('WebP: frame offsets have to be even');
-        const bitstream = riffChunk('VP8L', vp8l.encode(toARGB(f.pixels, f.width * f.height), f.width, f.height));
+        const bitstream = quality === undefined ? riffChunk('VP8L', vp8l.encode(toARGB(f.pixels, f.width * f.height), f.width, f.height))
+            : concat(lossyChunks(f.pixels, f.width, f.height, quality, method).chunks);
         const header = new Uint8Array(16);
         set24(header, 0, f.x >> 1);
         set24(header, 3, f.y >> 1);

package/dist/image-type.d.ts

@@ -1,6 +1,6 @@
 import { BinaryData } from './util/mem.js';
 /** Image formats recognized by {@link ImageType.getType} */
-export type ImageTypeName = 'png' | 'jpeg' | 'tiff' | 'gif' | 'webp' | 'tga';
+export type ImageTypeName = 'png' | 'jpeg' | 'tiff' | 'gif' | 'webp' | 'avif' | 'jxl' | 'bmp' | 'ico' | 'cur' | 'qoi' | 'pnm' | 'hdr' | 'tga';
 /** Detects image formats by their magic numbers */
 export declare class ImageType {
     private constructor();
@@ -20,6 +20,20 @@ export declare class ImageType {
     static isGIF(data: BinaryData): boolean;
     /** Whether the data starts like a WebP */
     static isWebP(data: BinaryData): boolean;
+    /** Whether the data starts like an AVIF (the avif or avis brand) */
+    static isAVIF(data: BinaryData): boolean;
+    /** Whether the data starts like a JPEG XL (a codestream or the container) */
+    static isJXL(data: BinaryData): boolean;
+    /** Whether the data starts like a BMP */
+    static isBMP(data: BinaryData): boolean;
+    /** Whether the data is a Windows icon or cursor (ICO or CUR) */
+    static isICO(data: BinaryData): boolean;
+    /** Whether the data starts like a QOI */
+    static isQOI(data: BinaryData): boolean;
+    /** Whether the data starts like a Netpbm image (PBM, PGM, PPM, PAM or PFM) */
+    static isPNM(data: BinaryData): boolean;
+    /** Whether the data starts like a Radiance HDR */
+    static isHDR(data: BinaryData): boolean;
     /** Whether the data looks like a TGA (which has no magic number: its header has to be consistent) */
     static isTGA(data: BinaryData): boolean;
 }

package/dist/image-type.js

@@ -1,5 +1,12 @@
 import { view as bytes } from "./util/mem.js";
 import { isTGA } from "./codecs/tga.js";
+import { isBMP } from "./codecs/bmp.js";
+import { iconType } from "./codecs/ico.js";
+import { isQOI } from "./codecs/qoi.js";
+import { isNetpbm } from "./codecs/netpbm.js";
+import { isHDR } from "./codecs/hdr.js";
+import { isAVIF } from "./codecs/avif.js";
+import { isJXL } from "./codecs/jxl.js";
 const MAGIC_NUMBERS = {
     PNG: 0x89504e47,
     JPEG: 0xffd8ff,
@@ -17,6 +24,7 @@ function dataView(data) {
     const u8 = bytes(data);
     return new DataView(u8.buffer, u8.byteOffset, u8.byteLength);
 }
+const u8 = (view) => new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
 export class ImageType {
     constructor() { }
     static getType(data) {
@@ -31,6 +39,21 @@ export class ImageType {
             return 'gif';
         if (this.isWebP(view))
             return 'webp';
+        if (this.isAVIF(view))
+            return 'avif';
+        if (this.isJXL(view))
+            return 'jxl';
+        if (this.isBMP(view))
+            return 'bmp';
+        const icon = iconType(u8(view));
+        if (icon)
+            return icon;
+        if (this.isQOI(view))
+            return 'qoi';
+        if (this.isPNM(view))
+            return 'pnm';
+        if (this.isHDR(view))
+            return 'hdr';
         if (this.isTGA(view))
             return 'tga';
         return null;
@@ -58,8 +81,28 @@ export class ImageType {
         const view = dataView(data);
         return view.byteLength >= 12 && view.getUint32(0, false) === MAGIC_NUMBERS.RIFF && view.getUint32(8, false) === MAGIC_NUMBERS.WEBP;
     }
+    static isAVIF(data) {
+        return isAVIF(u8(dataView(data)));
+    }
+    static isJXL(data) {
+        return isJXL(u8(dataView(data)));
+    }
+    static isBMP(data) {
+        return isBMP(u8(dataView(data)));
+    }
+    static isICO(data) {
+        return iconType(u8(dataView(data))) !== null;
+    }
+    static isQOI(data) {
+        return isQOI(u8(dataView(data)));
+    }
+    static isPNM(data) {
+        return isNetpbm(u8(dataView(data)));
+    }
+    static isHDR(data) {
+        return isHDR(u8(dataView(data)));
+    }
     static isTGA(data) {
-        const view = dataView(data);
-        return isTGA(new Uint8Array(view.buffer, view.byteOffset, view.byteLength));
+        return isTGA(u8(dataView(data)));
     }
 }

package/dist/image.d.ts

@@ -1,3 +1,4 @@
+import type { ToneMapping } from './codecs/hdr.js';
 import { BinaryData } from './util/mem.js';
 import { TextLayout } from './text-layout.js';
 import { Metadata } from './metadata.js';
@@ -65,7 +66,23 @@ export interface JPEGEncodeOptions {
     /** Metadata to include, see {@link Metadata} */
     metadata?: Metadata;
 }
-/** Options of {@link Image.encodeWebP} and {@link Image.encodeTGA} */
+/** Options of {@link Image.encodeWebP} */
+export interface WebPEncodeOptions {
+    /**
+     * Lossy compression (0-100, like libwebp's quality: 75 is its default): the image is encoded like cwebp encodes it
+     * with its default settings, much smaller than lossless. Without it the image is encoded losslessly
+     */
+    quality?: number;
+    /**
+     * How much effort lossy compression takes (0-6, libwebp's method): higher is smaller but slower. 0-2 pick the
+     * predictions by how close they are, 3 and up also by how many bits they take, 5 and 6 also optimize the
+     * quantized values. Default: `4` (like cwebp)
+     */
+    effort?: number;
+    /** Metadata to include, see {@link Metadata} */
+    metadata?: Metadata;
+}
+/** Options of {@link Image.encodeTGA} */
 export interface EncodeOptions {
     /** Metadata to include, see {@link Metadata} */
     metadata?: Metadata;
@@ -107,6 +124,13 @@ export interface DecodeOptions {
      * sharp), `Infinity` for no limit
      */
     maxPixels?: number;
+    /**
+     * How Radiance HDRs, PFMs and HDR (PQ or HLG) AVIFs and JPEG XLs, whose light can be brighter than (SDR) white,
+     * become 8 bit sRGB: `'reinhard'` compresses the brightest parts like Reinhard's tone mapping operator does (the
+     * brightest pixel becomes white, images no brighter than white stay as they are), `'clamp'` clamps everything
+     * brighter than white. Default: `'reinhard'`
+     */
+    toneMapping?: ToneMapping;
 }
 /** Text style options of {@link Image.renderText} */
 export interface TextStyle {
@@ -711,18 +735,35 @@ export declare class Image {
      */
     encodeJPEG(quality?: number): Promise<Uint8Array>;
     /**
-     * Encodes the image as lossless WebP (usually 20-30% smaller than PNG, but slower to encode)
-     * @param options See {@link EncodeOptions}
+     * Encodes the image as WebP: lossless (usually 20-30% smaller than PNG, but slower to encode), or lossy with a
+     * quality
+     * @param options See {@link WebPEncodeOptions}
      */
-    encodeWebP({ metadata }?: EncodeOptions): Promise<Uint8Array>;
+    encodeWebP({ quality, effort, metadata }?: WebPEncodeOptions): Promise<Uint8Array>;
     /**
      * Encodes the image as run length encoded TGA (32 bit, or 24 bit if the image is opaque)
      * @param options See {@link EncodeOptions}
      */
     encodeTGA({ metadata }?: EncodeOptions): Promise<Uint8Array>;
     /**
-     * Decodes an image (PNG, JPEG, TIFF, WebP or TGA). For APNGs this is the default image; animated WebPs and GIFs
-     * have no single image, decode those with {@link Animation.decode}
+     * Encodes the image as BMP: with a palette if it is opaque and has at most 256 colors, else with 24 bit pixels, or
+     * 32 bit ones if it has transparency
+     */
+    encodeBMP(): Promise<Uint8Array>;
+    /**
+     * Encodes the image as QOI (3 channels if the image is opaque)
+     */
+    encodeQOI(): Promise<Uint8Array>;
+    /**
+     * Encodes the image as the smallest fitting Netpbm format: PBM for black and white images, PGM for greyscale ones,
+     * PPM for others, PAM if the image has transparency
+     */
+    encodePNM(): Promise<Uint8Array>;
+    /**
+     * Decodes an image (PNG, JPEG, TIFF, WebP, BMP, ICO, CUR, QOI, PBM, PGM, PPM, PAM, PFM, Radiance HDR, TGA, AVIF or
+     * JPEG XL). For APNGs this is the default image; animated WebPs and GIFs have no single image, decode those with
+     * {@link Animation.decode}; for icons and cursors it's their largest image, for AVIF image sequences and JPEG XL
+     * animations their first frame
      * @param input The binary data to decode
      * @param options See {@link DecodeOptions}. JPEGs, TIFFs and PNGs are rotated/mirrored as their orientation tag
      *     (Exif, for PNGs also XMP) says by default: photos taken with a rotated camera are stored sideways

package/dist/image.js

@@ -3,6 +3,13 @@ import * as jpeg from "./codecs/jpeg.js";
 import * as tiff from "./codecs/tiff.js";
 import * as webp from "./codecs/webp.js";
 import * as tga from "./codecs/tga.js";
+import * as bmp from "./codecs/bmp.js";
+import * as ico from "./codecs/ico.js";
+import * as qoi from "./codecs/qoi.js";
+import * as netpbm from "./codecs/netpbm.js";
+import * as hdr from "./codecs/hdr.js";
+import * as avif from "./codecs/avif.js";
+import * as jxl from "./codecs/jxl.js";
 import * as quantize from "./codecs/quantize.js";
 import * as textRenderer from "./render/text.js";
 import * as svgRenderer from "./render/svg.js";
@@ -996,15 +1003,34 @@ export class Image {
         const m = resolveMetadata(metadata);
         return jpeg.encode(this.__bytes__(), this.width, this.height, finite(quality, 'quality'), { exif: exifData(m), comment: m.comment ? utf8(m.comment) : undefined });
     }
-    async encodeWebP({ metadata = {} } = {}) {
-        return webp.encode(this.__bytes__(), this.width, this.height, exifData(resolveMetadata(metadata)));
+    async encodeWebP({ quality, effort = 4, metadata = {} } = {}) {
+        const exif = exifData(resolveMetadata(metadata));
+        if (quality === undefined)
+            return webp.encode(this.__bytes__(), this.width, this.height, exif);
+        const q = finite(quality, 'quality');
+        if (q < 0 || q > 100)
+            throw new RangeError(`quality must be 0-100, not ${q}`);
+        if (!Number.isInteger(effort) || effort < 0 || effort > 6)
+            throw new RangeError(`effort must be an integer 0-6, not ${effort}`);
+        return webp.encodeLossy(this.__bytes__(), this.width, this.height, q, exif, effort);
     }
     async encodeTGA({ metadata = {} } = {}) {
         const { author, comment, creationTime: time, software } = resolveMetadata(metadata);
         return tga.encode(this.__bytes__(), this.width, this.height, { author, comment, time, software });
     }
+    async encodeBMP() {
+        return bmp.encode(this.__bytes__(), this.width, this.height);
+    }
+    async encodeQOI() {
+        return qoi.encode(this.__bytes__(), this.width, this.height);
+    }
+    async encodePNM() {
+        return netpbm.encode(this.__bytes__(), this.width, this.height);
+    }
     static async decode(input, options = {}) {
-        const { applyOrientation = true, maxPixels = MAX_PIXELS } = options;
+        const { applyOrientation = true, maxPixels = MAX_PIXELS, toneMapping = 'reinhard' } = options;
+        if (toneMapping !== 'reinhard' && toneMapping !== 'clamp')
+            throw new TypeError(`toneMapping must be 'reinhard' or 'clamp', not ${String(toneMapping)}`);
         const data = view(input);
         const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
         const decoded = await decoding(() => {
@@ -1019,6 +1045,26 @@ export class Image {
                     throw new Error('Animated WebPs have to be decoded with Animation.decode()');
                 return webp.decode(data, maxPixels);
             }
+            const bitmap = async (decoded) => {
+                if (!('embedded' in decoded))
+                    return decoded;
+                const { width, height, pixels } = decoded.embedded === 'png' ? await png.decode(decoded.data, maxPixels) : jpeg.decode(decoded.data, { maxPixels });
+                return { width, height, pixels };
+            };
+            if (ImageType.isAVIF(dataView))
+                return avif.decode(data, maxPixels, toneMapping);
+            if (ImageType.isJXL(dataView))
+                return jxl.decode(data, maxPixels, toneMapping);
+            if (ImageType.isBMP(dataView))
+                return bitmap(bmp.decode(data, maxPixels));
+            if (ImageType.isICO(dataView))
+                return bitmap(ico.decode(data, maxPixels));
+            if (ImageType.isQOI(dataView))
+                return qoi.decode(data, maxPixels);
+            if (ImageType.isPNM(dataView))
+                return netpbm.decode(data, maxPixels, toneMapping);
+            if (ImageType.isHDR(dataView))
+                return hdr.decode(data, maxPixels, toneMapping);
             if (ImageType.isTGA(dataView))
                 return tga.decode(data, maxPixels);
             throw new Error('Unsupported image type');

package/dist/index.d.ts

@@ -3,16 +3,17 @@ import { Image, DecodeOptions } from './image.js';
 import { GIF } from './gif.js';
 import { Animation, AnimationDecodeOptions } from './animation.js';
 export { Image } from './image.js';
-export type { Color, ColorFunction, ResizeMode, SVGScaleMode, PNGMetadata, TextStyle, DecodeOptions, CompositeOptions, BlendMode, CropCircleOptions, DominantColorOptions, RotateOptions, ColorToAlphaOptions, ResizeOptions, AdjustOptions, SharpenOptions, PNGEncodeOptions, JPEGEncodeOptions, EncodeOptions, SVGOptions, TextOptions, RoundCornersOptions, FisheyeOptions, TrimOptions } from './image.js';
+export type { Color, ColorFunction, ResizeMode, SVGScaleMode, PNGMetadata, TextStyle, DecodeOptions, CompositeOptions, BlendMode, CropCircleOptions, DominantColorOptions, RotateOptions, ColorToAlphaOptions, ResizeOptions, AdjustOptions, SharpenOptions, PNGEncodeOptions, JPEGEncodeOptions, WebPEncodeOptions, EncodeOptions, SVGOptions, TextOptions, RoundCornersOptions, FisheyeOptions, TrimOptions } from './image.js';
 export { Frame } from './frame.js';
 export type { FrameDisposalModeName, FrameDisposalModeId, FrameOptions } from './frame.js';
 export { GIF } from './gif.js';
 export { Animation } from './animation.js';
-export type { AnimationOptions, AnimationDecodeOptions, AnimationEncodeOptions, GIFEncodeOptions, APNGEncodeOptions } from './animation.js';
+export type { AnimationOptions, AnimationDecodeOptions, AnimationEncodeOptions, WebPAnimationEncodeOptions, GIFEncodeOptions, APNGEncodeOptions } from './animation.js';
 export { TextLayout } from './text-layout.js';
 export type { TextLayoutOptions, WrapStyle, HorizontalAlign, VerticalAlign } from './text-layout.js';
 export { ImageType } from './image-type.js';
 export type { ImageTypeName } from './image-type.js';
+export type { ToneMapping } from './codecs/hdr.js';
 export type { BinaryData } from './util/mem.js';
 export type { Metadata } from './metadata.js';
 /**

package/dist/index.js

@@ -12,11 +12,11 @@ export { Animation } from "./animation.js";
 export { TextLayout } from "./text-layout.js";
 export { ImageType } from "./image-type.js";
 export function decode(data, onlyFirstFrameOrOptions = false) {
-    const { onlyFirstFrame = false, applyOrientation, maxPixels } = isOptions(onlyFirstFrameOrOptions) ? onlyFirstFrameOrOptions : { onlyFirstFrame: onlyFirstFrameOrOptions };
+    const { onlyFirstFrame = false, applyOrientation, maxPixels, toneMapping } = isOptions(onlyFirstFrameOrOptions) ? onlyFirstFrameOrOptions : { onlyFirstFrame: onlyFirstFrameOrOptions };
     const type = ImageType.getType(data);
     if (type === 'gif')
         return GIF.decode(data, { onlyFirstFrame, maxPixels });
     if (type === 'webp' && webp.isAnimated(view(data)))
         return Animation.decode(data, { onlyFirstFrame, maxPixels });
-    return Image.decode(data, { applyOrientation, maxPixels });
+    return Image.decode(data, { applyOrientation, maxPixels, toneMapping });
 }

package/dist/render/hinting.js

@@ -12,6 +12,12 @@ class SkipInstruction extends Error {
 }
 const roundHalfAway = (v) => v < 0 ? -Math.round(-v) : Math.round(v);
 const mulFix = (a, b) => roundHalfAway(a * b / 65536);
+const mulDiv = (a, b, c) => {
+    if (!c)
+        return a * b < 0 ? -0x7fffffff : 0x7fffffff;
+    const d = Math.floor((Math.abs(a * b) + Math.abs(c) / 2) / Math.abs(c));
+    return a * b * c < 0 ? -d : d;
+};
 const divFix = (a, b) => b === 0 ? 0 : roundHalfAway(a * 65536 / b);
 const ROUND_GRID = { period: 64, phase: 0, threshold: 32 };
 const defaultState = () => ({
@@ -347,10 +353,10 @@ class Execution {
     }
     lineVector(p1, p2, perpendicular, original) {
         const z1 = this.zone(this.gs.zp1), z2 = this.zone(this.gs.zp2);
-        this.point(z1, p2);
-        this.point(z2, p1);
-        let x = (original ? z1.orgX[p2] - z2.orgX[p1] : z1.curX[p2] - z2.curX[p1]);
-        let y = (original ? z1.orgY[p2] - z2.orgY[p1] : z1.curY[p2] - z2.curY[p1]);
+        this.point(z1, p1);
+        this.point(z2, p2);
+        let x = (original ? z1.orgX[p1] - z2.orgX[p2] : z1.curX[p1] - z2.curX[p2]);
+        let y = (original ? z1.orgY[p1] - z2.orgY[p2] : z1.curY[p1] - z2.curY[p2]);
         if (x === 0 && y === 0) {
             x = 1;
             y = 0;
@@ -475,18 +481,19 @@ class Execution {
                         [a0, a1].forEach(i => this.point(za, i));
                         [b0, b1].forEach(i => this.point(zb, i));
                         this.point(z, p);
-                        const ax0 = za.curX[a0], ay0 = za.curY[a0], ax1 = za.curX[a1], ay1 = za.curY[a1];
-                        const bx0 = zb.curX[b0], by0 = zb.curY[b0], bx1 = zb.curX[b1], by1 = zb.curY[b1];
+                        const ax0 = Math.round(za.curX[a0]), ay0 = Math.round(za.curY[a0]), ax1 = Math.round(za.curX[a1]), ay1 = Math.round(za.curY[a1]);
+                        const bx0 = Math.round(zb.curX[b0]), by0 = Math.round(zb.curY[b0]), bx1 = Math.round(zb.curX[b1]), by1 = Math.round(zb.curY[b1]);
                         const dax = ax1 - ax0, day = ay1 - ay0, dbx = bx1 - bx0, dby = by1 - by0;
-                        const det = dax * dby - day * dbx;
-                        if (Math.abs(det) < 1e-9) {
-                            z.curX[p] = (ax0 + ax1 + bx0 + bx1) / 4;
-                            z.curY[p] = (ay0 + ay1 + by0 + by1) / 4;
+                        const discriminant = mulDiv(dax, -dby, 64) + mulDiv(day, dbx, 64);
+                        const dotProduct = mulDiv(dax, dbx, 64) + mulDiv(day, dby, 64);
+                        if (19 * Math.abs(discriminant) > Math.abs(dotProduct)) {
+                            const v = mulDiv(bx0 - ax0, -dby, 64) + mulDiv(by0 - ay0, dbx, 64);
+                            z.curX[p] = ax0 + mulDiv(v, dax, discriminant);
+                            z.curY[p] = ay0 + mulDiv(v, day, discriminant);
                         }
                         else {
-                            const t = ((bx0 - ax0) * dby - (by0 - ay0) * dbx) / det;
-                            z.curX[p] = ax0 + t * dax;
-                            z.curY[p] = ay0 + t * day;
+                            z.curX[p] = Math.trunc((ax0 + ax1 + bx0 + bx1) / 4);
+                            z.curY[p] = Math.trunc((ay0 + ay1 + by0 + by1) / 4);
                         }
                         z.touchX[p] = z.touchY[p] = 1;
                         break;
@@ -540,11 +547,12 @@ class Execution {
                     case 0x76:
                     case 0x77: {
                         const n = this.pop();
-                        const grid = op === 0x76 ? 64 : 64 / Math.SQRT2;
-                        const period = [grid / 2, grid, grid * 2, grid][n >> 6 & 3];
-                        const phase = [0, period / 4, period / 2, period * 3 / 4][n >> 4 & 3];
+                        const grid = op === 0x76 ? 0x4000 : 0x2d41;
+                        const period = [grid >> 1, grid, grid * 2, grid][n >> 6 & 3];
+                        const phase = [0, period >> 2, period >> 1, Math.trunc(period * 3 / 4)][n >> 4 & 3];
                         const t = n & 15;
-                        gs.round = { period, phase, threshold: t === 0 ? period - 1 : (t - 4) * period / 8 };
+                        const threshold = t === 0 ? period - 1 : Math.trunc((t - 4) * period / 8);
+                        gs.round = { period: period >> 8, phase: phase >> 8, threshold: threshold >> 8 };
                         break;
                     }
                     case 0x1a:
@@ -1024,7 +1032,7 @@ class Execution {
                         const z0 = this.zone(gs.zp0), z1 = this.zone(gs.zp1);
                         this.point(z0, p2);
                         this.point(z1, p1);
-                        const d = this.project(z0.curX[p2] - z1.curX[p1], z0.curY[p2] - z1.curY[p1]) / 2;
+                        const d = Math.trunc(Math.round(this.project(z0.curX[p2] - z1.curX[p1], z0.curY[p2] - z1.curY[p1])) / 2);
                         this.move(z1, p1, d);
                         this.move(z0, p2, -d);
                         break;

package/dist/render/layout.js

@@ -207,7 +207,7 @@ export class ApplyContext {
         this.initIters();
     }
     randomNumber() {
-        this.randomState = this.randomState * 48271 % 2147483647;
+        this.randomState = (Math.imul(this.randomState, 48271) >>> 0) % 2147483647;
         return this.randomState;
     }
     recurse(lookupIndex) {

package/dist/render/svg.js

@@ -421,7 +421,7 @@ class Document {
         const presentation = {};
         for (const name in node.attrs)
             if (PROPERTIES.has(name))
-                presentation[name] = node.attrs[name];
+                presentation[name] = node.attrs[name].trim();
         apply(presentation);
         const rules = this.rules.filter(rule => rule.match(node));
         const inline = node.attrs.style ? parseDeclarations(node.attrs.style) : null;

package/dist/render/unicode.js

@@ -1,13 +1,5 @@
+import { base64 } from "../util/bytes.js";
 const decoded = new WeakMap();
-const fromBase64 = Uint8Array.fromBase64;
-function base64(text) {
-    if (fromBase64)
-        return fromBase64(text);
-    const binary = atob(text), bytes = new Uint8Array(binary.length);
-    for (let i = 0; i < binary.length; i++)
-        bytes[i] = binary.charCodeAt(i);
-    return bytes;
-}
 function decode(property) {
     let ranges = decoded.get(property);
     if (ranges)

package/dist/util/bytes.js

@@ -1,3 +1,12 @@
+const fromBase64 = Uint8Array.fromBase64;
+export function base64(text) {
+    if (fromBase64)
+        return fromBase64(text);
+    const binary = atob(text), bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++)
+        bytes[i] = binary.charCodeAt(i);
+    return bytes;
+}
 export class ByteWriter {
     buffer;
     length = 0;

package/dist/util/resample.js

@@ -192,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;
@@ -367,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/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "imagescript",
-  "version": "3.3.0",
+  "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"
   }
 }