@min-pack/tfjs-node 2.17.1 → 3.8.1-patch.0

package/tfjs-types/utils/data-structures.d.ts

@@ -0,0 +1,294 @@
+/**
+ * @file Custom data structures.
+ *
+ * These are only used internally, meaning an end-user shouldn't
+ * need to access anything here.
+ *
+ * @module utils/data-structures
+ */
+/**
+ * Efficient Heap-based Implementation of a Priority Queue.
+ * It uses an array-based binary heap, where the root is at index `0`, and the
+ * children of node `i` are located at indices `2i + 1` and `2i + 2`, respectively.
+ *
+ * Adapted from the following sources:
+ * - https://stackoverflow.com/a/42919752/13989043 (original)
+ * - https://github.com/belladoreai/llama-tokenizer-js (minor improvements)
+ */
+export class PriorityQueue {
+    /**
+     * Create a new PriorityQueue.
+     * @param {function(any, any): boolean} comparator Comparator function to determine priority. Defaults to a MaxHeap.
+     */
+    constructor(comparator?: (arg0: any, arg1: any) => boolean, maxSize?: number);
+    _heap: any[];
+    _comparator: (arg0: any, arg1: any) => boolean;
+    _maxSize: number;
+    /**
+     * The size of the queue
+     */
+    get size(): number;
+    /**
+     * Check if the queue is empty.
+     * @returns {boolean} `true` if the queue is empty, `false` otherwise.
+     */
+    isEmpty(): boolean;
+    /**
+     * Return the element with the highest priority in the queue.
+     * @returns {any} The highest priority element in the queue.
+     */
+    peek(): any;
+    /**
+     * Add one or more elements to the queue.
+     * @param  {...any} values The values to push into the queue.
+     * @returns {number} The new size of the queue.
+     */
+    push(...values: any[]): number;
+    /**
+     * Add multiple elements to the queue.
+     * @param {any[]} values The values to push into the queue.
+     * @returns {number} The new size of the queue.
+     */
+    extend(values: any[]): number;
+    /**
+     * Remove and return the element with the highest priority in the queue.
+     * @returns {any} The element with the highest priority in the queue.
+     */
+    pop(): any;
+    /**
+     * Replace the element with the highest priority in the queue with a new value.
+     * @param {*} value The new value.
+     * @returns {*} The replaced value.
+     */
+    replace(value: any): any;
+    /**
+     * Compute the index for the parent of the node at index `i`.
+     * @param {number} i The index of the node to get the parent of.
+     * @returns {number} The index of the parent node.
+     * @private
+     */
+    private _parent;
+    /**
+     * Compute the index for the left child of the node at index `i`.
+     * @param {number} i The index of the node to get the left child of.
+     * @returns {number} The index of the left child.
+     * @private
+     */
+    private _left;
+    /**
+     * Compute the index for the right child of the node at index `i`.
+     * @param {number} i The index of the node to get the right child of.
+     * @returns {number} The index of the right child.
+     * @private
+     */
+    private _right;
+    /**
+     * Check if the element at index `i` is greater than the element at index `j`.
+     * @param {number} i The index of the first element to compare.
+     * @param {number} j The index of the second element to compare.
+     * @returns {boolean} `true` if the element at index `i` is greater than the element at index `j`, `false` otherwise.
+     * @private
+     */
+    private _greater;
+    /**
+     * Swap the elements at indices `i` and `j`.
+     * @param {number} i The index of the first element to swap.
+     * @param {number} j The index of the second element to swap.
+     * @private
+     */
+    private _swap;
+    /**
+     * Maintain the heap property by updating positions in the heap,
+     * starting at the last element and moving up the heap.
+     * @private
+     */
+    private _siftUp;
+    /**
+     * Helper function to sift up from a given node.
+     * @param {number} node The index of the node to start sifting up from.
+     */
+    _siftUpFrom(node: number): void;
+    /**
+     * Maintain the heap property by updating positions in the heap,
+     * starting at the first element and moving down the heap.
+     * @private
+     */
+    private _siftDown;
+    /**
+     * Get the index of the smallest element in the heap. Since we use an array-based heap,
+     * the index can be computed without needing to traverse the heap.
+     * @private
+     */
+    private _smallest;
+}
+/**
+ * A trie structure to efficiently store and search for strings.
+ */
+export class CharTrie {
+    root: CharTrieNode;
+    /**
+     * Adds one or more `texts` to the trie.
+     * @param {string[]} texts The strings to add to the trie.
+     */
+    extend(texts: string[]): void;
+    /**
+     * Adds text to the trie.
+     * @param {string} text The string to add to the trie.
+     */
+    push(text: string): void;
+    /**
+     * Searches the trie for all strings with a common prefix of `text`.
+     * @param {string} text The common prefix to search for.
+     * @yields {string} Each string in the trie that has `text` as a prefix.
+     */
+    commonPrefixSearch(text: string): Generator<string, void, unknown>;
+}
+/**
+ * A lattice data structure to be used for tokenization.
+ */
+export class TokenLattice {
+    /**
+     * Creates a new TokenLattice instance.
+     *
+     * @param {string} sentence The input sentence to be tokenized.
+     * @param {number} bosTokenId The beginning-of-sequence token ID.
+     * @param {number} eosTokenId The end-of-sequence token ID.
+     */
+    constructor(sentence: string, bosTokenId: number, eosTokenId: number);
+    chars: string[];
+    len: number;
+    bosTokenId: number;
+    eosTokenId: number;
+    nodes: TokenLatticeNode[];
+    beginNodes: any[][];
+    endNodes: any[][];
+    /**
+     * Inserts a new token node into the token lattice.
+     *
+     * @param {number} pos The starting position of the token.
+     * @param {number} length The length of the token.
+     * @param {number} score The score of the token.
+     * @param {number} tokenId The token ID of the token.
+     */
+    insert(pos: number, length: number, score: number, tokenId: number): void;
+    /**
+     * Implements the Viterbi algorithm to compute the most likely sequence of tokens.
+     *
+     * @returns {TokenLatticeNode[]} The most likely sequence of tokens.
+     */
+    viterbi(): TokenLatticeNode[];
+    /**
+     * @param {TokenLatticeNode} node
+     * @returns {string} The array of nodes representing the most likely sequence of tokens.
+     */
+    piece(node: TokenLatticeNode): string;
+    /**
+     * @returns {string[]} The most likely sequence of tokens.
+     */
+    tokens(): string[];
+    /**
+     * @returns {number[]} The most likely sequence of token ids.
+     */
+    tokenIds(): number[];
+}
+/**
+ * A data structure which uses a trie to split a string into tokens based on a dictionary.
+ * It can also use a regular expression to preprocess the input text before splitting.
+ *
+ * NOTE: To ensure multi-byte characters are handled correctly, we operate at byte-level instead of character-level.
+ */
+export class DictionarySplitter {
+    /**
+     * @param {string[]} dictionary The dictionary of words to use for splitting.
+     */
+    constructor(dictionary: string[]);
+    trie: any;
+    /**
+     * Builds a trie from the given dictionary.
+     * @param {string[]} dictionary The dictionary of words to build the trie from.
+     * @returns {Object} The root node of the trie.
+     * @private
+     */
+    private _buildTrie;
+    /**
+     * Splits the input text into tokens based on the dictionary.
+     * @param {string} text The input text to split.
+     * @returns {string[]} An array of tokens.
+     */
+    split(text: string): string[];
+}
+/**
+* A simple Least Recently Used (LRU) cache implementation in JavaScript.
+* This cache stores key-value pairs and evicts the least recently used item
+* when the capacity is exceeded.
+*/
+export class LRUCache {
+    /**
+     * Creates an LRUCache instance.
+     * @param {number} capacity The maximum number of items the cache can hold.
+     */
+    constructor(capacity: number);
+    capacity: number;
+    cache: Map<any, any>;
+    /**
+     * Retrieves the value associated with the given key and marks the key as recently used.
+     * @param {any} key The key to retrieve.
+     * @returns {any} The value associated with the key, or undefined if the key does not exist.
+     */
+    get(key: any): any;
+    /**
+     * Inserts or updates the key-value pair in the cache.
+     * If the key already exists, it is updated and marked as recently used.
+     * If the cache exceeds its capacity, the least recently used item is evicted.
+     * @param {any} key The key to add or update.
+     * @param {any} value The value to associate with the key.
+     */
+    put(key: any, value: any): void;
+    /**
+     * Clears the cache.
+     */
+    clear(): void;
+}
+/**
+ * Represents a node in a character trie.
+ */
+declare class CharTrieNode {
+    /**
+     * Returns a new `CharTrieNode` instance with default values.
+     * @returns {CharTrieNode} A new `CharTrieNode` instance with `isLeaf` set to `false` and an empty `children` map.
+     */
+    static default(): CharTrieNode;
+    /**
+     * Create a new CharTrieNode.
+     * @param {boolean} isLeaf Whether the node is a leaf node or not.
+     * @param {Map<string, CharTrieNode>} children A map containing the node's children, where the key is a character and the value is a `CharTrieNode`.
+     */
+    constructor(isLeaf: boolean, children: Map<string, CharTrieNode>);
+    isLeaf: boolean;
+    children: Map<string, CharTrieNode>;
+}
+declare class TokenLatticeNode {
+    /**
+     * Represents a node in a token lattice for a given sentence.
+     * @param {number} tokenId The ID of the token associated with this node.
+     * @param {number} nodeId The ID of this node.
+     * @param {number} pos The starting position of the token in the sentence.
+     * @param {number} length The length of the token.
+     * @param {number} score The score associated with the token.
+     */
+    constructor(tokenId: number, nodeId: number, pos: number, length: number, score: number);
+    tokenId: number;
+    nodeId: number;
+    pos: number;
+    length: number;
+    score: number;
+    prev: any;
+    backtraceScore: number;
+    /**
+     * Returns a clone of this node.
+     * @returns {TokenLatticeNode} A clone of this node.
+     */
+    clone(): TokenLatticeNode;
+}
+export {};
+//# sourceMappingURL=data-structures.d.ts.map

