@huggingface/transformers 3.0.0-alpha.0

package/types/utils/hub.d.ts

@@ -0,0 +1,191 @@
+/**
+ * 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.
+ *
+ * @throws Will throw an error if the file is not found and `fatal` is true.
+ * @returns {Promise<Uint8Array>} A Promise that resolves with the file content as a buffer.
+ */
+export function getModelFile(path_or_repo_id: string, filename: string, fatal?: boolean, options?: PretrainedOptions): Promise<Uint8Array>;
+/**
+ * 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>;
+/**
+ * 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?: Function;
+    /**
+     * 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?: any;
+    /**
+     * 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?: boolean | Record<string, boolean>;
+    /**
+     * (Optional) User-specified session options passed to the runtime. If not provided, suitable defaults will be chosen.
+     */
+    session_options?: any;
+};
+/**
+ * Options for loading a pretrained model.
+ */
+export type PretrainedModelOptions = PretrainedOptions & ModelSpecificPretrainedOptions;
+/**
+ * @typedef {Object} PretrainedOptions Options for loading a pretrained model.
+ * @property {function} [progress_callback=null] If specified, this function will be called during model construction, to provide the user with progress updates.
+ * @property {Object} [config=null] 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.
+ * @property {string} [cache_dir=null] Path to a directory in which a downloaded pretrained model configuration should be cached if the standard cache should not be used.
+ * @property {boolean} [local_files_only=false] Whether or not to only look at local files (e.g., not try downloading the model).
+ * @property {string} [revision='main'] 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.
+ */
+/**
+ * @typedef {Object} ModelSpecificPretrainedOptions Options for loading a pretrained model.
+ * @property {string} [subfolder='onnx'] In case the relevant files are located inside a subfolder of the model repo on huggingface.co,
+ * you can specify the folder name here.
+ * @property {string} [model_file_name=null] If specified, load the model with this name (excluding the .onnx suffix). Currently only valid for encoder- or decoder-only models.
+ * @property {import("./devices.js").DeviceType|Record<string, import("./devices.js").DeviceType>} [device=null] The device to run the model on. If not specified, the device will be chosen from the environment settings.
+ * @property {import("./dtypes.js").DataType|Record<string, import("./dtypes.js").DataType>} [dtype=null] The data type to use for the model. If not specified, the data type will be chosen from the environment settings.
+ * @property {boolean|Record<string, boolean>} [use_external_data_format=false] Whether to load the model using the external data format (used for models >= 2GB in size).
+ * @property {Object} [session_options] (Optional) User-specified session options passed to the runtime. If not provided, suitable defaults will be chosen.
+ */
+/**
+ * @typedef {PretrainedOptions & ModelSpecificPretrainedOptions} PretrainedModelOptions Options for loading a pretrained model.
+ */
+declare class FileResponse {
+    /**
+     * Creates a new `FileResponse` object.
+     * @param {string|URL} filePath
+     */
+    constructor(filePath: string | URL);
+    /**
+     * Mapping from file extensions to MIME types.
+     */
+    _CONTENT_TYPE_MAP: {
+        txt: string;
+        html: string;
+        css: string;
+        js: string;
+        json: string;
+        png: string;
+        jpg: string;
+        jpeg: string;
+        gif: string;
+    };
+    filePath: string | URL;
+    headers: Headers;
+    exists: any;
+    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/types/utils/hub.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hub.d.ts","sourceRoot":"","sources":["../../src/utils/hub.js"],"names":[],"mappings":"AAsLA;;;;;GAKG;AACH,mCAHW,GAAG,GAAC,MAAM,GACR,QAAQ,YAAY,GAAC,QAAQ,CAAC,CAgC1C;AA2GD;;;;;;;;;;;;;;GAcG;AACH,8CAVW,MAAM,YAGN,MAAM,UACN,OAAO,YACP,iBAAiB,GAGf,QAAQ,UAAU,CAAC,CAyO/B;AAED;;;;;;;;;GASG;AACH,wCAPW,MAAM,YACN,MAAM,UACN,OAAO,YACP,iBAAiB,GACf,YAAe,CAc3B;;;;;;;;;;;;;;;;;;gBA/jBa,MAAM;;;;uBACN,OAAO;;;;;;eACP,MAAM;;;;;;;;;;gBAON,MAAM;;;;sBAEN,MAAM;;;;aACN,OAAO,cAAc,EAAE,UAAU,GAAC,OAAO,MAAM,EAAE,OAAO,cAAc,EAAE,UAAU,CAAC;;;;YACnF,OAAO,aAAa,EAAE,QAAQ,GAAC,OAAO,MAAM,EAAE,OAAO,aAAa,EAAE,QAAQ,CAAC;;;;+BAC7E,OAAO,GAAC,OAAO,MAAM,EAAE,OAAO,CAAC;;;;;;;;;qCAKhC,iBAAiB,GAAG,8BAA8B;AAzB/D;;;;;;;;;;;GAWG;AAEH;;;;;;;;;GASG;AAEH;;GAEG;AAEH;IAeI;;;OAGG;IACH,sBAFW,MAAM,GAAC,GAAG,EA8BpB;IA9CD;;OAEG;IACH;;;;;;;;;;MAUC;IAMG,uBAAwB;IACxB,iBAA4B;IAE5B,YAAqC;IAEjC,eAAiB;IACjB,mBAAsB;IAQtB,0BAOE;IAQV;;;;OAIG;IACH,qBAFa,IAAI,CAMhB;IAED;;;OAGG;IACH,SAFa,YAAY,CASxB;IAED;;;;;OAKG;IACH,eAHa,QAAQ,WAAW,CAAC,CAMhC;IAED;;;;;OAKG;IACH,QAHa,QAAQ,IAAI,CAAC,CAMzB;IAED;;;;;OAKG;IACH,QAHa,QAAQ,MAAM,CAAC,CAM3B;IAED;;;;;;OAMG;IACH,QAHa,YAAe,CAK3B;CACJ"}

package/types/utils/image.d.ts

@@ -0,0 +1,119 @@
+export class RawImage {
+    /**
+     * Helper method for reading an image from a variety of input types.
+     * @param {RawImage|string|URL} 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): 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 | Uint8ClampedArray;
+    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;
+    /**
+     * 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.
+     * @param {number} height The height of the new image.
+     * @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;
+    /**
+     * 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<any>;
+    toSharp(): any;
+}
+import { Tensor } from './tensor.js';
+//# sourceMappingURL=image.d.ts.map

package/types/utils/image.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image.d.ts","sourceRoot":"","sources":["../../src/utils/image.js"],"names":[],"mappings":"AA6EA;IAwBI;;;;;;;;;;;;;;;OAeG;IACH,mBAdW,QAAQ,GAAC,MAAM,GAAC,GAAG,qBAsB7B;IAED;;;;OAIG;IACH,0BAHW,iBAAiB,GAAC,eAAe,GAC/B,QAAQ,CAUpB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GAAC,GAAG,GACR,QAAQ,QAAQ,CAAC,CAS7B;IAED;;;;OAIG;IACH,sBAHW,IAAI,GACF,QAAQ,QAAQ,CAAC,CAoB7B;IAED;;;OAGG;IACH,0BAFW,MAAM,qCA0BhB;IAlID;;;;;;OAMG;IACH,kBALW,iBAAiB,GAAC,UAAU,SAC5B,MAAM,UACN,MAAM,YACN,CAAC,GAAC,CAAC,GAAC,CAAC,GAAC,CAAC,EAOjB;IAJG,qCAAgB;IAChB,cAAkB;IAClB,eAAoB;IACpB,wBAAwB;IAG5B;;;OAGG;IACH,6BAEC;IAgHD;;;OAGG;IACH,aAFa,QAAQ,CAuBpB;IAED;;;OAGG;IACH,OAFa,QAAQ,CA6BpB;IAED;;;OAGG;IACH,QAFa,QAAQ,CA+BpB;IAED;;;;;;;OAOG;IACH,cANW,MAAM,UACN,MAAM;QAEuB,QAAQ,GAArC,CAAC,GAAC,CAAC,GAAC,CAAC,GAAC,CAAC,GAAC,CAAC,GAAC,CAAC,GAAC,MAAM;QAChB,QAAQ,QAAQ,CAAC,CAqE7B;IAED,oEA0CC;IAED,uEAkDC;IAED,6DAiHC;IAED,sDAOC;IAED,0CAeC;IAED,gBAiBC;IAED;;;;;;;OAOG;IACH,gBAQC;IAED;;;OAGG;IACH,SAFa,QAAQ,CAIpB;IAED;;;;OAIG;IACH,qBAHW,MAAM,GACJ,QAAQ,CAmBpB;IAED;;;OAGG;IACH,WAFW,MAAM,gBAsChB;IAED,eAYC;CACJ;uBA5tBsB,aAAa"}

package/types/utils/maths.d.ts

@@ -0,0 +1,280 @@
+/**
+ * @file Helper module for mathematical processing.
+ *
+ * These functions and classes are only used internally,
+ * meaning an end-user shouldn't need to access anything here.
+ *
+ * @module utils/maths
+ */
+/**
+ * @typedef {Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array} TypedArray
+ * @typedef {BigInt64Array | BigUint64Array} BigTypedArray
+ * @typedef {TypedArray | BigTypedArray} AnyTypedArray
+ */
+/**
+ * @param {TypedArray} input
+ */
+export function interpolate_data(input: TypedArray, [in_channels, in_height, in_width]: [any, any, any], [out_height, out_width]: [any, any], mode?: string, align_corners?: boolean): any;
+/**
+ * Helper method to permute a `AnyTypedArray` directly
+ * @template {AnyTypedArray} T
+ * @param {T} array
+ * @param {number[]} dims
+ * @param {number[]} axes
+ * @returns {[T, number[]]} The permuted array and the new shape.
+ */
+export function permute_data<T extends AnyTypedArray>(array: T, dims: number[], axes: number[]): [T, number[]];
+/**
+ * Compute the softmax of an array of numbers.
+ * @template {TypedArray|number[]} T
+ * @param {T} arr The array of numbers to compute the softmax of.
+ * @returns {T} The softmax array.
+ */
+export function softmax<T extends number[] | TypedArray>(arr: T): T;
+/**
+ * Calculates the logarithm of the softmax function for the input array.
+ * @template {TypedArray|number[]} T
+ * @param {T} arr The input array to calculate the log_softmax function for.
+ * @returns {T} The resulting log_softmax array.
+ */
+export function log_softmax<T extends number[] | TypedArray>(arr: T): T;
+/**
+ * Calculates the dot product of two arrays.
+ * @param {number[]} arr1 The first array.
+ * @param {number[]} arr2 The second array.
+ * @returns {number} The dot product of arr1 and arr2.
+ */
+export function dot(arr1: number[], arr2: number[]): number;
+/**
+ * Computes the cosine similarity between two arrays.
+ *
+ * @param {number[]} arr1 The first array.
+ * @param {number[]} arr2 The second array.
+ * @returns {number} The cosine similarity between the two arrays.
+ */
+export function cos_sim(arr1: number[], arr2: number[]): number;
+/**
+ * Calculates the magnitude of a given array.
+ * @param {number[]} arr The array to calculate the magnitude of.
+ * @returns {number} The magnitude of the array.
+ */
+export function magnitude(arr: number[]): number;
+/**
+ * Returns the value and index of the minimum element in an array.
+ * @param {number[]|TypedArray} arr array of numbers.
+ * @returns {number[]} the value and index of the minimum element, of the form: [valueOfMin, indexOfMin]
+ * @throws {Error} If array is empty.
+ */
+export function min(arr: number[] | TypedArray): number[];
+/**
+ * Returns the value and index of the maximum element in an array.
+ * @param {number[]|AnyTypedArray} arr array of numbers.
+ * @returns {[number, number]} the value and index of the maximum element, of the form: [valueOfMax, indexOfMax]
+ * @throws {Error} If array is empty.
+ */
+export function max(arr: number[] | AnyTypedArray): [number, number];
+/**
+ * Performs median filter on the provided data. Padding is done by mirroring the data.
+ * @param {AnyTypedArray} data The input array
+ * @param {number} windowSize The window size
+ */
+export function medianFilter(data: AnyTypedArray, windowSize: number): any;
+/**
+ * Helper function to round a number to a given number of decimals
+ * @param {number} num The number to round
+ * @param {number} decimals The number of decimals
+ * @returns {number} The rounded number
+ */
+export function round(num: number, decimals: number): number;
+/**
+ * Helper function to round a number to the nearest integer, with ties rounded to the nearest even number.
+ * Also known as "bankers' rounding". This is the default rounding mode in python. For example:
+ * 1.5 rounds to 2 and 2.5 rounds to 2.
+ *
+ * @param {number} x The number to round
+ * @returns {number} The rounded number
+ */
+export function bankers_round(x: number): number;
+/**
+ * Measures similarity between two temporal sequences (e.g., input audio and output tokens
+ * to generate token-level timestamps).
+ * @param {number[][]} matrix
+ * @returns {number[][]}
+ */
+export function dynamic_time_warping(matrix: number[][]): number[][];
+export class FFT {
+    constructor(fft_length: any);
+    fft_length: any;
+    isPowerOfTwo: boolean;
+    fft: P2FFT | NP2FFT;
+    outputBufferSize: number;
+    realTransform(out: any, input: any): void;
+    transform(out: any, input: any): void;
+}
+export type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array;
+export type BigTypedArray = BigInt64Array | BigUint64Array;
+export type AnyTypedArray = TypedArray | BigTypedArray;
+/**
+ * Implementation of Radix-4 FFT.
+ *
+ * P2FFT class provides functionality for performing Fast Fourier Transform on arrays
+ * which are a power of two in length.
+ * Code adapted from https://www.npmjs.com/package/fft.js
+ */
+declare class P2FFT {
+    /**
+     * @param {number} size The size of the input array. Must be a power of two larger than 1.
+     * @throws {Error} FFT size must be a power of two larger than 1.
+     */
+    constructor(size: number);
+    size: number;
+    _csize: number;
+    table: Float64Array;
+    _width: number;
+    _bitrev: Int32Array;
+    /**
+     * Create a complex number array with size `2 * size`
+     *
+     * @returns {Float64Array} A complex number array with size `2 * size`
+     */
+    createComplexArray(): Float64Array;
+    /**
+     * Converts a complex number representation stored in a Float64Array to an array of real numbers.
+     *
+     * @param {Float64Array} complex The complex number representation to be converted.
+     * @param {number[]} [storage] An optional array to store the result in.
+     * @returns {number[]} An array of real numbers representing the input complex number representation.
+     */
+    fromComplexArray(complex: Float64Array, storage?: number[]): number[];
+    /**
+     * Convert a real-valued input array to a complex-valued output array.
+     * @param {Float64Array} input The real-valued input array.
+     * @param {Float64Array} [storage] Optional buffer to store the output array.
+     * @returns {Float64Array} The complex-valued output array.
+     */
+    toComplexArray(input: Float64Array, storage?: Float64Array): Float64Array;
+    /**
+     * Performs a Fast Fourier Transform (FFT) on the given input data and stores the result in the output buffer.
+     *
+     * @param {Float64Array} out The output buffer to store the result.
+     * @param {Float64Array} data The input data to transform.
+     *
+     * @throws {Error} Input and output buffers must be different.
+     *
+     * @returns {void}
+     */
+    transform(out: Float64Array, data: Float64Array): void;
+    /**
+     * Performs a real-valued forward FFT on the given input buffer and stores the result in the given output buffer.
+     * The input buffer must contain real values only, while the output buffer will contain complex values. The input and
+     * output buffers must be different.
+     *
+     * @param {Float64Array} out The output buffer.
+     * @param {Float64Array} data The input buffer containing real values.
+     *
+     * @throws {Error} If the input and output buffers are the same.
+     */
+    realTransform(out: Float64Array, data: Float64Array): void;
+    /**
+     * Performs an inverse FFT transformation on the given `data` array, and stores the result in `out`.
+     * The `out` array must be a different buffer than the `data` array. The `out` array will contain the
+     * result of the transformation. The `data` array will not be modified.
+     *
+     * @param {Float64Array} out The output buffer for the transformed data.
+     * @param {Float64Array} data The input data to transform.
+     * @throws {Error} If `out` and `data` refer to the same buffer.
+     * @returns {void}
+     */
+    inverseTransform(out: Float64Array, data: Float64Array): void;
+    /**
+     * Performs a radix-4 implementation of a discrete Fourier transform on a given set of data.
+     *
+     * @param {Float64Array} out The output buffer for the transformed data.
+     * @param {Float64Array} data The input buffer of data to be transformed.
+     * @param {number} inv A scaling factor to apply to the transform.
+     * @returns {void}
+     */
+    _transform4(out: Float64Array, data: Float64Array, inv: number): void;
+    /**
+     * Performs a radix-2 implementation of a discrete Fourier transform on a given set of data.
+     *
+     * @param {Float64Array} data The input buffer of data to be transformed.
+     * @param {Float64Array} out The output buffer for the transformed data.
+     * @param {number} outOff The offset at which to write the output data.
+     * @param {number} off The offset at which to begin reading the input data.
+     * @param {number} step The step size for indexing the input data.
+     * @returns {void}
+     */
+    _singleTransform2(data: Float64Array, out: Float64Array, outOff: number, off: number, step: number): void;
+    /**
+     * Performs radix-4 transformation on input data of length 8
+     *
+     * @param {Float64Array} data Input data array of length 8
+     * @param {Float64Array} out Output data array of length 8
+     * @param {number} outOff Index of output array to start writing from
+     * @param {number} off Index of input array to start reading from
+     * @param {number} step Step size between elements in input array
+     * @param {number} inv Scaling factor for inverse transform
+     *
+     * @returns {void}
+     */
+    _singleTransform4(data: Float64Array, out: Float64Array, outOff: number, off: number, step: number, inv: number): void;
+    /**
+     * Real input radix-4 implementation
+     * @param {Float64Array} out Output array for the transformed data
+     * @param {Float64Array} data Input array of real data to be transformed
+     * @param {number} inv The scale factor used to normalize the inverse transform
+     */
+    _realTransform4(out: Float64Array, data: Float64Array, inv: number): void;
+    /**
+     * Performs a single real input radix-2 transformation on the provided data
+     *
+     * @param {Float64Array} data The input data array
+     * @param {Float64Array} out The output data array
+     * @param {number} outOff The output offset
+     * @param {number} off The input offset
+     * @param {number} step The step
+     *
+     * @returns {void}
+     */
+    _singleRealTransform2(data: Float64Array, out: Float64Array, outOff: number, off: number, step: number): void;
+    /**
+     * Computes a single real-valued transform using radix-4 algorithm.
+     * This method is only called for len=8.
+     *
+     * @param {Float64Array} data The input data array.
+     * @param {Float64Array} out The output data array.
+     * @param {number} outOff The offset into the output array.
+     * @param {number} off The offset into the input array.
+     * @param {number} step The step size for the input array.
+     * @param {number} inv The value of inverse.
+     */
+    _singleRealTransform4(data: Float64Array, out: Float64Array, outOff: number, off: number, step: number, inv: number): void;
+}
+/**
+ * NP2FFT class provides functionality for performing Fast Fourier Transform on arrays
+ * which are not a power of two in length. In such cases, the chirp-z transform is used.
+ *
+ * For more information, see: https://math.stackexchange.com/questions/77118/non-power-of-2-ffts/77156#77156
+ */
+declare class NP2FFT {
+    /**
+     * Constructs a new NP2FFT object.
+     * @param {number} fft_length The length of the FFT
+     */
+    constructor(fft_length: number);
+    bufferSize: number;
+    _a: number;
+    _chirpBuffer: Float64Array;
+    _buffer1: Float64Array;
+    _buffer2: Float64Array;
+    _outBuffer1: Float64Array;
+    _outBuffer2: Float64Array;
+    _slicedChirpBuffer: Float64Array;
+    _f: P2FFT;
+    _transform(output: any, input: any, real: any): void;
+    transform(output: any, input: any): void;
+    realTransform(output: any, input: any): void;
+}
+export {};
+//# sourceMappingURL=maths.d.ts.map

package/types/utils/maths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"maths.d.ts","sourceRoot":"","sources":["../../src/utils/maths.js"],"names":[],"mappings":"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"}