imagescript 3.1.0 → 3.2.0

package/dist/codecs/tga.d.ts

@@ -1,16 +0,0 @@
-/**
- * Whether the data looks like a TGA. Older TGAs have no signature, so this checks that the header is consistent
- */
-export declare function isTGA(d: Uint8Array): boolean;
-/**
- * Decodes a TGA into RGBA
- */
-export declare function decode(d: Uint8Array): {
-    width: number;
-    height: number;
-    pixels: Uint8Array;
-};
-/**
- * Encodes RGBA pixels into a run length encoded TGA (32 bit with alpha, 24 bit if opaque), top left origin
- */
-export declare function encode(rgba: Uint8Array, width: number, height: number): Uint8Array;

package/dist/codecs/tiff.d.ts

@@ -1,6 +0,0 @@
-export declare function decode(data: Uint8Array): Promise<{
-    width: number;
-    height: number;
-    pixels: Uint8Array;
-    orientation: number;
-}>;

package/dist/codecs/vp8-tables.d.ts

@@ -1,10 +0,0 @@
-/*!
- * VP8 constant tables, extracted from RFC 6386 ("VP8 Data Format and Decoding Guide", sections 9.6, 11.5, 13.4,
- * 13.5 and 14.1). Copyright (c) 2010, 2011 Google Inc., BSD license (see THIRD_PARTY_NOTICES.md)
- */
-export declare const KF_BMODE_PROBS: Uint8Array<ArrayBuffer>;
-export declare const COEFF_UPDATE_PROBS: Uint8Array<ArrayBuffer>;
-export declare const DEFAULT_COEFF_PROBS: Uint8Array<ArrayBuffer>;
-export declare const DC_QLOOKUP: Uint8Array<ArrayBuffer>;
-export declare const AC_QLOOKUP: Int16Array<ArrayBuffer>;
-export declare const PCAT: Uint8Array<ArrayBuffer>[];

package/dist/codecs/vp8.d.ts

@@ -1,8 +0,0 @@
-/**
- * Decodes a VP8 key frame (the payload of a VP8 chunk) into RGBA
- */
-export declare function decode(data: Uint8Array): {
-    width: number;
-    height: number;
-    pixels: Uint8Array;
-};

package/dist/codecs/vp8l.d.ts

@@ -1,62 +0,0 @@
-/*!
- * WebP lossless (VP8L) bitstream, as specified in RFC 9649 ("WebP Image Format") section 3 onwards, including its
- * table of short distance codes. Copyright (c) 2024 IETF Trust and the persons identified as the document authors,
- * Revised BSD License (see THIRD_PARTY_NOTICES.md)
- */
-/** decoded VP8L image: ARGB pixels (0xAARRGGBB) */
-export interface VP8LImage {
-    width: number;
-    height: number;
-    argb: Uint32Array;
-    hasAlpha: boolean;
-}
-/**
- * LSB-first bit reader
- */
-export declare class BitReader {
-    data: Uint8Array;
-    pos: number;
-    private buffer;
-    private count;
-    constructor(data: Uint8Array, offset?: number);
-    private fill;
-    /** reads up to 24 bits */
-    read(bits: number): number;
-    /** the next 24 bits without consuming them */
-    peek(): number;
-    skip(bits: number): void;
-    /** whether reading went past the end of the data */
-    get overrun(): boolean;
-}
-/** canonical prefix code as lookup table */
-export interface PrefixCode {
-    table: Int32Array;
-    /** set if the code has a single symbol (which takes zero bits) */
-    single: number;
-}
-/**
- * Builds a lookup table from code lengths (RFC 9649 section 3.7.2.1.1: canonical codes, read LSB first)
- */
-export declare function buildCode(lengths: ArrayLike<number>, size: number): PrefixCode;
-/** reads one symbol */
-export declare function readSymbol(reader: BitReader, code: PrefixCode): number;
-/**
- * Reads the VP8L header (signature, dimensions)
- */
-export declare function readHeader(data: Uint8Array): {
-    width: number;
-    height: number;
-    hasAlpha: boolean;
-};
-/**
- * Decodes a VP8L bitstream (the payload of a VP8L chunk)
- */
-export declare function decode(data: Uint8Array): VP8LImage;
-/**
- * Decodes transforms and the main image from the bit reader (used by the ALPH chunk too, which has no header)
- */
-export declare function decodeStream(reader: BitReader, width: number, height: number): Uint32Array;
-/**
- * Encodes ARGB pixels into a VP8L bitstream (the payload of a VP8L chunk)
- */
-export declare function encode(argb: Uint32Array, width: number, height: number): Uint8Array;

