imagescript 1.3.1 → 3.1.0

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+import { BinaryData } from './util/mem.js';
+import { Image } from './image.js';
+import { GIF } from './gif.js';
+import { Animation } from './animation.js';
+export { Image } from './image.js';
+export type { Color, ColorFunction, ResizeMode, SVGScaleMode, PNGMetadata, TextStyle, DecodeOptions, CompositeOptions, BlendMode, CropCircleOptions, DominantColorOptions, RotateOptions, ColorToAlphaOptions } from './image.js';
+export { Frame } from './frame.js';
+export type { FrameDisposalModeName, FrameDisposalModeId } from './frame.js';
+export { GIF } from './gif.js';
+export { Animation } 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 { BinaryData } from './util/mem.js';
+/**
+ * Decodes any supported image: GIFs are returned as {@link GIF} (an {@link Animation}), animated WebPs as
+ * {@link Animation}, everything else (including APNGs, as their default image) as {@link Image}.
+ * {@link Animation.decode} decodes the frames of GIFs, APNGs and WebPs
+ * @param data The image data
+ * @param onlyExtractFirstFrame Whether to end animation decoding after the first frame
+ */
+export declare function decode(data: BinaryData, onlyExtractFirstFrame?: boolean): Promise<GIF | Animation | Image>;

package/dist/index.js

@@ -0,0 +1,20 @@
+import { Image } from "./image.js";
+import { GIF } from "./gif.js";
+import { Animation } from "./animation.js";
+import * as webp from "./codecs/webp.js";
+import { view } from "./util/mem.js";
+import { ImageType } from "./image-type.js";
+export { Image } from "./image.js";
+export { Frame } from "./frame.js";
+export { GIF } from "./gif.js";
+export { Animation } from "./animation.js";
+export { TextLayout } from "./text-layout.js";
+export { ImageType } from "./image-type.js";
+export function decode(data, onlyExtractFirstFrame = false) {
+    const type = ImageType.getType(data);
+    if (type === 'gif')
+        return GIF.decode(data, onlyExtractFirstFrame);
+    if (type === 'webp' && webp.isAnimated(view(data)))
+        return Animation.decode(data, onlyExtractFirstFrame);
+    return Image.decode(data);
+}

package/dist/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/dist/render/font.d.ts

@@ -0,0 +1,92 @@
+/**
+ * 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 {};