imagescript 1.3.1 → 3.0.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,44 @@
+import { BinaryData } from './util/mem.js';
+import { ResizeMode } from './image.js';
+import { Frame } from './frame.js';
+/**
+ * Represents a GIF image as an array of frames.
+ * Array methods like map and filter return plain arrays.
+ */
+export declare class GIF extends Array<Frame> {
+    /** How many times to repeat the GIF (-1 = forever, 0 = play once) */
+    loopCount: number;
+    /**
+     * 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);
+    /** The GIF's width */
+    get width(): number;
+    /** The GIF's height */
+    get height(): number;
+    /** The GIF's duration (in ms) */
+    get duration(): number;
+    toString(): string;
+    /**
+     * Returns a new GIF containing a range of this GIF's frames (same semantics as Array.prototype.slice)
+     */
+    slice(start?: number, end?: number): GIF;
+    /**
+     * Encodes the GIF
+     * @param quality 1-100, scales the palette size from 8 colors (1) to 256 colors (90 and above)
+     */
+    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
+     */
+    static decode(input: BinaryData, onlyExtractFirstFrame?: boolean): Promise<GIF>;
+    /**
+     * Resizes the GIF to the given dimensions, scaling every frame and its offsets proportionally.
+     * Use {@link Image.RESIZE_AUTO} as either width or height to automatically preserve the aspect ratio.
+     */
+    resize(width: number, height: number, mode?: ResizeMode): this;
+}

package/dist/gif.js

@@ -0,0 +1,93 @@
+import * as codec from "./codecs/gif.js";
+import { view } from "./util/mem.js";
+import { Image } from "./image.js";
+import { Frame } from "./frame.js";
+import { ImageType } from "./image-type.js";
+export class GIF extends Array {
+    loopCount;
+    constructor(frames, loopCount = -1) {
+        super();
+        for (const frame of frames)
+            this.push(frame);
+        for (let i = 0; i < this.length; i++)
+            if (!(this[i] instanceof Frame))
+                throw new TypeError(`Frame ${i} is not an instance of Frame`);
+        if (loopCount < -1 || isNaN(loopCount))
+            throw new RangeError('Invalid loop count');
+        this.loopCount = loopCount;
+    }
+    static get [Symbol.species]() {
+        return Array;
+    }
+    get width() {
+        let max = 0;
+        for (const frame of this)
+            max = Math.max(max, frame.width + frame.xOffset);
+        return max;
+    }
+    get height() {
+        let max = 0;
+        for (const frame of this)
+            max = Math.max(max, frame.height + frame.yOffset);
+        return max;
+    }
+    get duration() {
+        let duration = 0;
+        for (const frame of this)
+            duration += frame.duration;
+        return duration;
+    }
+    toString() {
+        return `GIF<${this.width}x${this.height}x${this.duration}ms>`;
+    }
+    slice(start, end) {
+        return new GIF(Array.prototype.slice.call(this, start, end), this.loopCount);
+    }
+    async encode(quality = 95) {
+        const frames = [];
+        for (const frame of this) {
+            if (!(frame instanceof Frame))
+                throw new Error('GIF contains invalid frames');
+            frames.push({
+                x: frame.xOffset,
+                y: frame.yOffset,
+                width: frame.width,
+                height: frame.height,
+                delay: Math.round(frame.duration / 10),
+                dispose: frame.__disposal_id__,
+                pixels: new Uint8Array(frame.bitmap.buffer, frame.bitmap.byteOffset, frame.bitmap.byteLength)
+            });
+        }
+        return codec.encode({ width: this.width, height: this.height, loopCount: this.loopCount, frames }, 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');
+        const decoded = codec.decode(data, onlyExtractFirstFrame);
+        const frames = codec.composite(decoded).map(({ pixels, delay }) => {
+            const frame = new Frame(decoded.width, decoded.height, 10 * delay, 0, 0, Frame.DISPOSAL_BACKGROUND);
+            frame.bitmap.set(pixels);
+            return frame;
+        });
+        return new GIF(frames, decoded.loopCount);
+    }
+    resize(width, height, mode = Image.RESIZE_BILINEAR) {
+        const originalWidth = this.width, originalHeight = this.height;
+        if (width === Image.RESIZE_AUTO && height === Image.RESIZE_AUTO)
+            throw new Error('RESIZE_AUTO can only be used for either width or height, not for both');
+        if (width === Image.RESIZE_AUTO)
+            width = originalWidth / originalHeight * height;
+        if (height === Image.RESIZE_AUTO)
+            height = originalHeight / originalWidth * width;
+        const sx = width / originalWidth, sy = height / originalHeight;
+        for (const frame of this) {
+            const left = Math.round(frame.xOffset * sx), top = Math.round(frame.yOffset * sy);
+            const right = Math.round((frame.xOffset + frame.width) * sx), bottom = Math.round((frame.yOffset + frame.height) * sy);
+            Image.prototype.resize.call(frame, Math.max(1, right - left), Math.max(1, bottom - top), mode);
+            frame.xOffset = left;
+            frame.yOffset = top;
+        }
+        return this;
+    }
+}

package/dist/image-type.d.ts

@@ -0,0 +1,20 @@
+import { BinaryData } from './util/mem.js';
+/** Image formats recognized by {@link ImageType.getType} */
+export type ImageTypeName = 'png' | 'jpeg' | 'tiff' | 'gif';
+/** 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;
+}

package/dist/image-type.js

@@ -0,0 +1,49 @@
+import { view as bytes } from "./util/mem.js";
+const MAGIC_NUMBERS = {
+    PNG: 0x89504e47,
+    JPEG: 0xffd8ff,
+    TIFF_LE: 0x49492a00,
+    TIFF_BE: 0x4d4d002a,
+    BIGTIFF_LE: 0x49492b00,
+    BIGTIFF_BE: 0x4d4d002b,
+    GIF: 0x474946
+};
+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';
+        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;
+    }
+}