package/dist/codecs/webp.d.ts

@@ -1,67 +0,0 @@
-export interface WebPFrame {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    /** milliseconds */
-    duration: number;
-    /** whether the frame is alpha blended onto the canvas (false: it replaces the covered area) */
-    blend: boolean;
-    /** whether the frame's area is cleared to transparent after it was shown */
-    dispose: boolean;
-    /** RGBA */
-    pixels: Uint8Array;
-}
-export interface WebPAnimation {
-    width: number;
-    height: number;
-    /** 0 = forever */
-    loopCount: number;
-    /** ARGB background color hint (decoders, like browsers, are free to ignore it) */
-    background: number;
-    frames: WebPFrame[];
-}
-/** Whether the WebP is animated */
-export declare function isAnimated(data: Uint8Array): boolean;
-/**
- * Decodes a still WebP into RGBA pixels. Animated WebPs decode to their first frame composited on the canvas
- */
-export declare function decode(data: Uint8Array): {
-    width: number;
-    height: number;
-    pixels: Uint8Array;
-    orientation: number;
-};
-/**
- * Decodes an animated WebP into its frames (not composited); still WebPs become a single frame
- */
-export declare function decodeAnimation(data: Uint8Array, onlyFirstFrame?: boolean): WebPAnimation;
-/**
- * Composites animation frames onto the canvas like browsers do (transparent background, the background color hint
- * is ignored as the spec allows)
- */
-export declare function composite({ width, height, frames }: WebPAnimation): Array<{
-    pixels: Uint8Array;
-    duration: number;
-}>;
-/**
- * Encodes RGBA pixels into a lossless WebP
- */
-export declare function encode(rgba: Uint8Array, width: number, height: number): Uint8Array;
-export interface WebPEncodeFrame {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    /** milliseconds */
-    duration: number;
-    /** whether the frame's area is cleared after it was shown */
-    dispose: boolean;
-    /** RGBA, alpha blended onto the canvas */
-    pixels: Uint8Array;
-}
-/**
- * Encodes frames into a lossless animated WebP. Frame offsets have to be even (the format stores them halved)
- * @param plays How often to play the animation, 0 = forever
- */
-export declare function encodeAnimation(frames: WebPEncodeFrame[], width: number, height: number, plays: number): Uint8Array;

package/dist/codecs/zlib.d.ts

@@ -1,22 +0,0 @@
-/*!
- * zlib deflate/inflate, derived from fflate (https://github.com/101arrowz/fflate)
- * Copyright (c) 2020 Arjun Barrett, MIT License (see THIRD_PARTY_NOTICES.md)
- */
-/**
- * Compresses data into a zlib stream
- * @param level compression level 0-9
- */
-export declare function compress(data: Uint8Array, level: number): Uint8Array;
-/**
- * Decompresses a zlib stream into at most limit bytes
- */
-export declare function decompress(data: Uint8Array, limit: number): Uint8Array;
-/**
- * Compresses data into a zlib stream, with the runtime's native zlib when available
- * @param level compression level 0-9
- */
-export declare function compressAsync(data: Uint8Array, level: number): Promise<Uint8Array>;
-/**
- * Decompresses a zlib stream into at most limit bytes, using the runtime's native zlib when available
- */
-export declare function decompressAsync(data: Uint8Array, limit: number): Promise<Uint8Array>;

package/dist/render/font.d.ts

