imagescript 3.2.1 → 3.4.0

package/dist/gif.js

@@ -13,10 +13,10 @@ export class GIF extends Animation {
         return this.encodeGIF(qualityOrOptions);
     }
     static async decode(input, onlyFirstFrameOrOptions = false) {
-        const onlyExtractFirstFrame = isOptions(onlyFirstFrameOrOptions) ? onlyFirstFrameOrOptions.onlyFirstFrame ?? false : onlyFirstFrameOrOptions;
+        const { onlyFirstFrame = false, maxPixels } = isOptions(onlyFirstFrameOrOptions) ? onlyFirstFrameOrOptions : { onlyFirstFrame: onlyFirstFrameOrOptions };
         const data = view(input);
         if (!ImageType.isGIF(new DataView(data.buffer, data.byteOffset, data.byteLength)))
             throw new Error('Unsupported image type');
-        return Animation.__fromGIF__(data, onlyExtractFirstFrame, GIF);
+        return Animation.__fromGIF__(data, onlyFirstFrame, GIF, maxPixels);
     }
 }

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';
@@ -26,6 +27,15 @@ export interface CompositeOptions {
 export interface ResizeOptions {
     /** The resizing mode. Default: {@link Image.RESIZE_BILINEAR} */
     mode?: ResizeMode;
+    /**
+     * Whether to round to 8 bits between the two passes, so two channels share the multiplications of both: about
+     * 15-25% faster for opaque images, with 10-25% of the channel values a step off the precise result (instead of
+     * about 1%, never more than 1). Transparent images are premultiplied to 8 bits like browsers do, which makes them
+     * about twice as fast: what shows once they're composited differs by up to about 2 steps, pixels that are almost
+     * transparent keep less of their color. Only affects {@link Image.RESIZE_BILINEAR} and {@link Image.RESIZE_AREA},
+     * down to about a third of the size. Default: `true`
+     */
+    fast?: boolean;
 }
 /**
  * Options of {@link Image.opacity}, {@link Image.red}, {@link Image.green}, {@link Image.blue}, {@link Image.lightness}
@@ -56,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;
@@ -92,6 +118,19 @@ export interface TextOptions extends TextStyle {
 export interface DecodeOptions {
     /** Whether to rotate/mirror JPEGs, TIFFs, PNGs and WebPs as their orientation tag (Exif or XMP) says. Default: `true` */
     applyOrientation?: boolean;
+    /**
+     * The most pixels to decode: larger images throw a RangeError before anything that size is allocated, so small
+     * files declaring huge images (decompression bombs) can't exhaust the memory. Default: `268402689` (16383², like
+     * 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 {
@@ -126,6 +165,13 @@ export interface DominantColorOptions {
 export interface RotateOptions {
     /** Whether to resize the image so it fits all pixels or just ignore outlying pixels. Default: `true` */
     resize?: boolean;
+    /**
+     * Whether to sample with 8-bit weights on 8-bit premultiplied pixels (like {@link ResizeOptions.fast}), about twice
+     * as fast: opaque pixels stay within a step of the precise result, what shows of translucent ones (also the
+     * faded edges) within about 2.5 steps (pixels that are almost transparent keep less of their color). Only affects
+     * angles that aren't multiples of 90°. Default: `true`
+     */
+    fast?: boolean;
 }
 /** Options of {@link Image.trim} */
 export interface TrimOptions {
@@ -165,9 +211,7 @@ export declare class Image {
     get bitmap(): Uint8ClampedArray;
     /** Replaces the pixel data, the array has to hold width * height * 4 bytes */
     set bitmap(bitmap: Uint8ClampedArray | Uint8Array);
-    /**
-     * @private
-     */
+    /** A short description for debugging, e.g. `Image<64x64>` */
     toString(): string;
     /**
      * The images width
@@ -669,7 +713,16 @@ export declare class Image {
      * Encodes the image into a PNG, an alias of {@link Image.encode}
      */
     encodePNG(options?: PNGEncodeOptions): Promise<Uint8Array>;
+    /**
+     * Encodes the image into a PNG, an alias of {@link Image.encode}
+     * @param compression The compression level (0-9). Default: `1`
+     * @param metadata Metadata to include, see {@link Metadata}
+     */
     encodePNG(compression?: number, metadata?: Metadata): Promise<Uint8Array>;
+    /**
+     * Encodes the image into a PNG, an alias of {@link Image.encode}
+     * @param metadata Metadata to include, see {@link Metadata}
+     */
     encodePNG(metadata?: Metadata): Promise<Uint8Array>;
     /**
      * Encodes the image into a JPEG
@@ -682,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
@@ -731,17 +801,23 @@ export declare class Image {
     static renderSVG(svg: string | BinaryData, size?: number, mode?: SVGScaleMode): Promise<Image>;
     /**
      * Creates a new image containing the rendered text.
-     * @param font TrueType (ttf/ttc) or OpenType (otf) font buffer to use
+     * @param font TrueType (ttf/ttc) or OpenType (otf) font buffer to use, or several by priority: every character
+     *     comes from the first font that has it (e.g. `[text, emoji]`), the first one sets the line height. Color
+     *     glyphs (COLR layers and paints, CBDT and sbix bitmaps, as in emoji fonts) keep their colors. Text in any script
+     *     is shaped like browsers do (right to left and bidirectional text, Arabic joining, Indic conjuncts, marks)
      * @param size Font size in pixels (per em)
      * @param text Text to render
      * @param options Color, layout and style, see {@link TextOptions}; the image grows by the outline width on every
      *     side
      * @return The rendered text
      */
-    static renderText(font: BinaryData, size: number, text: string, options?: TextOptions): Promise<Image>;
+    static renderText(font: BinaryData | BinaryData[], size: number, text: string, options?: TextOptions): Promise<Image>;
     /**
      * Creates a new image containing the rendered text.
-     * @param font TrueType (ttf/ttc) or OpenType (otf) font buffer to use
+     * @param font TrueType (ttf/ttc) or OpenType (otf) font buffer to use, or several by priority: every character
+     *     comes from the first font that has it (e.g. `[text, emoji]`), the first one sets the line height. Color
+     *     glyphs (COLR layers and paints, CBDT and sbix bitmaps, as in emoji fonts) keep their colors. Text in any script
+     *     is shaped like browsers do (right to left and bidirectional text, Arabic joining, Indic conjuncts, marks)
      * @param size Font size in pixels (per em)
      * @param text Text to render
      * @param [color=0xffffffff] Text color to use
@@ -749,5 +825,5 @@ export declare class Image {
      * @param style Outline, see {@link TextStyle}; the image grows by the outline width on every side
      * @return The rendered text
      */
-    static renderText(font: BinaryData, size: number, text: string, color?: Color, layout?: TextLayout, style?: TextStyle): Promise<Image>;
+    static renderText(font: BinaryData | BinaryData[], size: number, text: string, color?: Color, layout?: TextLayout, style?: TextStyle): Promise<Image>;
 }