package/tfjs-types/utils/devices.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The list of devices supported by Transformers.js
+ */
+export const DEVICE_TYPES: Readonly<{
+    auto: "auto";
+    gpu: "gpu";
+    cpu: "cpu";
+    wasm: "wasm";
+    webgpu: "webgpu";
+    cuda: "cuda";
+    dml: "dml";
+    webnn: "webnn";
+    'webnn-npu': "webnn-npu";
+    'webnn-gpu': "webnn-gpu";
+    'webnn-cpu': "webnn-cpu";
+}>;
+export type DeviceType = keyof typeof DEVICE_TYPES;
+//# sourceMappingURL=devices.d.ts.map

package/tfjs-types/utils/dtypes.d.ts

@@ -0,0 +1,20 @@
+export function isWebGpuFp16Supported(): Promise<boolean>;
+export const DATA_TYPES: Readonly<{
+    auto: "auto";
+    fp32: "fp32";
+    fp16: "fp16";
+    q8: "q8";
+    int8: "int8";
+    uint8: "uint8";
+    q4: "q4";
+    bnb4: "bnb4";
+    q4f16: "q4f16";
+}>;
+/** @typedef {keyof typeof DATA_TYPES} DataType */
+export const DEFAULT_DEVICE_DTYPE_MAPPING: Readonly<{
+    wasm: "q8";
+}>;
+/** @type {Record<Exclude<DataType, "auto">, string>} */
+export const DEFAULT_DTYPE_SUFFIX_MAPPING: Record<Exclude<DataType, "auto">, string>;
+export type DataType = keyof typeof DATA_TYPES;
+//# sourceMappingURL=dtypes.d.ts.map

