ImageScript.d.ts

export class Image {
  private __width__: number;
  private __height__: number;
  private __buffer__: ArrayBuffer;
  private __view__: DataView;
  private __u32__: Uint32Array;
  bitmap: Uint8ClampedArray;

  constructor(width: number, height: number);

  private toString(): string;

  get width(): number;

  get height(): number;

  * [Symbol.iterator](): void;

  * iterateWithColors(): Generator<[x: number, y: number, color: number], void, unknown>;

  static rgbaToColor(r: number, g: number, b: number, a: number): number;

  static rgbToColor(r: number, g: number, b: number): number;

  static hslaToColor(h: number, s: number, l: number, a: number): number;

  static hslToColor(h: number, s: number, l: number): number;

  static rgbaToHSLA(r: number, g: number, b: number, a: number): number[];

  static colorToRGBA(color: number): number[];

  static colorToRGB(color: number): number[];

  getPixelAt(x: number, y: number): number;

  getRGBAAt(x: number, y: number): Uint8ClampedArray;

  setPixelAt(x: number, y: number, pixelColor: number): Image;

  private __set_pixel__(x: number, y: number, pixelColor: number): void;

  private __check_boundaries__(x: number, y: number): void;

  private static get __out_of_bounds__(): string;

  fill(color: number | colorFunction): Image;

  clone(): Image;

  static get RESIZE_NEAREST_NEIGHBOR(): string;

  static get RESIZE_AUTO(): number;

  scale(factor: number, mode?: string): Image;

  private __scale__(factor: number, mode?: string);

  resize(width: number, height: number, mode?: string): Image;

  contain(width: number, height: number, mode?: string): Image;

  fit(width: number, height: number, mode?: string): Image;

  cover(width: number, height: number, mode?: string): Image;

  private __resize__(width: number, height: number, mode?: string): Image;

  private __resize_nearest_neighbor__(width: number, height: number): Image;

  crop(x: number, y: number, width: number, height: number): Image;

  private __crop__(x: number, y: number, width: number, height: number): Image;

  drawBox(x: number, y: number, width: number, height: number, color: number | colorFunction): Image;

  private __fast_box__(x: number, y: number, width: number, height: number, color: number): Image;

  drawCircle(x: number, y: number, radius: number, color: number | colorFunction): Image;

  cropCircle(max?: boolean, feathering?: number): Image;

  opacity(opacity: number, absolute?: boolean): Image;

  red(saturation: number, absolute?: boolean): Image;

  green(saturation: number, absolute?: boolean): Image;

  blue(saturation: number, absolute?: boolean): Image;

  private __set_channel_value__(value: number, absolute: boolean, offset: number): void;

  lightness(value: number, absolute?: boolean): Image;

  saturation(value: number, absolute?: boolean): Image;

  composite(source: Image, x?: number, y?: number): Image;

  invert(): Image;

  invertValue(): Image;

  invertSaturation(): Image;

  invertHue(): Image;

  hueShift(degrees: number): Image;

  averageColor(): number;

  dominantColor(ignoreBlack?: boolean, ignoreWhite?: boolean, bwThreshold?: number): number;

  rotate(angle: number, resize?: boolean): Image;

  flip(direction: 'horizontal' | 'vertical'): Image;

  private __apply__(image: Image | Frame): Image | Frame;

  static gradient(colors: { [position: number]: number; }): ((position: number) => number);

  roundCorners(radius?: number): Image;

  private static __gradient__(startColor: number, endColor: number): number;

  fisheye(radius?: number): Image;

  async encode(compression?: number, metadata?: PNGMetadata): Promise<Uint8Array>;
  async encode(metadata?: PNGMetadata): Promise<Uint8Array>;

  async encodeJPEG(quality?: number): Promise<Uint8Array>;

  async encodeWEBP(quality?: null | number): Promise<Uint8Array>;

  static async decode(data: Buffer | Uint8Array): Promise<Image>

  static get SVG_MODE_SCALE(): number;

  static get SVG_MODE_WIDTH(): number;

  static get SVG_MODE_HEIGHT(): number;

  static async renderSVG(svg: string, size?: number, mode?: number): Promise<Image>;

  static async renderText(font: Uint8Array, scale: number, text: string, color?: number, layout?: TextLayout): Promise<Image>;
};

export class Frame extends Image {
  static get DISPOSAL_KEEP(): string;

  static get DISPOSAL_PREVIOUS(): string;

  static get DISPOSAL_BACKGROUND(): string

  private static __convert_disposal_mode__(mode: string | number): any;

  constructor(width: number, height: number, duration?: number, xOffset?: number, yOffset?: number, disposalMode?: typeof Frame.DISPOSAL_KEEP | string);

  duration: number;

  xOffset: number;

  yOffset: number;

  get disposalMode(): number;

  set disposalMode(disposalMode: string|number);

  toString(): string;

  static from(image: Image, duration?: number, xOffset?: number, yOffset?: number, disposalMode?: typeof Frame.DISPOSAL_KEEP | string): Frame;

  resize(width: number, height: number, mode?: typeof Image.RESIZE_NEAREST_NEIGHBOR | string): Image;
};

export class GIF extends Array {
  constructor(frames: Frame[], loopCount?: number);

  get width(): number;

  get height(): number;

  toString(): string;

  * [Symbol.iterator](): Generator<Frame, void, *>

  slice(start: number, end: number): GIF;

  get duration(): number;

  async encode(quality?: number): Promise<Uint8Array>

  static async decode(data: Buffer | Uint8Array, onlyExtractFirstFrame?: boolean): Promise<GIF>;

  resize(width: number, height: number, mode?: typeof Image.RESIZE_NEAREST_NEIGHBOR | string): void;
}

export class TextLayout {
  constructor(options?: {
    maxWidth?: number,
    maxHeight?: number,
    wrapStyle?: string,
    verticalAlign?: string,
    horizontalAlign?: string,
    wrapHardBreaks?: boolean
  });
};

export class ImageType {
  static getType(data: Buffer | Uint8Array): string | null;

  static isPNG(view: DataView): boolean;

  static isJPEG(view: DataView): boolean;

  static isTIFF(view: DataView): boolean;

  static isGIF(view: DataView): boolean;
};

export function decode(data: Uint8Array | Buffer, onlyExtractFirstFrame?: boolean): Promise<GIF | Image>;

type colorFunction = (x: number, y: number) => number;

type PNGMetadata = {
  title?: string,
  author?: string,
  description?: string,
  copyright?: string,
  creationTime?: string | number | Date,
  software?: string,
  disclaimer?: string,
  warning?: string,
  source?: string,
  comment?: string
};