imagescript 1.3.1 → 3.1.0

package/dist/frame.js

@@ -0,0 +1,65 @@
+import { Image } from "./image.js";
+const DISPOSAL_MODES = ['any', 'keep', 'previous', 'background'];
+export class Frame extends Image {
+    duration;
+    xOffset;
+    yOffset;
+    __disposalMode__ = 1;
+    static get DISPOSAL_ANY() {
+        return 'any';
+    }
+    static get DISPOSAL_KEEP() {
+        return 'keep';
+    }
+    static get DISPOSAL_PREVIOUS() {
+        return 'previous';
+    }
+    static get DISPOSAL_BACKGROUND() {
+        return 'background';
+    }
+    static __convert_disposal_mode__(mode) {
+        const id = typeof mode === 'string' ? DISPOSAL_MODES.indexOf(mode) : mode;
+        if (!(id >= 0 && id <= 3))
+            throw new RangeError('Invalid disposal mode');
+        return id;
+    }
+    constructor(width, height, duration = 100, xOffset = 0, yOffset = 0, disposalMode = Frame.DISPOSAL_KEEP) {
+        if (isNaN(duration) || duration < 0)
+            throw new RangeError('Invalid frame duration');
+        super(width, height);
+        this.duration = duration;
+        this.xOffset = xOffset;
+        this.yOffset = yOffset;
+        this.disposalMode = disposalMode;
+    }
+    get disposalMode() {
+        return DISPOSAL_MODES[this.__disposalMode__];
+    }
+    get __disposal_id__() {
+        return this.__disposalMode__;
+    }
+    set disposalMode(disposalMode) {
+        this.__disposalMode__ = Frame.__convert_disposal_mode__(disposalMode);
+    }
+    toString() {
+        return `Frame<${this.width}x${this.height}x${this.duration}ms>`;
+    }
+    static from(image, duration, xOffset, yOffset, disposalMode = Frame.DISPOSAL_KEEP) {
+        if (!(image instanceof Image))
+            throw new TypeError('Invalid image passed');
+        const frame = new Frame(image.width, image.height, duration, xOffset, yOffset, disposalMode);
+        frame.bitmap.set(image.bitmap);
+        return frame;
+    }
+    clone() {
+        return Frame.from(this, this.duration, this.xOffset, this.yOffset, this.disposalMode);
+    }
+    resize(width, height, mode = Image.RESIZE_BILINEAR) {
+        const originalWidth = this.width;
+        const originalHeight = this.height;
+        super.resize(width, height, mode);
+        this.xOffset = Math.round(this.xOffset * this.width / originalWidth);
+        this.yOffset = Math.round(this.yOffset * this.height / originalHeight);
+        return this;
+    }
+}

package/dist/gif.d.ts

@@ -0,0 +1,31 @@
+import { BinaryData } from './util/mem.js';
+import { Frame } from './frame.js';
+import { Animation } from './animation.js';
+/**
+ * Represents a GIF image as an array of frames, an {@link Animation} whose `encode()` and `decode()` work with GIFs.
+ * Array methods like map and filter return plain arrays.
+ * @deprecated Use {@link Animation}, which works the same and also handles APNG: `new Animation(frames, loopCount)`,
+ *     {@link Animation.decode} and {@link Animation.encodeGIF}. `GIF` will be removed in 4.0
+ */
+export declare class GIF extends Animation {
+    /**
+     * Creates a new GIF image
+     * @param frames The frames to create the GIF from
+     * @param loopCount How many times to repeat the GIF (-1 = forever, 0 = play once)
+     */
+    constructor(frames: Frame[], loopCount?: number);
+    toString(): string;
+    /**
+     * Encodes the GIF
+     * @param quality 1-100, scales the palette size from 8 colors (1) to 256 colors (90 and above)
+     * @deprecated Use {@link Animation.encodeGIF}
+     */
+    encode(quality?: number): Promise<Uint8Array>;
+    /**
+     * Decodes a GIF into fully composited frames
+     * @param input The binary data to decode
+     * @param onlyExtractFirstFrame Whether to end GIF decoding after the first frame
+     * @deprecated Use {@link Animation.decode}, which decodes APNGs too
+     */
+    static decode(input: BinaryData, onlyExtractFirstFrame?: boolean): Promise<GIF>;
+}

package/dist/gif.js