package/tfjs-types/utils/generic.d.ts

@@ -0,0 +1,11 @@
+/**
+ * A base class for creating callable objects.
+ * See [here](https://stackoverflow.com/q/76073890) for more information.
+ *
+ * @type {new () => {(...args: any[]): any, _call(...args: any[]): any}}
+ */
+export const Callable: new () => {
+    (...args: any[]): any;
+    _call(...args: any[]): any;
+};
+//# sourceMappingURL=generic.d.ts.map

package/tfjs-types/utils/hub.d.ts

@@ -0,0 +1,175 @@
+/**
+ * Helper function to get a file, using either the Fetch API or FileSystem API.
+ *
+ * @param {URL|string} urlOrPath The URL/path of the file to get.
+ * @returns {Promise<FileResponse|Response>} A promise that resolves to a FileResponse object (if the file is retrieved using the FileSystem API), or a Response object (if the file is retrieved using the Fetch API).
+ */
+export function getFile(urlOrPath: URL | string): Promise<FileResponse | Response>;
+/**
+ * Retrieves a file from either a remote URL using the Fetch API or from the local file system using the FileSystem API.
+ * If the filesystem is available and `env.useCache = true`, the file will be downloaded and cached.
+ *
+ * @param {string} path_or_repo_id This can be either:
+ * - a string, the *model id* of a model repo on huggingface.co.
+ * - a path to a *directory* potentially containing the file.
+ * @param {string} filename The name of the file to locate in `path_or_repo`.
+ * @param {boolean} [fatal=true] Whether to throw an error if the file is not found.
+ * @param {PretrainedOptions} [options] An object containing optional parameters.
+ * @param {boolean} [return_path=false] Whether to return the path of the file instead of the file content.
+ *
+ * @throws Will throw an error if the file is not found and `fatal` is true.
+ * @returns {Promise<string|Uint8Array>} A Promise that resolves with the file content as a Uint8Array if `return_path` is false, or the file path as a string if `return_path` is true.
+ */
+export function getModelFile(path_or_repo_id: string, filename: string, fatal?: boolean, options?: PretrainedOptions, return_path?: boolean): Promise<string | Uint8Array>;
+/**
+ * Fetches a text file from a given path and file name.
+ *
+ * @param {string} modelPath The path to the directory containing the file.
+ * @param {string} fileName The name of the file to fetch.
+ * @param {boolean} [fatal=true] Whether to throw an error if the file is not found.
+ * @param {PretrainedOptions} [options] An object containing optional parameters.
+ * @returns {Promise<string|null>} The text content of the file.
+ * @throws Will throw an error if the file is not found and `fatal` is true.
+ */
+export function getModelText(modelPath: string, fileName: string, fatal?: boolean, options?: PretrainedOptions): Promise<string | null>;
+/**
+ * Fetches a JSON file from a given path and file name.
+ *
+ * @param {string} modelPath The path to the directory containing the file.
+ * @param {string} fileName The name of the file to fetch.
+ * @param {boolean} [fatal=true] Whether to throw an error if the file is not found.
+ * @param {PretrainedOptions} [options] An object containing optional parameters.
+ * @returns {Promise<Object>} The JSON data parsed into a JavaScript object.
+ * @throws Will throw an error if the file is not found and `fatal` is true.
+ */
+export function getModelJSON(modelPath: string, fileName: string, fatal?: boolean, options?: PretrainedOptions): Promise<any>;
+/**
+ * @typedef {boolean|number} ExternalData Whether to load the model using the external data format (used for models >= 2GB in size).
+ * If `true`, the model will be loaded using the external data format.
+ * If a number, this many chunks will be loaded using the external data format (of the form: "model.onnx_data[_{chunk_number}]").
+ */
+export const MAX_EXTERNAL_DATA_CHUNKS: 100;
+/**
+ * Whether to load the model using the external data format (used for models >= 2GB in size).
+ * If `true`, the model will be loaded using the external data format.
+ * If a number, this many chunks will be loaded using the external data format (of the form: "model.onnx_data[_{chunk_number}]").
+ */
+export type ExternalData = boolean | number;
+/**
+ * Options for loading a pretrained model.
+ */
+export type PretrainedOptions = {
+    /**
+     * If specified, this function will be called during model construction, to provide the user with progress updates.
+     */
+    progress_callback?: import("./core.js").ProgressCallback;
+    /**
+     * Configuration for the model to use instead of an automatically loaded configuration. Configuration can be automatically loaded when:
+     * - The model is a model provided by the library (loaded with the *model id* string of a pretrained model).
+     * - The model is loaded by supplying a local directory as `pretrained_model_name_or_path` and a configuration JSON file named *config.json* is found in the directory.
+     */
+    config?: import("../configs.js").PretrainedConfig;
+    /**
+     * Path to a directory in which a downloaded pretrained model configuration should be cached if the standard cache should not be used.
+     */
+    cache_dir?: string;
+    /**
+     * Whether or not to only look at local files (e.g., not try downloading the model).
+     */
+    local_files_only?: boolean;
+    /**
+     * The specific model version to use. It can be a branch name, a tag name, or a commit id,
+     * since we use a git-based system for storing models and other artifacts on huggingface.co, so `revision` can be any identifier allowed by git.
+     * NOTE: This setting is ignored for local requests.
+     */
+    revision?: string;
+};
+/**
+ * Options for loading a pretrained model.
+ */
+export type ModelSpecificPretrainedOptions = {
+    /**
+     * In case the relevant files are located inside a subfolder of the model repo on huggingface.co,
+     * you can specify the folder name here.
+     */
+    subfolder?: string;
+    /**
+     * If specified, load the model with this name (excluding the .onnx suffix). Currently only valid for encoder- or decoder-only models.
+     */
+    model_file_name?: string;
+    /**
+     * The device to run the model on. If not specified, the device will be chosen from the environment settings.
+     */
+    device?: import("./devices.js").DeviceType | Record<string, import("./devices.js").DeviceType>;
+    /**
+     * The data type to use for the model. If not specified, the data type will be chosen from the environment settings.
+     */
+    dtype?: import("./dtypes.js").DataType | Record<string, import("./dtypes.js").DataType>;
+    /**
+     * Whether to load the model using the external data format (used for models >= 2GB in size).
+     */
+    use_external_data_format?: ExternalData | Record<string, ExternalData>;
+    /**
+     * (Optional) User-specified session options passed to the runtime. If not provided, suitable defaults will be chosen.
+     */
+    session_options?: import("onnxruntime-common").InferenceSession.SessionOptions;
+};
+/**
+ * Options for loading a pretrained model.
+ */
+export type PretrainedModelOptions = PretrainedOptions & ModelSpecificPretrainedOptions;
+declare class FileResponse {
+    /**
+     * Creates a new `FileResponse` object.
+     * @param {string} filePath
+     */
+    constructor(filePath: string);
+    filePath: string;
+    headers: Headers;
+    exists: boolean;
+    status: number;
+    statusText: string;
+    body: ReadableStream<any>;
+    /**
+     * Updates the 'content-type' header property of the response based on the extension of
+     * the file specified by the filePath property of the current object.
+     * @returns {void}
+     */
+    updateContentType(): void;
+    /**
+     * Clone the current FileResponse object.
+     * @returns {FileResponse} A new FileResponse object with the same properties as the current object.
+     */
+    clone(): FileResponse;
+    /**
+     * Reads the contents of the file specified by the filePath property and returns a Promise that
+     * resolves with an ArrayBuffer containing the file's contents.
+     * @returns {Promise<ArrayBuffer>} A Promise that resolves with an ArrayBuffer containing the file's contents.
+     * @throws {Error} If the file cannot be read.
+     */
+    arrayBuffer(): Promise<ArrayBuffer>;
+    /**
+     * Reads the contents of the file specified by the filePath property and returns a Promise that
+     * resolves with a Blob containing the file's contents.
+     * @returns {Promise<Blob>} A Promise that resolves with a Blob containing the file's contents.
+     * @throws {Error} If the file cannot be read.
+     */
+    blob(): Promise<Blob>;
+    /**
+     * Reads the contents of the file specified by the filePath property and returns a Promise that
+     * resolves with a string containing the file's contents.
+     * @returns {Promise<string>} A Promise that resolves with a string containing the file's contents.
+     * @throws {Error} If the file cannot be read.
+     */
+    text(): Promise<string>;
+    /**
+     * Reads the contents of the file specified by the filePath property and returns a Promise that
+     * resolves with a parsed JavaScript object containing the file's contents.
+     *
+     * @returns {Promise<Object>} A Promise that resolves with a parsed JavaScript object containing the file's contents.
+     * @throws {Error} If the file cannot be read.
+     */
+    json(): Promise<any>;
+}
+export {};
+//# sourceMappingURL=hub.d.ts.map

