@huggingface/transformers 3.0.0-alpha.0

package/types/tokenizers.d.ts.map

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

package/types/transformers.d.ts

@@ -0,0 +1,13 @@
+export { env } from "./env.js";
+export * from "./pipelines.js";
+export * from "./models.js";
+export * from "./tokenizers.js";
+export * from "./processors.js";
+export * from "./configs.js";
+export * from "./utils/audio.js";
+export * from "./utils/image.js";
+export * from "./utils/tensor.js";
+export * from "./utils/maths.js";
+export * from "./generation/streamers.js";
+export * from "./generation/stopping_criteria.js";
+//# sourceMappingURL=transformers.d.ts.map

package/types/transformers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformers.d.ts","sourceRoot":"","sources":["../src/transformers.js"],"names":[],"mappings":""}

package/types/utils/audio.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Helper function to read audio from a path/URL.
+ * @param {string|URL} url The path/URL to load the audio from.
+ * @param {number} sampling_rate The sampling rate to use when decoding the audio.
+ * @returns {Promise<Float32Array>} The decoded audio as a `Float32Array`.
+ */
+export function read_audio(url: string | URL, sampling_rate: number): Promise<Float32Array>;
+/**
+ * Generates a Hanning window of length M.
+ * See https://numpy.org/doc/stable/reference/generated/numpy.hanning.html for more information.
+ *
+ * @param {number} M The length of the Hanning window to generate.
+ * @returns {Float64Array} The generated Hanning window.
+ */
+export function hanning(M: number): Float64Array;
+/**
+ * Generates a Hamming window of length M.
+ * See https://numpy.org/doc/stable/reference/generated/numpy.hamming.html for more information.
+ *
+ * @param {number} M The length of the Hamming window to generate.
+ * @returns {Float64Array} The generated Hamming window.
+ */
+export function hamming(M: number): Float64Array;
+/**
+ * Creates a frequency bin conversion matrix used to obtain a mel spectrogram. This is called a *mel filter bank*, and
+ * various implementation exist, which differ in the number of filters, the shape of the filters, the way the filters
+ * are spaced, the bandwidth of the filters, and the manner in which the spectrum is warped. The goal of these
+ * features is to approximate the non-linear human perception of the variation in pitch with respect to the frequency.
+ * @param {number} num_frequency_bins Number of frequencies used to compute the spectrogram (should be the same as in `stft`).
+ * @param {number} num_mel_filters Number of mel filters to generate.
+ * @param {number} min_frequency Lowest frequency of interest in Hz.
+ * @param {number} max_frequency Highest frequency of interest in Hz. This should not exceed `sampling_rate / 2`.
+ * @param {number} sampling_rate Sample rate of the audio waveform.
+ * @param {string} [norm] If `"slaney"`, divide the triangular mel weights by the width of the mel band (area normalization).
+ * @param {string} [mel_scale] The mel frequency scale to use, `"htk"` or `"slaney"`.
+ * @param {boolean} [triangularize_in_mel_space] If this option is enabled, the triangular filter is applied in mel space rather than frequency space.
+ * This should be set to `true` in order to get the same results as `torchaudio` when computing mel filters.
+ * @returns {number[][]} Triangular filter bank matrix, which is a 2D array of shape (`num_frequency_bins`, `num_mel_filters`).
+ * This is a projection matrix to go from a spectrogram to a mel spectrogram.
+ */
+export function mel_filter_bank(num_frequency_bins: number, num_mel_filters: number, min_frequency: number, max_frequency: number, sampling_rate: number, norm?: string, mel_scale?: string, triangularize_in_mel_space?: boolean): number[][];
+/**
+ * Calculates a spectrogram over one waveform using the Short-Time Fourier Transform.
+ *
+ * This function can create the following kinds of spectrograms:
+ *   - amplitude spectrogram (`power = 1.0`)
+ *   - power spectrogram (`power = 2.0`)
+ *   - complex-valued spectrogram (`power = None`)
+ *   - log spectrogram (use `log_mel` argument)
+ *   - mel spectrogram (provide `mel_filters`)
+ *   - log-mel spectrogram (provide `mel_filters` and `log_mel`)
+ *
+ * In this implementation, the window is assumed to be zero-padded to have the same size as the analysis frame.
+ * A padded window can be obtained from `window_function()`. The FFT input buffer may be larger than the analysis frame,
+ * typically the next power of two.
+ *
+ * @param {Float32Array|Float64Array} waveform The input waveform of shape `(length,)`. This must be a single real-valued, mono waveform.
+ * @param {Float32Array|Float64Array} window The windowing function to apply of shape `(frame_length,)`, including zero-padding if necessary. The actual window length may be
+ * shorter than `frame_length`, but we're assuming the array has already been zero-padded.
+ * @param {number} frame_length The length of the analysis frames in samples (a.k.a., `fft_length`).
+ * @param {number} hop_length The stride between successive analysis frames in samples.
+ * @param {Object} options
+ * @param {number} [options.fft_length=null] The size of the FFT buffer in samples. This determines how many frequency bins the spectrogram will have.
+ * For optimal speed, this should be a power of two. If `null`, uses `frame_length`.
+ * @param {number} [options.power=1.0] If 1.0, returns the amplitude spectrogram. If 2.0, returns the power spectrogram. If `null`, returns complex numbers.
+ * @param {boolean} [options.center=true] Whether to pad the waveform so that frame `t` is centered around time `t * hop_length`. If `false`, frame
+ * `t` will start at time `t * hop_length`.
+ * @param {string} [options.pad_mode="reflect"] Padding mode used when `center` is `true`. Possible values are: `"constant"` (pad with zeros),
+ * `"edge"` (pad with edge values), `"reflect"` (pads with mirrored values).
+ * @param {boolean} [options.onesided=true] If `true`, only computes the positive frequencies and returns a spectrogram containing `fft_length // 2 + 1`
+ * frequency bins. If `false`, also computes the negative frequencies and returns `fft_length` frequency bins.
+ * @param {number} [options.preemphasis=null] Coefficient for a low-pass filter that applies pre-emphasis before the DFT.
+ * @param {number[][]} [options.mel_filters=null] The mel filter bank of shape `(num_freq_bins, num_mel_filters)`.
+ * If supplied, applies this filter bank to create a mel spectrogram.
+ * @param {number} [options.mel_floor=1e-10] Minimum value of mel frequency banks.
+ * @param {string} [options.log_mel=null] How to convert the spectrogram to log scale. Possible options are:
+ * `null` (don't convert), `"log"` (take the natural logarithm) `"log10"` (take the base-10 logarithm), `"dB"` (convert to decibels).
+ * Can only be used when `power` is not `null`.
+ * @param {number} [options.reference=1.0] Sets the input spectrogram value that corresponds to 0 dB. For example, use `max(spectrogram)[0]` to set
+ * the loudest part to 0 dB. Must be greater than zero.
+ * @param {number} [options.min_value=1e-10] The spectrogram will be clipped to this minimum value before conversion to decibels, to avoid taking `log(0)`.
+ * For a power spectrogram, the default of `1e-10` corresponds to a minimum of -100 dB. For an amplitude spectrogram, the value `1e-5` corresponds to -100 dB.
+ * Must be greater than zero.
+ * @param {number} [options.db_range=null] Sets the maximum dynamic range in decibels. For example, if `db_range = 80`, the difference between the
+ * peak value and the smallest value will never be more than 80 dB. Must be greater than zero.
+ * @param {boolean} [options.remove_dc_offset=null] Subtract mean from waveform on each frame, applied before pre-emphasis. This should be set to `true` in
+ * order to get the same results as `torchaudio.compliance.kaldi.fbank` when computing mel filters.
+ * @param {number} [options.max_num_frames=null] If provided, limits the number of frames to compute to this value.
+ * @param {number} [options.min_num_frames=null] If provided, ensures the number of frames to compute is at least this value.
+ * @param {boolean} [options.do_pad=true] If `true`, pads the output spectrogram to have `max_num_frames` frames.
+ * @param {boolean} [options.transpose=false] If `true`, the returned spectrogram will have shape `(num_frames, num_frequency_bins/num_mel_filters)`. If `false`, the returned spectrogram will have shape `(num_frequency_bins/num_mel_filters, num_frames)`.
+ * @returns {Promise<Tensor>} Spectrogram of shape `(num_frequency_bins, length)` (regular spectrogram) or shape `(num_mel_filters, length)` (mel spectrogram).
+ */
+export function spectrogram(waveform: Float32Array | Float64Array, window: Float32Array | Float64Array, frame_length: number, hop_length: number, { fft_length, power, center, pad_mode, onesided, preemphasis, mel_filters, mel_floor, log_mel, reference, min_value, db_range, remove_dc_offset, min_num_frames, max_num_frames, do_pad, transpose, }?: {
+    fft_length?: number;
+    power?: number;
+    center?: boolean;
+    pad_mode?: string;
+    onesided?: boolean;
+    preemphasis?: number;
+    mel_filters?: number[][];
+    mel_floor?: number;
+    log_mel?: string;
+    reference?: number;
+    min_value?: number;
+    db_range?: number;
+    remove_dc_offset?: boolean;
+    max_num_frames?: number;
+    min_num_frames?: number;
+    do_pad?: boolean;
+    transpose?: boolean;
+}): Promise<Tensor>;
+/**
+ * Returns an array containing the specified window.
+ * @param {number} window_length The length of the window in samples.
+ * @param {string} name The name of the window function.
+ * @param {Object} options Additional options.
+ * @param {boolean} [options.periodic=true] Whether the window is periodic or symmetric.
+ * @param {number} [options.frame_length=null] The length of the analysis frames in samples.
+ * Provide a value for `frame_length` if the window is smaller than the frame length, so that it will be zero-padded.
+ * @param {boolean} [options.center=true] Whether to center the window inside the FFT buffer. Only used when `frame_length` is provided.
+ * @returns {Float64Array} The window of shape `(window_length,)` or `(frame_length,)`.
+ */
+export function window_function(window_length: number, name: string, { periodic, frame_length, center, }?: {
+    periodic?: boolean;
+    frame_length?: number;
+    center?: boolean;
+}): Float64Array;
+import { Tensor } from './tensor.js';
+//# sourceMappingURL=audio.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"audio.d.ts","sourceRoot":"","sources":["../../src/utils/audio.js"],"names":[],"mappings":"AAmBA;;;;;GAKG;AACH,gCAJW,MAAM,GAAC,GAAG,iBACV,MAAM,GACJ,QAAQ,YAAY,CAAC,CAuDjC;AA2BD;;;;;;GAMG;AACH,2BAHW,MAAM,GACJ,YAAY,CAIxB;AAGD;;;;;;GAMG;AACH,2BAHW,MAAM,GACJ,YAAY,CAIxB;AAsGD;;;;;;;;;;;;;;;;GAgBG;AACH,oDAZW,MAAM,mBACN,MAAM,iBACN,MAAM,iBACN,MAAM,iBACN,MAAM,SACN,MAAM,cACN,MAAM,+BACN,OAAO,GAEL,MAAM,EAAE,EAAE,CAkDtB;AAqHD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,sCArCW,YAAY,GAAC,YAAY,UACzB,YAAY,GAAC,YAAY,gBAEzB,MAAM,cACN,MAAM;IAEW,UAAU,GAA3B,MAAM;IAEW,KAAK,GAAtB,MAAM;IACY,MAAM,GAAxB,OAAO;IAEU,QAAQ,GAAzB,MAAM;IAEY,QAAQ,GAA1B,OAAO;IAEU,WAAW,GAA5B,MAAM;IACe,WAAW,GAAhC,MAAM,EAAE,EAAE;IAEO,SAAS,GAA1B,MAAM;IACW,OAAO,GAAxB,MAAM;IAGW,SAAS,GAA1B,MAAM;IAEW,SAAS,GAA1B,MAAM;IAGW,QAAQ,GAAzB,MAAM;IAEY,gBAAgB,GAAlC,OAAO;IAEU,cAAc,GAA/B,MAAM;IACW,cAAc,GAA/B,MAAM;IACY,MAAM,GAAxB,OAAO;IACW,SAAS,GAA3B,OAAO;IACL,QAAQ,MAAM,CAAC,CAoM3B;AAED;;;;;;;;;;GAUG;AACH,+CATW,MAAM,QACN,MAAM;IAEY,QAAQ,GAA1B,OAAO;IACU,YAAY,GAA7B,MAAM;IAEY,MAAM,GAAxB,OAAO;IACL,YAAY,CAqCxB;uBA/qB8B,aAAa"}