@@ -1,92 +0,0 @@
-/**
- * A path command in font units (y up) or user units:
- * ['M', x, y], ['L', x, y], ['Q', cx, cy, x, y], ['C', c1x, c1y, c2x, c2y, x, y], ['Z']
- */
-export type PathCommand = [string, ...number[]];
-/** a TrueType glyph's points (font units) and instructions, for hinting */
-export interface GlyfPoints {
-    xs: number[];
-    ys: number[];
-    /** on curve flags */
-    on: boolean[];
-    /** index of the last point of every contour */
-    ends: number[];
-    instructions: Uint8Array;
-    /** glyph bounding box minimum x (the left side bearing's reference) */
-    xMin: number;
-    /** components of composite glyphs (their points are not included in xs/ys) */
-    components: Array<{
-        glyph: number;
-        dx: number;
-        dy: number;
-        matrix: [number, number, number, number];
-        round: boolean;
-        match: [number, number] | null;
-        useMetrics: boolean;
-    }> | null;
-}
-interface CFF {
-    charStrings: Uint8Array[];
-    globalSubrs: Uint8Array[];
-    privateFor: (glyph: number) => {
-        subrs: Uint8Array[];
-    };
-}
-/**
- * Parses TrueType (glyf) and OpenType (CFF) fonts, including the first font of a collection
- */
-export declare class Font {
-    data: Uint8Array;
-    view: DataView;
-    tables: Record<string, {
-        offset: number;
-        length: number;
-    }>;
-    unitsPerEm: number;
-    indexToLocFormat: number;
-    ascender: number;
-    descender: number;
-    lineGap: number;
-    numberOfHMetrics: number;
-    numGlyphs: number;
-    outlines: 'glyf' | 'cff';
-    cff: CFF | null;
-    cmap: (codepoint: number) => number;
-    outlineCache: Map<number, PathCommand[]>;
-    /** kerning between two glyphs in font units, null if the font has none */
-    kerning: ((left: number, right: number) => number) | null;
-    constructor(data: Uint8Array);
-    u8(o: number): number;
-    i8(o: number): number;
-    u16(o: number): number;
-    i16(o: number): number;
-    u32(o: number): number;
-    i32(o: number): number;
-    /**
-     * @param {number} codepoint
-     * @return {number} glyph index, 0 (.notdef) if the font has no glyph for it
-     */
-    glyphIndex(codepoint: number): number;
-    /**
-     * @param {number} glyph
-     * @return {number} advance width in font units
-     */
-    advance(glyph: number): number;
-    /** left side bearing in font units */
-    leftSideBearing(glyph: number): number;
-    /**
-     * A TrueType glyph's points and instructions (null for empty glyphs or CFF fonts)
-     */
-    glyfPoints(glyph: number): GlyfPoints | null;
-    /**
-     * @param {number} glyph
-     * @return {Array} path commands in font units
-     */
-    outline(glyph: number): PathCommand[];
-    glyfOutline(glyph: number, depth: number): PathCommand[];
-    simpleGlyph(offset: number, contourCount: number): PathCommand[];
-    compositeGlyph(offset: number, depth: number): PathCommand[];
-    cffOutline(glyph: number): PathCommand[];
-}
-export declare function contourToPath(path: PathCommand[], xs: ArrayLike<number>, ys: ArrayLike<number>, flags: ArrayLike<number | boolean>, first: number, last: number): void;
-export {};

package/dist/render/hinting.d.ts