package/tfjs-types/utils/image.d.ts

@@ -0,0 +1,141 @@
+export class RawImage {
+    /**
+     * Helper method for reading an image from a variety of input types.
+     * @param {RawImage|string|URL|Blob|HTMLCanvasElement|OffscreenCanvas} input
+     * @returns The image object.
+     *
+     * **Example:** Read image from a URL.
+     * ```javascript
+     * let image = await RawImage.read('https://huggingface.co/datasets/Xenova/transformers.js-docs/resolve/main/football-match.jpg');
+     * // RawImage {
+     * //   "data": Uint8ClampedArray [ 25, 25, 25, 19, 19, 19, ... ],
+     * //   "width": 800,
+     * //   "height": 533,
+     * //   "channels": 3
+     * // }
+     * ```
+     */
+    static read(input: RawImage | string | URL | Blob | HTMLCanvasElement | OffscreenCanvas): Promise<RawImage>;
+    /**
+     * Read an image from a canvas.
+     * @param {HTMLCanvasElement|OffscreenCanvas} canvas The canvas to read the image from.
+     * @returns {RawImage} The image object.
+     */
+    static fromCanvas(canvas: HTMLCanvasElement | OffscreenCanvas): RawImage;
+    /**
+     * Read an image from a URL or file path.
+     * @param {string|URL} url The URL or file path to read the image from.
+     * @returns {Promise<RawImage>} The image object.
+     */
+    static fromURL(url: string | URL): Promise<RawImage>;
+    /**
+     * Helper method to create a new Image from a blob.
+     * @param {Blob} blob The blob to read the image from.
+     * @returns {Promise<RawImage>} The image object.
+     */
+    static fromBlob(blob: Blob): Promise<RawImage>;
+    /**
+     * Helper method to create a new Image from a tensor
+     * @param {Tensor} tensor
+     */
+    static fromTensor(tensor: Tensor, channel_format?: string): RawImage;
+    /**
+     * Create a new `RawImage` object.
+     * @param {Uint8ClampedArray|Uint8Array} data The pixel data.
+     * @param {number} width The width of the image.
+     * @param {number} height The height of the image.
+     * @param {1|2|3|4} channels The number of channels.
+     */
+    constructor(data: Uint8ClampedArray | Uint8Array, width: number, height: number, channels: 1 | 2 | 3 | 4);
+    data: Uint8Array<ArrayBufferLike> | Uint8ClampedArray<ArrayBufferLike>;
+    width: number;
+    height: number;
+    channels: 2 | 1 | 3 | 4;
+    /**
+     * Returns the size of the image (width, height).
+     * @returns {[number, number]} The size of the image (width, height).
+     */
+    get size(): [number, number];
+    /**
+     * Convert the image to grayscale format.
+     * @returns {RawImage} `this` to support chaining.
+     */
+    grayscale(): RawImage;
+    /**
+     * Convert the image to RGB format.
+     * @returns {RawImage} `this` to support chaining.
+     */
+    rgb(): RawImage;
+    /**
+     * Convert the image to RGBA format.
+     * @returns {RawImage} `this` to support chaining.
+     */
+    rgba(): RawImage;
+    /**
+     * Apply an alpha mask to the image. Operates in place.
+     * @param {RawImage} mask The mask to apply. It should have a single channel.
+     * @returns {RawImage} The masked image.
+     * @throws {Error} If the mask is not the same size as the image.
+     * @throws {Error} If the image does not have 4 channels.
+     * @throws {Error} If the mask is not a single channel.
+     */
+    putAlpha(mask: RawImage): RawImage;
+    /**
+     * Resize the image to the given dimensions. This method uses the canvas API to perform the resizing.
+     * @param {number} width The width of the new image. `null` or `-1` will preserve the aspect ratio.
+     * @param {number} height The height of the new image. `null` or `-1` will preserve the aspect ratio.
+     * @param {Object} options Additional options for resizing.
+     * @param {0|1|2|3|4|5|string} [options.resample] The resampling method to use.
+     * @returns {Promise<RawImage>} `this` to support chaining.
+     */
+    resize(width: number, height: number, { resample, }?: {
+        resample?: 0 | 1 | 2 | 3 | 4 | 5 | string;
+    }): Promise<RawImage>;
+    pad([left, right, top, bottom]: [any, any, any, any]): Promise<any>;
+    crop([x_min, y_min, x_max, y_max]: [any, any, any, any]): Promise<any>;
+    center_crop(crop_width: any, crop_height: any): Promise<any>;
+    toBlob(type?: string, quality?: number): Promise<any>;
+    toTensor(channel_format?: string): Tensor;
+    toCanvas(): any;
+    /**
+     * Split this image into individual bands. This method returns an array of individual image bands from an image.
+     * For example, splitting an "RGB" image creates three new images each containing a copy of one of the original bands (red, green, blue).
+     *
+     * Inspired by PIL's `Image.split()` [function](https://pillow.readthedocs.io/en/latest/reference/Image.html#PIL.Image.Image.split).
+     * @returns {RawImage[]} An array containing bands.
+     */
+    split(): RawImage[];
+    /**
+     * Helper method to update the image data.
+     * @param {Uint8ClampedArray} data The new image data.
+     * @param {number} width The new width of the image.
+     * @param {number} height The new height of the image.
+     * @param {1|2|3|4|null} [channels] The new number of channels of the image.
+     * @private
+     */
+    private _update;
+    /**
+     * Clone the image
+     * @returns {RawImage} The cloned image
+     */
+    clone(): RawImage;
+    /**
+     * Helper method for converting image to have a certain number of channels
+     * @param {number} numChannels The number of channels. Must be 1, 3, or 4.
+     * @returns {RawImage} `this` to support chaining.
+     */
+    convert(numChannels: number): RawImage;
+    /**
+     * Save the image to the given path.
+     * @param {string} path The path to save the image to.
+     */
+    save(path: string): Promise<sharp.OutputInfo>;
+    toSharp(): sharp.Sharp;
+}
+/**
+ * Helper function to load an image from a URL, path, etc.
+ */
+export const load_image: any;
+import { Tensor } from './tensor.js';
+import sharp from 'sharp';
+//# sourceMappingURL=image.d.ts.map