package/types/utils/constants.d.ts

@@ -0,0 +1,2 @@
+export const GITHUB_ISSUE_URL: "https://github.com/xenova/transformers.js/issues/new/choose";
+//# sourceMappingURL=constants.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/utils/constants.js"],"names":[],"mappings":"AACA,6FAA8F"}

package/types/utils/core.d.ts

@@ -0,0 +1,91 @@
+/**
+ * @file Core utility functions/classes for Transformers.js.
+ *
+ * These are only used internally, meaning an end-user shouldn't
+ * need to access anything here.
+ *
+ * @module utils/core
+ */
+/**
+ * Helper function to dispatch progress callbacks.
+ *
+ * @param {Function} progress_callback The progress callback function to dispatch.
+ * @param {any} data The data to pass to the progress callback function.
+ * @returns {void}
+ * @private
+ */
+export function dispatchCallback(progress_callback: Function, data: any): void;
+/**
+ * Reverses the keys and values of an object.
+ *
+ * @param {Object} data The object to reverse.
+ * @returns {Object} The reversed object.
+ * @see https://ultimatecourses.com/blog/reverse-object-keys-and-values-in-javascript
+ */
+export function reverseDictionary(data: any): any;
+/**
+ * Escapes regular expression special characters from a string by replacing them with their escaped counterparts.
+ *
+ * @param {string} string The string to escape.
+ * @returns {string} The escaped string.
+ */
+export function escapeRegExp(string: string): string;
+/**
+ * Check if a value is a typed array.
+ * @param {*} val The value to check.
+ * @returns {boolean} True if the value is a `TypedArray`, false otherwise.
+ *
+ * Adapted from https://stackoverflow.com/a/71091338/13989043
+ */
+export function isTypedArray(val: any): boolean;
+/**
+ * Check if a value is an integer.
+ * @param {*} x The value to check.
+ * @returns {boolean} True if the value is a string, false otherwise.
+ */
+export function isIntegralNumber(x: any): boolean;
+/**
+ * Calculates the dimensions of a nested array.
+ *
+ * @param {any[]} arr The nested array to calculate dimensions for.
+ * @returns {number[]} An array containing the dimensions of the input array.
+ */
+export function calculateDimensions(arr: any[]): number[];
+/**
+ * Replicate python's .pop() method for objects.
+ * @param {Object} obj The object to pop from.
+ * @param {string} key The key to pop.
+ * @param {*} defaultValue The default value to return if the key does not exist.
+ * @returns {*} The value of the popped key.
+ * @throws {Error} If the key does not exist and no default value is provided.
+ */
+export function pop(obj: any, key: string, defaultValue?: any): any;
+/**
+ * Efficiently merge arrays, creating a new copy.
+ * Adapted from https://stackoverflow.com/a/6768642/13989043
+ * @param  {Array[]} arrs Arrays to merge.
+ * @returns {Array} The merged array.
+ */
+export function mergeArrays(...arrs: any[][]): any[];
+/**
+ * Compute the Cartesian product of given arrays
+ * @param {...Array} a Arrays to compute the product
+ * @returns {Array} Returns the computed Cartesian product as an array
+ * @private
+ */
+export function product(...a: any[][]): any[];
+/**
+ * Calculates the index offset for a given index and window size.
+ * @param {number} i The index.
+ * @param {number} w The window size.
+ * @returns {number} The index offset.
+ */
+export function calculateReflectOffset(i: number, w: number): number;
+/**
+ *
+ * @param {Object} o
+ * @param {string[]} props
+ * @returns {Object}
+ */
+export function pick(o: any, props: string[]): any;
+//# sourceMappingURL=core.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../src/utils/core.js"],"names":[],"mappings":"AACA;;;;;;;GAOG;AAEH;;;;;;;GAOG;AACH,oEAJW,GAAG,GACD,IAAI,CAKhB;AAED;;;;;;GAMG;AACH,kDAGC;AAED;;;;;GAKG;AACH,qCAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;GAMG;AACH,wCAJa,OAAO,CAMnB;AAGD;;;;GAIG;AACH,0CAFa,OAAO,CAInB;AAED;;;;;GAKG;AACH,yCAHW,GAAG,EAAE,GACH,MAAM,EAAE,CAUpB;AAED;;;;;;;GAOG;AACH,mCALW,MAAM,2BAehB;AAED;;;;;GAKG;AACH,qCAHY,OAAO,SAKlB;AAED;;;;;GAKG;AACH,8CAIC;AAED;;;;;GAKG;AACH,0CAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,EAAE,OAYlB"}

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