@@ -0,0 +1,20 @@
+import { view } from "./util/mem.js";
+import { ImageType } from "./image-type.js";
+import { Animation } from "./animation.js";
+export class GIF extends Animation {
+    constructor(frames, loopCount = -1) {
+        super(frames, loopCount);
+    }
+    toString() {
+        return `GIF<${this.width}x${this.height}x${this.duration}ms>`;
+    }
+    async encode(quality = 95) {
+        return this.encodeGIF(quality);
+    }
+    static async decode(input, onlyExtractFirstFrame = false) {
+        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);
+    }
+}

package/dist/image-type.d.ts

@@ -0,0 +1,24 @@
+import { BinaryData } from './util/mem.js';
+/** Image formats recognized by {@link ImageType.getType} */
+export type ImageTypeName = 'png' | 'jpeg' | 'tiff' | 'gif' | 'webp' | 'tga';
+/** Detects image formats by their magic numbers */
+export declare class ImageType {
+    /**
+     * Gets an image's type from its magic number
+     * @param data The image binary to get the type of
+     * @returns The image type, or null if it isn't supported
+     */
+    static getType(data: BinaryData): ImageTypeName | null;
+    /** Whether the data starts like a PNG */
+    static isPNG(data: BinaryData): boolean;
+    /** Whether the data starts like a JPEG */
+    static isJPEG(data: BinaryData): boolean;
+    /** Whether the data starts like a TIFF (or BigTIFF) */
+    static isTIFF(data: BinaryData): boolean;
+    /** Whether the data starts like a GIF */
+    static isGIF(data: BinaryData): boolean;
+    /** Whether the data starts like a WebP */
+    static isWebP(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

@@ -0,0 +1,64 @@
+import { view as bytes } from "./util/mem.js";
+import { isTGA } from "./codecs/tga.js";
+const MAGIC_NUMBERS = {
+    PNG: 0x89504e47,
+    JPEG: 0xffd8ff,
+    TIFF_LE: 0x49492a00,
+    TIFF_BE: 0x4d4d002a,
+    BIGTIFF_LE: 0x49492b00,
+    BIGTIFF_BE: 0x4d4d002b,
+    GIF: 0x474946,
+    RIFF: 0x52494646,
+    WEBP: 0x57454250
+};
+function dataView(data) {
+    if (data instanceof DataView)
+        return data;
+    const u8 = bytes(data);
+    return new DataView(u8.buffer, u8.byteOffset, u8.byteLength);
+}
+export class ImageType {
+    static getType(data) {
+        const view = dataView(data);
+        if (this.isPNG(view))
+            return 'png';
+        if (this.isJPEG(view))
+            return 'jpeg';
+        if (this.isTIFF(view))
+            return 'tiff';
+        if (this.isGIF(view))
+            return 'gif';
+        if (this.isWebP(view))
+            return 'webp';
+        if (this.isTGA(view))
+            return 'tga';
+        return null;
+    }
+    static isPNG(data) {
+        const view = dataView(data);
+        return view.byteLength >= 4 && view.getUint32(0, false) === MAGIC_NUMBERS.PNG;
+    }
+    static isJPEG(data) {
+        const view = dataView(data);
+        return view.byteLength >= 4 && (view.getUint32(0, false) >>> 8) === MAGIC_NUMBERS.JPEG;
+    }
+    static isTIFF(data) {
+        const view = dataView(data);
+        if (view.byteLength < 4)
+            return false;
+        const magic = view.getUint32(0, false);
+        return magic === MAGIC_NUMBERS.TIFF_LE || magic === MAGIC_NUMBERS.TIFF_BE || magic === MAGIC_NUMBERS.BIGTIFF_LE || magic === MAGIC_NUMBERS.BIGTIFF_BE;
+    }
+    static isGIF(data) {
+        const view = dataView(data);
+        return view.byteLength >= 4 && (view.getUint32(0, false) >>> 8) === MAGIC_NUMBERS.GIF;
+    }
+    static isWebP(data) {
+        const view = dataView(data);
+        return view.byteLength >= 12 && view.getUint32(0, false) === MAGIC_NUMBERS.RIFF && view.getUint32(8, false) === MAGIC_NUMBERS.WEBP;
+    }
+    static isTGA(data) {
+        const view = dataView(data);
+        return isTGA(new Uint8Array(view.buffer, view.byteOffset, view.byteLength));
+    }
+}