imagescript 3.1.0 → 3.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "imagescript",
-  "version": "3.1.0",
+  "version": "3.2.1",
   "description": "zero-dependency javascript image manipulation",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -47,7 +47,14 @@
     "bitmap",
     "gif",
     "picture",
-    "thumbnail"
+    "thumbnail",
+    "webp",
+    "apng",
+    "tiff",
+    "tga",
+    "animation",
+    "text rendering",
+    "font"
   ],
   "author": "Mathis Mensing <mathis@matmen.dev>",
   "license": "(AGPL-3.0-or-later OR MIT)",

package/dist/codecs/crc.d.ts

@@ -1,9 +0,0 @@
-/*!
- * Slice-by-16 CRC-32, derived from "Fast CRC32 in JavaScript" (https://gist.github.com/101arrowz/e58695f7ccfdf74f60ba22018093edea)
- * Copyright (c) 2021 Arjun Barrett, MIT License (see THIRD_PARTY_NOTICES.md)
- */
-/**
- * CRC-32 (ISO 3309), as used by PNG and zlib. Processes 16 bytes per step (slice-by-16, see #12), byte by byte so
- * it doesn't depend on alignment or endianness
- */
-export declare function crc32(buffer: Uint8Array): number;

package/dist/codecs/exif.d.ts

@@ -1,11 +0,0 @@
-/**
- * Reads the orientation tag (0x0112) from the first IFD of Exif data
- * @param data a TIFF header and IFDs, optionally preceded by "Exif\0\0" (as in JPEG's APP1)
- * @return the orientation (1-8), 1 if it is missing or invalid
- */
-export declare function orientation(data: Uint8Array): number;
-/**
- * Reads tiff:Orientation from an XMP packet, as attribute or element
- * @return the orientation (1-8), 1 if it is missing or invalid
- */
-export declare function xmpOrientation(xmp: string): number;

package/dist/codecs/gif.d.ts

@@ -1,44 +0,0 @@
-export interface GIFFrame {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    /** Frame delay in centiseconds */
-    delay: number;
-    /** ImageScript disposal mode (0 any, 1 keep, 2 previous, 3 background) */
-    dispose: number;
-    /** RGBA pixel data */
-    pixels: Uint8Array;
-}
-export interface GIFData {
-    width: number;
-    height: number;
-    /** -1 loops forever, 0 plays once, n repeats n times */
-    loopCount: number;
-    frames: GIFFrame[];
-}
-/**
- * Encodes frames into a GIF
- * @param {{width: number, height: number, loopCount?: number, frames: GIFFrame[]}} gif loopCount -1 loops forever, 0 plays once, n repeats n times
- * @param {number} [quality=95] 1-100, scales the palette size (1 = 8 colors, 50 = 55, 90 and above = 256)
- * @return {Uint8Array}
- */
-export declare function encode({ width, height, loopCount, frames }: Omit<GIFData, 'loopCount'> & {
-    loopCount?: number;
-}, quality?: number): Uint8Array;
-/**
- * Decodes a GIF into its individual (uncomposited) frames, zero-sized images are skipped
- * @param {Uint8Array} data
- * @param {boolean} [onlyFirstFrame=false]
- * @return {{width: number, height: number, loopCount: number, frames: GIFFrame[]}}
- */
-export declare function decode(data: Uint8Array, onlyFirstFrame?: boolean): GIFData;
-/**
- * Composites decoded frames onto the logical screen, applying their disposal modes
- * @param {{width: number, height: number, frames: GIFFrame[]}} gif output of {@link decode}
- * @return {Array<{pixels: Uint8Array, delay: number}>} full screen RGBA frames
- */
-export declare function composite({ width, height, frames }: GIFData): Array<{
-    pixels: Uint8Array;
-    delay: number;
-}>;

package/dist/codecs/jpeg.d.ts

@@ -1,35 +0,0 @@
-/*!
- * JPEG codec. This software is based in part on the work of the Independent JPEG Group: the IDCT, FDCT, upsampling,
- * color conversion, progressive refinement and optimal Huffman tables are translated from libjpeg/libjpeg-turbo
- * (IJG license, see licenses/README.ijg). The scan decoder follows the structure of pdf.js' jpg.js
- * (Copyright 2014 Mozilla Foundation, Apache License 2.0). See THIRD_PARTY_NOTICES.md
- */
-export interface DecodeOptions {
-    /** overrides the color transform detected from JFIF/Adobe markers (used by TIFF) */
-    transform?: 'ycc' | 'rgb' | 'cmyk' | null;
-}
-/**
- * Decodes a JPEG into 8-bit RGBA pixel data
- * Supports baseline, extended and progressive huffman coded JPEGs with any
- * sampling factors, restart intervals and greyscale, YCbCr, RGB, CMYK and YCCK color
- * The output matches libjpeg's defaults (islow IDCT, fancy upsampling)
- * @param {Uint8Array} data
- * @param {{transform?: 'ycc'|'rgb'|'cmyk'}} [options] overrides the color transform detected from JFIF/Adobe markers (used by TIFF)
- * @return {{width: number, height: number, pixels: Uint8Array}}
- */
-export declare function decode(data: Uint8Array, { transform }?: DecodeOptions): {
-    width: number;
-    height: number;
-    pixels: Uint8Array;
-    orientation: number;
-};
-/**
- * Encodes RGBA pixel data into a baseline JPEG (alpha is ignored)
- * Uses 4:2:0 chroma subsampling up to quality 90 and 4:4:4 above, with optimized huffman tables
- * @param {Uint8Array} pixels
- * @param {number} width
- * @param {number} height
- * @param {number} [quality=90] 1-100
- * @return {Uint8Array}
- */
-export declare function encode(pixels: Uint8Array, width: number, height: number, quality?: number): Uint8Array;