@@ -0,0 +1,236 @@
+/**
+ * @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);
+    sentence: 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 array of nodes representing 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 {Array} The array of nodes representing the most likely sequence of tokens.
+     */
+    tokens(): any[];
+    /**
+     * @returns {Array} The array of nodes representing the most likely sequence of tokens.
+     */
+    tokenIds(): any[];
+}
+/**
+ * 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/types/utils/data-structures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-structures.d.ts","sourceRoot":"","sources":["../../src/utils/data-structures.js"],"names":[],"mappings":"AACA;;;;;;;GAOG;AAGH;;;;;;;;GAQG;AACH;IAEI;;;OAGG;IACH,gCAFoB,GAAG,QAAE,GAAG,KAAG,OAAO,oBAMrC;IAHG,aAAe;IACf,oBAJgB,GAAG,QAAE,GAAG,KAAG,OAAO,CAIL;IAC7B,iBAAuB;IAG3B;;OAEG;IACH,mBAEC;IAED;;;OAGG;IACH,WAFa,OAAO,CAInB;IAED;;;OAGG;IACH,QAFa,GAAG,CAIf;IAED;;;;OAIG;IACH,gBAHe,GAAG,KACL,MAAM,CAIlB;IAED;;;;OAIG;IACH,eAHW,GAAG,EAAE,GACH,MAAM,CAoBlB;IAED;;;OAGG;IACH,OAFa,GAAG,CAWf;IAED;;;;OAIG;IACH,yBAKC;IAED;;;;;OAKG;IACH,gBAEC;IAED;;;;;OAKG;IACH,cAEC;IAED;;;;;OAKG;IACH,eAEC;IAED;;;;;;OAMG;IACH,iBAEC;IAED;;;;;OAKG;IACH,cAIC;IAED;;;;OAIG;IACH,gBAEC;IAED;;;OAGG;IACH,kBAFW,MAAM,QAOhB;IAED;;;;OAIG;IACH,kBAYC;IAED;;;;OAIG;IACH,kBAEC;CACJ;AAED;;GAEG;AACH;IAEQ,mBAAkC;IAGtC;;;OAGG;IACH,cAFW,MAAM,EAAE,QAMlB;IAED;;;OAGG;IACH,WAFW,MAAM,QAahB;IAED;;;;OAIG;IACH,yBAHW,MAAM,oCAchB;CACJ;AAyBD;;GAEG;AACH;IACI;;;;;;OAMG;IACH,sBAJW,MAAM,cACN,MAAM,cACN,MAAM,EAiBhB;IAdG,iBAAwB;IACxB,YAA0B;IAC1B,mBAA4B;IAC5B,mBAA4B;IAC5B,0BAAe;IACf,oBAAgE;IAChE,kBAA8D;IAUlE;;;;;;;OAOG;IACH,YALW,MAAM,UACN,MAAM,SACN,MAAM,WACN,MAAM,QAQhB;IAED;;;;OAIG;IACH,WAFa,gBAAgB,EAAE,CA+C9B;IAED;;;OAGG;IACH,YAHW,gBAAgB,GACd,MAAM,CAIlB;IAED;;OAEG;IACH,gBAGC;IAED;;OAEG;IACH,kBAGC;CACJ;AA9ID;;GAEG;AACH;IAWI;;;OAGG;IACH,kBAFa,YAAY,CAIxB;IAhBD;;;;OAIG;IACH,oBAHW,OAAO,YACP,IAAI,MAAM,EAAE,YAAY,CAAC,EAKnC;IAFG,gBAAoB;IACpB,oCAAwB;CAU/B;AA0HD;IACI;;;;;;;OAOG;IACH,qBANW,MAAM,UACN,MAAM,OACN,MAAM,UACN,MAAM,SACN,MAAM,EAUhB;IAPG,gBAAsB;IACtB,eAAoB;IACpB,YAAc;IACd,eAAoB;IACpB,cAAkB;IAClB,UAAgB;IAChB,uBAAyB;IAG7B;;;OAGG;IACH,SAFa,gBAAgB,CAO5B;CACJ"}

package/types/utils/devices.d.ts

@@ -0,0 +1,8 @@
+export const DEVICE_TYPES: Readonly<{
+    cpu: "cpu";
+    gpu: "gpu";
+    wasm: "wasm";
+    webgpu: "webgpu";
+}>;
+export type DeviceType = keyof typeof DEVICE_TYPES;
+//# sourceMappingURL=devices.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"devices.d.ts","sourceRoot":"","sources":["../../src/utils/devices.js"],"names":[],"mappings":"AACA;;;;;GAKG;yBAGU,MAAM,mBAAmB"}

package/types/utils/dtypes.d.ts

@@ -0,0 +1,22 @@
+export function isWebGpuFp16Supported(): Promise<boolean>;
+export const DATA_TYPES: Readonly<{
+    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<{
+    cpu: "q8";
+    gpu: "fp32";
+    wasm: "q8";
+    webgpu: "fp32";
+}>;
+/** @type {Record<DataType, string>} */
+export const DEFAULT_DTYPE_SUFFIX_MAPPING: Record<DataType, string>;
+export type DataType = keyof typeof DATA_TYPES;
+//# sourceMappingURL=dtypes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dtypes.d.ts","sourceRoot":"","sources":["../../src/utils/dtypes.js"],"names":[],"mappings":"AAeW,0DAcN;AAGL;;;;;;;;;GASG;AACH,kDAAkD;AAElD;;;;;GAKG;AAEH,uCAAuC;AACvC,2CADW,OAAO,QAAQ,EAAE,MAAM,CAAC,CAUhC;uBAnBW,MAAM,iBAAiB"}

package/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/types/utils/generic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generic.d.ts","sourceRoot":"","sources":["../../src/utils/generic.js"],"names":[],"mappings":"AACA;;;;;GAKG;AACH;cAF+B,GAAG,EAAE,GAAG,GAAG;mBAAiB,GAAG,EAAE,GAAG,GAAG;EA6BnE"}