@@ -1,110 +0,0 @@
-/*!
- * TrueType hinting interpreter. Where the TrueType specification leaves details open, its behavior and parts of its
- * logic follow FreeType's TrueType interpreter (src/truetype/ttinterp.c): fixed point rounding, original distances
- * on the unscaled outline (IP, IUP, MDRP, MD), the IUP interpolation, the movement along near-perpendicular vectors
- * and the tolerance of invalid references. Portions of this software are copyright © 2026 The FreeType Project
- * (https://freetype.org). All rights reserved. FreeType License, see THIRD_PARTY_NOTICES.md and licenses/FTL.txt
- */
-import { Font, PathCommand } from './font.js';
-interface Vector {
-    x: number;
-    y: number;
-}
-interface GraphicsState {
-    pv: Vector;
-    fv: Vector;
-    dv: Vector;
-    rp0: number;
-    rp1: number;
-    rp2: number;
-    zp0: number;
-    zp1: number;
-    zp2: number;
-    loop: number;
-    minimumDistance: number;
-    cvtCutIn: number;
-    singleWidthCutIn: number;
-    singleWidth: number;
-    deltaBase: number;
-    deltaShift: number;
-    autoFlip: boolean;
-    /** null: rounding off */
-    round: {
-        period: number;
-        phase: number;
-        threshold: number;
-    } | null;
-    instructControl: number;
-}
-interface Zone {
-    curX: Float64Array;
-    curY: Float64Array;
-    orgX: Float64Array;
-    orgY: Float64Array;
-    /** unscaled original positions (font units), measurements between original glyph points use them */
-    orusX: Float64Array;
-    orusY: Float64Array;
-    touchX: Uint8Array;
-    touchY: Uint8Array;
-    on: Uint8Array;
-    ends: number[];
-}
-interface FunctionDef {
-    code: Uint8Array;
-    start: number;
-    end: number;
-}
-/** state of a font at one size, after the font and control value programs ran */
-interface SizeState {
-    ppem: number;
-    /** 26.6 units per font unit */
-    scale: number;
-    /** the same as 16.16 fixed point number */
-    scaleFixed: number;
-    cvt: Float64Array;
-    storage: Int32Array;
-    state: GraphicsState;
-    twilight: Zone;
-    functions: Map<number, FunctionDef>;
-    instructions: Map<number, FunctionDef>;
-    /** set if the font and control value programs failed, the font is then rendered unhinted */
-    broken: boolean;
-}
-export interface HintedGlyph {
-    /** outline in pixels, relative to the pen position (y up) */
-    path: PathCommand[];
-    /** advance width in whole pixels */
-    advance: number;
-}
-/**
- * Executes TrueType instructions for one font
- */
-export declare class Hinter {
-    font: Font;
-    fpgm: Uint8Array;
-    prep: Uint8Array;
-    cvt: Int16Array;
-    maxStack: number;
-    maxStorage: number;
-    maxTwilight: number;
-    sizes: Map<number, SizeState>;
-    /** 26.6 units per font unit (16.16 fixed point) of the glyph being loaded */
-    private scaleFixed;
-    constructor(font: Font);
-    /** whether the font has hinting instructions (a font program, control value program or control values) */
-    get hasInstructions(): boolean;
-    private size;
-    /**
-     * Hints a glyph at a size
-     * @param size pixels per em
-     * @return the hinted outline, or null if the glyph can't be hinted (it is then rendered unhinted)
-     */
-    glyph(glyph: number, size: number): HintedGlyph | null;
-    /**
-     * Loads, scales and hints a glyph (recursively for composites)
-     * @return the glyph zone (with 4 phantom points after the outline points)
-     */
-    private load;
-    private phantoms;
-}
-export {};

package/dist/render/svg.d.ts

@@ -1,11 +0,0 @@
-/**
- * @param {string|Uint8Array} source
- * @param {number} mode 1 = scale by size, 2 = fit width to size, 3 = fit height to size
- * @param {number} size
- * @return {{width: number, height: number, pixels: Uint8Array}}
- */
-export declare function render(source: string | Uint8Array, mode: number, size: number): {
-    width: number;
-    height: number;
-    pixels: Uint8Array;
-};

package/dist/render/text.d.ts