package/dist/codecs/png.d.ts

@@ -1,97 +0,0 @@
-export interface EncodeOptions {
-    /** tEXt chunks, empty values are skipped */
-    text?: Record<string, string | undefined>;
-    width: number;
-    height: number;
-    channels: number;
-    depth?: number;
-    level?: number;
-    /** packed RGB palette, makes the data palette indices (1 channel) */
-    palette?: Uint8Array;
-    /** alpha per palette entry */
-    transparency?: Uint8Array;
-    /** whether to paeth filter the rows (pays off for truecolor and greyscale images) */
-    filter?: boolean;
-}
-export interface Decoded {
-    width: number;
-    height: number;
-    /** 8-bit RGBA */
-    pixels: Uint8Array;
-    /** Exif orientation (1-8) */
-    orientation: number;
-}
-/**
- * Encodes raw pixel data into a PNG
- * @param data Raw pixel data, rows packed MSB first for depths below 8
- */
-export declare function encode(data: Uint8Array, { text, width, height, channels, depth, level, palette, transparency, filter: filterRows }: EncodeOptions): Promise<Uint8Array>;
-/**
- * Encodes 8-bit RGBA pixels into a PNG with the smallest lossless color type (see {@link pixelFormat}).
- * Rows of non-palette images are paeth filtered (unless the data isn't compressed), palette indices aren't
- * filtered (like libpng recommends)
- */
-export declare function encodeRGBA(rgba: Uint8Array, width: number, height: number, level: number, text?: EncodeOptions['text']): Promise<Uint8Array>;
-export interface APNGEncodeFrame {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    /** milliseconds (stored as a fraction of up to 65535/65535 seconds) */
-    duration: number;
-    /** 0 none, 1 background (transparent), 2 previous */
-    dispose: number;
-    /** RGBA */
-    pixels: Uint8Array;
-}
-/**
- * Encodes frames into an APNG. Frames are alpha blended onto the canvas ("over"); the first frame is also the
- * default image that viewers without APNG support show
- * @param plays How often to play the animation, 0 = forever
- */
-export declare function encodeAnimation(frames: APNGEncodeFrame[], width: number, height: number, plays: number, level: number): Promise<Uint8Array>;
-/**
- * Decodes a PNG into 8-bit RGBA pixel data (for APNGs, the default image)
- * Supports all color types, bit depths, tRNS transparency and adam7 interlacing
- * The orientation comes from the eXIf chunk, or, if there is none, from the Exif text ImageMagick wrote before eXIf
- * existed ("Raw profile type exif") or from the XMP packet
- */
-export declare function decode(array: Uint8Array): Promise<Decoded>;
-export interface APNGFrame {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    /** milliseconds */
-    duration: number;
-    /** 0 none, 1 background (transparent), 2 previous */
-    dispose: number;
-    /** 0 source (replace), 1 over */
-    blend: number;
-    pixels: Uint8Array;
-}
-/** Whether the PNG is an APNG (has an acTL chunk) */
-export declare function isAnimated(array: Uint8Array): boolean;
-/**
- * Decodes an APNG (https://wiki.mozilla.org/APNG_Specification) into its (uncomposited) frames; a plain PNG becomes
- * a single frame
- * @return plays: 0 = forever
- */
-export declare function decodeAnimation(array: Uint8Array, onlyFirstFrame?: boolean): Promise<{
-    width: number;
-    height: number;
-    plays: number;
-    frames: APNGFrame[];
-}>;
-/**
- * Composites APNG frames onto the canvas, as the APNG specification describes (the integer "over" operation of its
- * blend_op section, https://wiki.mozilla.org/APNG_Specification)
- */
-export declare function compositeAnimation({ width, height, frames }: {
-    width: number;
-    height: number;
-    frames: APNGFrame[];
-}): Array<{
-    pixels: Uint8Array;
-    duration: number;
-}>;

package/dist/codecs/quantize.d.ts

@@ -1,25 +0,0 @@
-/**
- * Reduces RGBA pixel data to an indexed palette
- * Pixels with alpha < 128 are mapped to a dedicated transparent index
- * @param {Uint8Array} pixels RGBA pixel data
- * @param {number} width Image width in pixels (needed for dithering)
- * @param {{maxColors?: number, quality?: number}} [options] quality (1-100) scales the palette size exponentially (1 = 8 colors, 50 = 55, 90 and above = 256)
- * @return {{palette: Uint8Array, indices: Uint8Array, transparentIndex: number}} palette is packed RGB, transparentIndex is -1 if unused
- */
-export interface QuantizeOptions {
-    maxColors?: number;
-    quality?: number;
-}
-export interface Quantized {
-    /** packed RGB */
-    palette: Uint8Array;
-    indices: Uint8Array;
-    /** -1 if no pixel is transparent */
-    transparentIndex: number;
-}
-/**
- * Finds the color of the largest cluster among the opaque pixels that pass the filter
- * @return packed RGB, or null if no pixel qualifies
- */
-export declare function dominantColor(pixels: Uint8Array, include: (r: number, g: number, b: number) => boolean, clusters?: number): [number, number, number] | null;
-export declare function quantize(pixels: Uint8Array, width: number, { maxColors, quality }?: QuantizeOptions): Quantized;

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;
-};