imagescript 3.0.0 → 3.2.0

package/licenses/FTL.txt

@@ -0,0 +1,169 @@
+                    The FreeType Project LICENSE
+                    ----------------------------
+
+                            2006-Jan-27
+
+                    Copyright 1996-2002, 2006 by
+          David Turner, Robert Wilhelm, and Werner Lemberg
+
+
+
+Introduction
+============
+
+  The FreeType  Project is distributed in  several archive packages;
+  some of them may contain, in addition to the FreeType font engine,
+  various tools and  contributions which rely on, or  relate to, the
+  FreeType Project.
+
+  This  license applies  to all  files found  in such  packages, and
+  which do not  fall under their own explicit  license.  The license
+  affects  thus  the  FreeType   font  engine,  the  test  programs,
+  documentation and makefiles, at the very least.
+
+  This  license   was  inspired  by  the  BSD,   Artistic,  and  IJG
+  (Independent JPEG  Group) licenses, which  all encourage inclusion
+  and  use of  free  software in  commercial  and freeware  products
+  alike.  As a consequence, its main points are that:
+
+    o We don't promise that this software works. However, we will be
+      interested in any kind of bug reports. (`as is' distribution)
+
+    o You can  use this software for whatever you  want, in parts or
+      full form, without having to pay us. (`royalty-free' usage)
+
+    o You may not pretend that  you wrote this software.  If you use
+      it, or  only parts of it,  in a program,  you must acknowledge
+      somewhere  in  your  documentation  that  you  have  used  the
+      FreeType code. (`credits')
+
+  We  specifically  permit  and  encourage  the  inclusion  of  this
+  software, with  or without modifications,  in commercial products.
+  We  disclaim  all warranties  covering  The  FreeType Project  and
+  assume no liability related to The FreeType Project.
+
+
+  Finally,  many  people  asked  us  for  a  preferred  form  for  a
+  credit/disclaimer to use in compliance with this license.  We thus
+  encourage you to use the following text:
+
+   """
+    Portions of this software are copyright © <year> The FreeType
+    Project (https://freetype.org).  All rights reserved.
+   """
+
+  Please replace <year> with the value from the FreeType version you
+  actually use.
+
+
+Legal Terms
+===========
+
+0. Definitions
+--------------
+
+  Throughout this license,  the terms `package', `FreeType Project',
+  and  `FreeType  archive' refer  to  the  set  of files  originally
+  distributed  by the  authors  (David Turner,  Robert Wilhelm,  and
+  Werner Lemberg) as the `FreeType Project', be they named as alpha,
+  beta or final release.
+
+  `You' refers to  the licensee, or person using  the project, where
+  `using' is a generic term including compiling the project's source
+  code as  well as linking it  to form a  `program' or `executable'.
+  This  program is  referred to  as  `a program  using the  FreeType
+  engine'.
+
+  This  license applies  to all  files distributed  in  the original
+  FreeType  Project,   including  all  source   code,  binaries  and
+  documentation,  unless  otherwise  stated   in  the  file  in  its
+  original, unmodified form as  distributed in the original archive.
+  If you are  unsure whether or not a particular  file is covered by
+  this license, you must contact us to verify this.
+
+  The FreeType  Project is copyright (C) 1996-2000  by David Turner,
+  Robert Wilhelm, and Werner Lemberg.  All rights reserved except as
+  specified below.
+
+1. No Warranty
+--------------
+
+  THE FREETYPE PROJECT  IS PROVIDED `AS IS' WITHOUT  WARRANTY OF ANY
+  KIND, EITHER  EXPRESS OR IMPLIED,  INCLUDING, BUT NOT  LIMITED TO,
+  WARRANTIES  OF  MERCHANTABILITY   AND  FITNESS  FOR  A  PARTICULAR
+  PURPOSE.  IN NO EVENT WILL ANY OF THE AUTHORS OR COPYRIGHT HOLDERS
+  BE LIABLE  FOR ANY DAMAGES CAUSED  BY THE USE OR  THE INABILITY TO
+  USE, OF THE FREETYPE PROJECT.
+
+2. Redistribution
+-----------------
+
+  This  license  grants  a  worldwide, royalty-free,  perpetual  and
+  irrevocable right  and license to use,  execute, perform, compile,
+  display,  copy,   create  derivative  works   of,  distribute  and
+  sublicense the  FreeType Project (in  both source and  object code
+  forms)  and  derivative works  thereof  for  any  purpose; and  to
+  authorize others  to exercise  some or all  of the  rights granted
+  herein, subject to the following conditions:
+
+    o Redistribution of  source code  must retain this  license file
+      (`FTL.TXT') unaltered; any  additions, deletions or changes to
+      the original  files must be clearly  indicated in accompanying
+      documentation.   The  copyright   notices  of  the  unaltered,
+      original  files must  be  preserved in  all  copies of  source
+      files.
+
+    o Redistribution in binary form must provide a  disclaimer  that
+      states  that  the software is based in part of the work of the
+      FreeType Team,  in  the  distribution  documentation.  We also
+      encourage you to put an URL to the FreeType web page  in  your
+      documentation, though this isn't mandatory.
+
+  These conditions  apply to any  software derived from or  based on
+  the FreeType Project,  not just the unmodified files.   If you use
+  our work, you  must acknowledge us.  However, no  fee need be paid
+  to us.
+
+3. Advertising
+--------------
+
+  Neither the  FreeType authors and  contributors nor you  shall use
+  the name of the  other for commercial, advertising, or promotional
+  purposes without specific prior written permission.
+
+  We suggest,  but do not require, that  you use one or  more of the
+  following phrases to refer  to this software in your documentation
+  or advertising  materials: `FreeType Project',  `FreeType Engine',
+  `FreeType library', or `FreeType Distribution'.
+
+  As  you have  not signed  this license,  you are  not  required to
+  accept  it.   However,  as  the FreeType  Project  is  copyrighted
+  material, only  this license, or  another one contracted  with the
+  authors, grants you  the right to use, distribute,  and modify it.
+  Therefore,  by  using,  distributing,  or modifying  the  FreeType
+  Project, you indicate that you understand and accept all the terms
+  of this license.
+
+4. Contacts
+-----------
+
+  There are two mailing lists related to FreeType:
+
+    o freetype@nongnu.org
+
+      Discusses general use and applications of FreeType, as well as
+      future and  wanted additions to the  library and distribution.
+      If  you are looking  for support,  start in  this list  if you
+      haven't found anything to help you in the documentation.
+
+    o freetype-devel@nongnu.org
+
+      Discusses bugs,  as well  as engine internals,  design issues,
+      specific licenses, porting, etc.
+
+  Our home page can be found at
+
+    https://freetype.org
+
+
+--- end of FTL.TXT ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "imagescript",
-  "version": "3.0.0",
+  "version": "3.2.0",
   "description": "zero-dependency javascript image manipulation",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -27,7 +27,7 @@
     "docs": "node scripts/docs.js",
     "test": "npm run build && node ./tests/run.js",
     "prepack": "npm run build",
-    "version": "node scripts/build.js && git add src/version.ts jsr.json"
+    "version": "node scripts/version.js && git add src/version.ts jsr.json"
   },
   "repository": {
     "type": "git",
@@ -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,44 +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:
- * a palette for up to 256 colors, otherwise greyscale or RGB, with alpha only if a pixel isn't opaque.
- * 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>;
-/**
- * Decodes a PNG into 8-bit RGBA pixel data
- * 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
- * @param {Uint8Array} array The PNG data
- * @return {{width: number, height: number, pixels: Uint8Array, orientation: number}}
- */
-export declare function decode(array: Uint8Array): Promise<Decoded>;

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/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/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,63 +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[]];
-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;
-    /**
-     * @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 {};

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,61 +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
- * @return {{width: number, height: number, coverage: Uint8Array}}
- */
-export declare function render(data: Uint8Array, size: number, text: string, layout: Layout): {
-    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.0.0";