@@ -1,63 +0,0 @@
-/*!
- * The Rasterizer class is translated from font-rs (https://github.com/raphlinus/font-rs)
- * Copyright 2015 Google Inc., Apache License 2.0 (see THIRD_PARTY_NOTICES.md and licenses/Apache-2.0.txt)
- */
-import { PathCommand } from './font.js';
-export interface Layout {
-    maxWidth: number;
-    maxHeight: number;
-    wrapStyle: 'word' | 'char';
-    horizontalAlign: 'left' | 'center' | 'right';
-    verticalAlign: 'top' | 'middle' | 'bottom';
-    wrapHardBreaks: boolean;
-}
-export interface GlyphBitmap {
-    data: Uint8Array;
-    width: number;
-    height: number;
-    /** offset from the pen position */
-    left: number;
-    /** offset above the baseline */
-    top: number;
-}
-/**
- * Lays out and rasterizes text
- * Lines start at ceil(ascender) and advance by ceil(ascender - descender + lineGap); glyphs are placed with
- * subpixel precision using their advance widths and the font's kerning; the canvas spans from the origin to the
- * furthest glyph edge
- * @param {Uint8Array} data TrueType/OpenType font
- * @param {number} size font size in pixels per em
- * @param {string} text
- * @param {Layout} layout
- * @param hinting Whether to run TrueType fonts' hinting instructions, the glyphs of hinted fonts are then placed on
- *     whole pixels (fonts without instructions render as without hinting)
- * @return {{width: number, height: number, coverage: Uint8Array}}
- */
-export declare function render(data: Uint8Array, size: number, text: string, layout: Layout, hinting?: boolean): {
-    width: number;
-    height: number;
-    coverage: Uint8Array;
-};
-/**
- * Rasterizes a glyph outline into an 8-bit coverage bitmap
- * @param {Array} path outline in font units (y up)
- * @param {number} scale pixels per font unit
- * @param {number} [offset=0] horizontal subpixel offset
- * @return {{data: Uint8Array, width: number, height: number, left: number, top: number}|null}
- *     left/top position the bitmap relative to the pen position on the baseline (top is measured upwards)
- */
-export declare function rasterizeGlyph(path: PathCommand[], scale: number, offset?: number): GlyphBitmap | null;
-/**
- * Signed area coverage rasterizer: every line segment adds its area to an accumulation buffer,
- * a prefix sum over each row yields the coverage
- */
-export declare class Rasterizer {
-    width: number;
-    height: number;
-    accumulation: Float32Array;
-    constructor(width: number, height: number);
-    line(x0: number, y0: number, x1: number, y1: number): void;
-    quad(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number): void;
-    cubic(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): void;
-    coverage(): Uint8Array;
-}

package/dist/util/blur.d.ts

@@ -1,13 +0,0 @@
-/**
- * Blurs premultiplied RGBA float pixels in place
- * @param sigma standard deviation of the gaussian in pixels
- */
-export declare function gaussianBlur(pixels: Float32Array, width: number, height: number, sigma: number): void;
-/**
- * Converts 8-bit RGBA to premultiplied floats
- */
-export declare function premultiply(rgba: Uint8ClampedArray): Float32Array;
-/**
- * Converts premultiplied floats back to 8-bit RGBA (the clamped output rounds)
- */
-export declare function unpremultiply(pixels: Float32Array, out: Uint8ClampedArray): void;

package/dist/util/resample.d.ts

@@ -1,12 +0,0 @@
-export interface Filter {
-    /** radius of the filter at scale 1 */
-    support: number;
-    weight: (x: number) => number;
-}
-export declare const BOX: Filter;
-export declare const TRIANGLE: Filter;
-export declare const CUBIC: Filter;
-/**
- * Resamples RGBA pixels with the given filter, in premultiplied alpha so transparent pixels don't bleed their color
- */
-export declare function resample(src: Uint8ClampedArray, width: number, height: number, outWidth: number, outHeight: number, filter: Filter, out: Uint8ClampedArray): void;

package/dist/util/utf8.d.ts

@@ -1,5 +0,0 @@
-export declare function encode(text: string): Uint8Array;
-/**
- * Decodes UTF-8, replacing invalid sequences with U+FFFD and skipping a leading byte order mark
- */
-export declare function decode(bytes: Uint8Array): string;

package/dist/version.d.ts

@@ -1 +0,0 @@
-export declare const VERSION = "3.1.0";