@huggingface/transformers 3.0.1 → 3.1.0

package/types/base/image_processors_utils.d.ts

@@ -0,0 +1,323 @@
+/**
+ * Post-processes the outputs of the model (for object detection).
+ * @param {Object} outputs The outputs of the model that must be post-processed
+ * @param {Tensor} outputs.logits The logits
+ * @param {Tensor} outputs.pred_boxes The predicted boxes.
+ * @param {number} [threshold=0.5] The threshold to use for the scores.
+ * @param {[number, number][]} [target_sizes=null] The sizes of the original images.
+ * @param {boolean} [is_zero_shot=false] Whether zero-shot object detection was performed.
+ * @return {Object[]} An array of objects containing the post-processed outputs.
+ */
+export function post_process_object_detection(outputs: {
+    logits: Tensor;
+    pred_boxes: Tensor;
+}, threshold?: number, target_sizes?: [number, number][], is_zero_shot?: boolean): any[];
+/**
+ * Post-processes the outputs of the model (for semantic segmentation).
+ * @param {*} outputs Raw outputs of the model.
+ * @param {[number, number][]} [target_sizes=null] List of tuples corresponding to the requested final size
+ * (height, width) of each prediction. If unset, predictions will not be resized.
+ * @returns {{segmentation: Tensor; labels: number[]}[]} The semantic segmentation maps.
+ */
+export function post_process_semantic_segmentation(outputs: any, target_sizes?: [number, number][]): {
+    segmentation: Tensor;
+    labels: number[];
+}[];
+/**
+ * Post-process the model output to generate the final panoptic segmentation.
+ * @param {*} outputs The model output to post process
+ * @param {number} [threshold=0.5] The probability score threshold to keep predicted instance masks.
+ * @param {number} [mask_threshold=0.5] Threshold to use when turning the predicted masks into binary values.
+ * @param {number} [overlap_mask_area_threshold=0.8] The overlap mask area threshold to merge or discard small disconnected parts within each binary instance mask.
+ * @param {Set<number>} [label_ids_to_fuse=null] The labels in this state will have all their instances be fused together.
+ * @param {[number, number][]} [target_sizes=null] The target sizes to resize the masks to.
+ * @returns {Array<{ segmentation: Tensor, segments_info: Array<{id: number, label_id: number, score: number}>}>}
+ */
+export function post_process_panoptic_segmentation(outputs: any, threshold?: number, mask_threshold?: number, overlap_mask_area_threshold?: number, label_ids_to_fuse?: Set<number>, target_sizes?: [number, number][]): Array<{
+    segmentation: Tensor;
+    segments_info: Array<{
+        id: number;
+        label_id: number;
+        score: number;
+    }>;
+}>;
+/**
+ * Post-processes the outputs of the model (for instance segmentation).
+ * @param {*} outputs Raw outputs of the model.
+ * @param {number} [threshold=0.5] The probability score threshold to keep predicted instance masks.
+ * @param {[number, number][]} [target_sizes=null] List of tuples corresponding to the requested final size
+ * (height, width) of each prediction. If unset, predictions will not be resized.
+ * @returns {Array<{ segmentation: Tensor, segments_info: Array<{id: number, label_id: number, score: number}>}>}
+ */
+export function post_process_instance_segmentation(outputs: any, threshold?: number, target_sizes?: [number, number][]): Array<{
+    segmentation: Tensor;
+    segments_info: Array<{
+        id: number;
+        label_id: number;
+        score: number;
+    }>;
+}>;
+declare const ImageProcessor_base: new () => {
+    (...args: any[]): any;
+    _call(...args: any[]): any;
+};
+/**
+ * @typedef {Object} ImageProcessorConfig A configuration object used to create an image processor.
+ * @property {function} [progress_callback=null] If specified, this function will be called during model construction, to provide the user with progress updates.
+ * @property {number[]} [image_mean] The mean values for image normalization.
+ * @property {number[]} [image_std] The standard deviation values for image normalization.
+ * @property {boolean} [do_rescale] Whether to rescale the image pixel values to the [0,1] range.
+ * @property {number} [rescale_factor] The factor to use for rescaling the image pixel values.
+ * @property {boolean} [do_normalize] Whether to normalize the image pixel values.
+ * @property {boolean} [do_resize] Whether to resize the image.
+ * @property {number} [resample] What method to use for resampling.
+ * @property {number|Object} [size] The size to resize the image to.
+ * @property {number|Object} [image_size] The size to resize the image to (same as `size`).
+ * @property {boolean} [do_flip_channel_order=false] Whether to flip the color channels from RGB to BGR.
+ * Can be overridden by the `do_flip_channel_order` parameter in the `preprocess` method.
+ * @property {boolean} [do_center_crop] Whether to center crop the image to the specified `crop_size`.
+ * Can be overridden by `do_center_crop` in the `preprocess` method.
+ * @property {boolean} [do_thumbnail] Whether to resize the image using thumbnail method.
+ * @property {boolean} [keep_aspect_ratio] If `true`, the image is resized to the largest possible size such that the aspect ratio is preserved.
+ * Can be overidden by `keep_aspect_ratio` in `preprocess`.
+ * @property {number} [ensure_multiple_of] If `do_resize` is `true`, the image is resized to a size that is a multiple of this value.
+ * Can be overidden by `ensure_multiple_of` in `preprocess`.
+ *
+ * @property {number[]} [mean] The mean values for image normalization (same as `image_mean`).
+ * @property {number[]} [std] The standard deviation values for image normalization (same as `image_std`).
+ */
+export class ImageProcessor extends ImageProcessor_base {
+    /**
+     * Instantiate one of the processor classes of the library from a pretrained model.
+     *
+     * The processor class to instantiate is selected based on the `image_processor_type` (or `feature_extractor_type`; legacy)
+     * property of the config object (either passed as an argument or loaded from `pretrained_model_name_or_path` if possible)
+     *
+     * @param {string} pretrained_model_name_or_path The name or path of the pretrained model. Can be either:
+     * - A string, the *model id* of a pretrained processor hosted inside a model repo on huggingface.co.
+     *   Valid model ids can be located at the root-level, like `bert-base-uncased`, or namespaced under a
+     *   user or organization name, like `dbmdz/bert-base-german-cased`.
+     * - A path to a *directory* containing processor files, e.g., `./my_model_directory/`.
+     * @param {import('../utils/hub.js').PretrainedOptions} options Additional options for loading the processor.
+     *
+     * @returns {Promise<ImageProcessor>} A new instance of the Processor class.
+     */
+    static from_pretrained(pretrained_model_name_or_path: string, options: import('../utils/hub.js').PretrainedOptions): Promise<ImageProcessor>;
+    /**
+     * Constructs a new `ImageProcessor`.
+     * @param {ImageProcessorConfig} config The configuration object.
+     */
+    constructor(config: ImageProcessorConfig);
+    image_mean: number[];
+    image_std: number[];
+    resample: number;
+    do_rescale: boolean;
+    rescale_factor: number;
+    do_normalize: boolean;
+    do_thumbnail: boolean;
+    size: any;
+    do_resize: boolean;
+    size_divisibility: any;
+    do_center_crop: boolean;
+    crop_size: any;
+    do_convert_rgb: any;
+    do_crop_margin: any;
+    pad_size: any;
+    do_pad: any;
+    do_flip_channel_order: boolean;
+    config: ImageProcessorConfig;
+    /**
+     * Resize the image to make a thumbnail. The image is resized so that no dimension is larger than any
+     * corresponding dimension of the specified size.
+     * @param {RawImage} image The image to be resized.
+     * @param {{height:number, width:number}} size The size `{"height": h, "width": w}` to resize the image to.
+     * @param {string | 0 | 1 | 2 | 3 | 4 | 5} [resample=2] The resampling filter to use.
+     * @returns {Promise<RawImage>} The resized image.
+     */
+    thumbnail(image: RawImage, size: {
+        height: number;
+        width: number;
+    }, resample?: string | 0 | 1 | 2 | 3 | 4 | 5): Promise<RawImage>;
+    /**
+     * Crops the margin of the image. Gray pixels are considered margin (i.e., pixels with a value below the threshold).
+     * @param {RawImage} image The image to be cropped.
+     * @param {number} gray_threshold Value below which pixels are considered to be gray.
+     * @returns {Promise<RawImage>} The cropped image.
+     */
+    crop_margin(image: RawImage, gray_threshold?: number): Promise<RawImage>;
+    /**
+     * Pad the image by a certain amount.
+     * @param {Float32Array} pixelData The pixel data to pad.
+     * @param {number[]} imgDims The dimensions of the image (height, width, channels).
+     * @param {{width:number; height:number}|number} padSize The dimensions of the padded image.
+     * @param {Object} options The options for padding.
+     * @param {'constant'|'symmetric'} [options.mode='constant'] The type of padding to add.
+     * @param {boolean} [options.center=false] Whether to center the image.
+     * @param {number|number[]} [options.constant_values=0] The constant value to use for padding.
+     * @returns {[Float32Array, number[]]} The padded pixel data and image dimensions.
+     */
+    pad_image(pixelData: Float32Array, imgDims: number[], padSize: {
+        width: number;
+        height: number;
+    } | number, { mode, center, constant_values, }?: {
+        mode?: 'constant' | 'symmetric';
+        center?: boolean;
+        constant_values?: number | number[];
+    }): [Float32Array, number[]];
+    /**
+     * Rescale the image' pixel values by `this.rescale_factor`.
+     * @param {Float32Array} pixelData The pixel data to rescale.
+     * @returns {void}
+     */
+    rescale(pixelData: Float32Array): void;
+    /**
+     * Find the target (width, height) dimension of the output image after
+     * resizing given the input image and the desired size.
+     * @param {RawImage} image The image to resize.
+     * @param {any} size The size to use for resizing the image.
+     * @returns {[number, number]} The target (width, height) dimension of the output image after resizing.
+     */
+    get_resize_output_image_size(image: RawImage, size: any): [number, number];
+    /**
+     * Resizes the image.
+     * @param {RawImage} image The image to resize.
+     * @returns {Promise<RawImage>} The resized image.
+     */
+    resize(image: RawImage): Promise<RawImage>;
+    /**
+     * @typedef {object} PreprocessedImage
+     * @property {HeightWidth} original_size The original size of the image.
+     * @property {HeightWidth} reshaped_input_size The reshaped input size of the image.
+     * @property {Tensor} pixel_values The pixel values of the preprocessed image.
+     */
+    /**
+     * Preprocesses the given image.
+     *
+     * @param {RawImage} image The image to preprocess.
+     * @param {Object} overrides The overrides for the preprocessing options.
+     * @returns {Promise<PreprocessedImage>} The preprocessed image.
+     */
+    preprocess(image: RawImage, { do_normalize, do_pad, do_convert_rgb, do_convert_grayscale, do_flip_channel_order, }?: any): Promise<{
+        /**
+         * The original size of the image.
+         */
+        original_size: HeightWidth;
+        /**
+         * The reshaped input size of the image.
+         */
+        reshaped_input_size: HeightWidth;
+        /**
+         * The pixel values of the preprocessed image.
+         */
+        pixel_values: Tensor;
+    }>;
+    /**
+     * Calls the feature extraction process on an array of images,
+     * preprocesses each image, and concatenates the resulting
+     * features into a single Tensor.
+     * @param {RawImage[]} images The image(s) to extract features from.
+     * @param {...any} args Additional arguments.
+     * @returns {Promise<ImageProcessorResult>} An object containing the concatenated pixel values (and other metadata) of the preprocessed images.
+     */
+    _call(images: RawImage[], ...args: any[]): Promise<ImageProcessorResult>;
+}
+/**
+ * Named tuple to indicate the order we are using is (height x width),
+ * even though the Graphics' industry standard is (width x height).
+ */
+export type HeightWidth = [height: number, width: number];
+export type ImageProcessorResult = {
+    /**
+     * The pixel values of the batched preprocessed images.
+     */
+    pixel_values: Tensor;
+    /**
+     * Array of two-dimensional tuples like [[480, 640]].
+     */
+    original_sizes: HeightWidth[];
+    /**
+     * Array of two-dimensional tuples like [[1000, 1330]].
+     */
+    reshaped_input_sizes: HeightWidth[];
+};
+/**
+ * A configuration object used to create an image processor.
+ */
+export type ImageProcessorConfig = {
+    /**
+     * If specified, this function will be called during model construction, to provide the user with progress updates.
+     */
+    progress_callback?: Function;
+    /**
+     * The mean values for image normalization.
+     */
+    image_mean?: number[];
+    /**
+     * The standard deviation values for image normalization.
+     */
+    image_std?: number[];
+    /**
+     * Whether to rescale the image pixel values to the [0,1] range.
+     */
+    do_rescale?: boolean;
+    /**
+     * The factor to use for rescaling the image pixel values.
+     */
+    rescale_factor?: number;
+    /**
+     * Whether to normalize the image pixel values.
+     */
+    do_normalize?: boolean;
+    /**
+     * Whether to resize the image.
+     */
+    do_resize?: boolean;
+    /**
+     * What method to use for resampling.
+     */
+    resample?: number;
+    /**
+     * The size to resize the image to.
+     */
+    size?: number | any;
+    /**
+     * The size to resize the image to (same as `size`).
+     */
+    image_size?: number | any;
+    /**
+     * Whether to flip the color channels from RGB to BGR.
+     * Can be overridden by the `do_flip_channel_order` parameter in the `preprocess` method.
+     */
+    do_flip_channel_order?: boolean;
+    /**
+     * Whether to center crop the image to the specified `crop_size`.
+     * Can be overridden by `do_center_crop` in the `preprocess` method.
+     */
+    do_center_crop?: boolean;
+    /**
+     * Whether to resize the image using thumbnail method.
+     */
+    do_thumbnail?: boolean;
+    /**
+     * If `true`, the image is resized to the largest possible size such that the aspect ratio is preserved.
+     * Can be overidden by `keep_aspect_ratio` in `preprocess`.
+     */
+    keep_aspect_ratio?: boolean;
+    /**
+     * If `do_resize` is `true`, the image is resized to a size that is a multiple of this value.
+     * Can be overidden by `ensure_multiple_of` in `preprocess`.
+     */
+    ensure_multiple_of?: number;
+    /**
+     * The mean values for image normalization (same as `image_mean`).
+     */
+    mean?: number[];
+    /**
+     * The standard deviation values for image normalization (same as `image_std`).
+     */
+    std?: number[];
+};
+import { Tensor } from "../utils/tensor.js";
+import { RawImage } from "../utils/image.js";
+export {};
+//# sourceMappingURL=image_processors_utils.d.ts.map

package/types/base/image_processors_utils.d.ts.map

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

package/types/base/processing_utils.d.ts

@@ -0,0 +1,80 @@
+declare const Processor_base: new () => {
+    (...args: any[]): any;
+    _call(...args: any[]): any;
+};
+/**
+ * @typedef {Object} ProcessorProperties Additional processor-specific properties.
+ * @typedef {import('../utils/hub.js').PretrainedOptions & ProcessorProperties} PretrainedProcessorOptions
+ */
+/**
+ * Represents a Processor that extracts features from an input.
+ */
+export class Processor extends Processor_base {
+    static classes: string[];
+    static uses_processor_config: boolean;
+    /**
+     * Instantiate one of the processor classes of the library from a pretrained model.
+     *
+     * The processor class to instantiate is selected based on the `feature_extractor_type` property of the config object
+     * (either passed as an argument or loaded from `pretrained_model_name_or_path` if possible)
+     *
+     * @param {string} pretrained_model_name_or_path The name or path of the pretrained model. Can be either:
+     * - A string, the *model id* of a pretrained processor hosted inside a model repo on huggingface.co.
+     *   Valid model ids can be located at the root-level, like `bert-base-uncased`, or namespaced under a
+     *   user or organization name, like `dbmdz/bert-base-german-cased`.
+     * - A path to a *directory* containing processor files, e.g., `./my_model_directory/`.
+     * @param {PretrainedProcessorOptions} options Additional options for loading the processor.
+     *
+     * @returns {Promise<Processor>} A new instance of the Processor class.
+     */
+    static from_pretrained(pretrained_model_name_or_path: string, options: PretrainedProcessorOptions): Promise<Processor>;
+    /**
+     * Creates a new Processor with the given components
+     * @param {Object} config
+     * @param {Record<string, Object>} components
+     */
+    constructor(config: any, components: Record<string, any>);
+    config: any;
+    components: Record<string, any>;
+    /**
+     * @returns {import('./image_processors_utils.js').ImageProcessor|undefined} The image processor of the processor, if it exists.
+     */
+    get image_processor(): import("./image_processors_utils.js").ImageProcessor;
+    /**
+     * @returns {import('../tokenizers.js').PreTrainedTokenizer|undefined} The tokenizer of the processor, if it exists.
+     */
+    get tokenizer(): import("../tokenizers.js").PreTrainedTokenizer;
+    /**
+     * @returns {import('./feature_extraction_utils.js').FeatureExtractor|undefined} The feature extractor of the processor, if it exists.
+     */
+    get feature_extractor(): import("./feature_extraction_utils.js").FeatureExtractor;
+    apply_chat_template(messages: any, options?: {}): string | number[] | number[][] | import("../transformers.js").Tensor | {
+        /**
+         * List of token ids to be fed to a model.
+         */
+        input_ids: number[] | number[][] | import("../transformers.js").Tensor;
+        /**
+         * List of indices specifying which tokens should be attended to by the model.
+         */
+        attention_mask: number[] | number[][] | import("../transformers.js").Tensor;
+        /**
+         * List of token type ids to be fed to a model.
+         */
+        token_type_ids?: number[] | number[][] | import("../transformers.js").Tensor;
+    };
+    batch_decode(...args: any[]): string[];
+    /**
+     * Calls the feature_extractor function with the given input.
+     * @param {any} input The input to extract features from.
+     * @param {...any} args Additional arguments.
+     * @returns {Promise<any>} A Promise that resolves with the extracted features.
+     */
+    _call(input: any, ...args: any[]): Promise<any>;
+}
+/**
+ * Additional processor-specific properties.
+ */
+export type ProcessorProperties = any;
+export type PretrainedProcessorOptions = import('../utils/hub.js').PretrainedOptions & ProcessorProperties;
+export {};
+//# sourceMappingURL=processing_utils.d.ts.map

package/types/base/processing_utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"processing_utils.d.ts","sourceRoot":"","sources":["../../src/base/processing_utils.js"],"names":[],"mappings":";;;;AA2BA;;;GAGG;AAGH;;GAEG;AACH;IACI,yBAIC;IACD,sCAAqC;IAoErC;;;;;;;;;;;;;;OAcG;IACH,sDATW,MAAM,WAKN,0BAA0B,GAExB,QAAQ,SAAS,CAAC,CAoB9B;IAnGD;;;;OAIG;IACH,qCAFW,OAAO,MAAM,MAAS,EAMhC;IAFG,YAAoB;IACpB,gCAA4B;IAGhC;;OAEG;IACH,4EAEC;IAED;;OAEG;IACH,gEAEC;IAED;;OAEG;IACH,kFAEC;IAED;;;;;;;;;;;;;MAQC;IAED,uCAKC;IAGD;;;;;OAKG;IACH,aAJW,GAAG,WACA,GAAG,KACJ,QAAQ,GAAG,CAAC,CASxB;CAqCJ;;;;;yCAnHY,OAAO,iBAAiB,EAAE,iBAAiB,GAAG,mBAAmB"}

package/types/configs.d.ts

@@ -3,8 +3,9 @@
  * @param {PretrainedConfig} config
  * @returns {Record<string, number[]>}
  */
-export function getKeyValueShapes(config: PretrainedConfig, { prefix, }?: {
+export function getKeyValueShapes(config: PretrainedConfig, { prefix, batch_size, }?: {
     prefix?: string;
+    batch_size?: number;
 }): Record<string, number[]>;
 /**
  * Base class for all configuration classes. For more information, see the corresponding
@@ -55,6 +56,8 @@ export class AutoConfig {
     static from_pretrained(pretrained_model_name_or_path: string, { progress_callback, config, cache_dir, local_files_only, revision, }?: import("./utils/hub.js").PretrainedOptions): Promise<PretrainedConfig>;
 }
 export type PretrainedOptions = import('./utils/hub.js').PretrainedOptions;
+export type ProgressCallback = import('./utils/core.js').ProgressCallback;
+export type ProgressInfo = import('./utils/core.js').ProgressInfo;
 /**
  * Transformers.js-specific configuration, possibly present in config.json under the key `transformers.js_config`.
  */

package/types/configs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"configs.d.ts","sourceRoot":"","sources":["../src/configs.js"],"names":[],"mappings":"AAmNA;;;;GAIG;AACH,0CAHW,gBAAgB;;IACd,OAAO,MAAM,EAAE,MAAM,EAAE,CAAC,CA6EpC;AACD;;;GAGG;AACH;IAwBI;;;;;;;;OAQG;IACH,sDANW,MAAM,0EACN,iBAAiB,GAGf,QAAQ,gBAAgB,CAAC,CAqBrC;IArCD;;;OAGG;IACH,6BAGC;IAnBD,0BAA0B;IAC1B,YADW,MAAM,GAAC,IAAI,CACJ;IAElB,sBAAsB;IACtB,oBADW,OAAO,CACS;IAE3B,qBAAqB;IACrB,yBADW,MAAM,CACO;IAExB,mCAAmC;IACnC,0BADW,oBAAoB,CACN;IAQrB,uBAAkD;CAgCzD;AAED;;;;;GAKG;AACH;IArCI;;;;;;;;OAQG;IACH,6MAmBC;CAcJ;gCAvUY,OAAO,gBAAgB,EAAE,iBAAiB;;;;;;;;qBA4UzC,OAAO,mBAAmB,EAAE,QAAQ,GAAC,OAAO,OAAO,mBAAmB,EAAE,QAAQ,EAAE,OAAO,mBAAmB,EAAE,QAAQ,CAAC;;;;;;+BACvH,OAAO,MAAM,EAAE,MAAM,CAAC;;;;aAGtB,OAAO,oBAAoB,EAAE,UAAU;;;;YACvC,OAAO,mBAAmB,EAAE,QAAQ;;;;+BACpC,OAAO,GAAC,OAAO,MAAM,EAAE,OAAO,CAAC"}
+{"version":3,"file":"configs.d.ts","sourceRoot":"","sources":["../src/configs.js"],"names":[],"mappings":"AAiOA;;;;GAIG;AACH,0CAHW,gBAAgB;;;IACd,OAAO,MAAM,EAAE,MAAM,EAAE,CAAC,CA2EpC;AACD;;;GAGG;AACH;IAwBI;;;;;;;;OAQG;IACH,sDANW,MAAM,0EACN,iBAAiB,GAGf,QAAQ,gBAAgB,CAAC,CAqBrC;IArCD;;;OAGG;IACH,6BAGC;IAnBD,0BAA0B;IAC1B,YADW,MAAM,GAAC,IAAI,CACJ;IAElB,sBAAsB;IACtB,oBADW,OAAO,CACS;IAE3B,qBAAqB;IACrB,yBADW,MAAM,CACO;IAExB,mCAAmC;IACnC,0BADW,oBAAoB,CACN;IAQrB,uBAAkD;CAgCzD;AAED;;;;;GAKG;AACH;IArCI;;;;;;;;OAQG;IACH,6MAmBC;CAcJ;gCAnVY,OAAO,gBAAgB,EAAE,iBAAiB;+BAI1C,OAAO,iBAAiB,EAAE,gBAAgB;2BAI1C,OAAO,iBAAiB,EAAE,YAAY;;;;;;;;qBAgVrC,OAAO,mBAAmB,EAAE,QAAQ,GAAC,OAAO,OAAO,mBAAmB,EAAE,QAAQ,EAAE,OAAO,mBAAmB,EAAE,QAAQ,CAAC;;;;;;+BACvH,OAAO,MAAM,EAAE,MAAM,CAAC;;;;aAGtB,OAAO,oBAAoB,EAAE,UAAU;;;;YACvC,OAAO,mBAAmB,EAAE,QAAQ;;;;+BACpC,OAAO,GAAC,OAAO,MAAM,EAAE,OAAO,CAAC"}

package/types/env.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../src/env.js"],"names":[],"mappings":"AA0CA;;GAEG;AACH;IACI,sDAAsD;;IAGtD,yDAAyD;;IAGzD,yCAAyC;;IAGzC,0CAA0C;;IAG1C,yCAAyC;;IAGzC,mDAAmD;;IAGnD,sDAAsD;;IAGtD,8CAA8C;;IAG9C,wCAAwC;;GAEzC;AAkBH;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,sCAAsC;AACtC,kBADW,uBAAuB,CA6BjC;;;;;;;;aAhDa,MAAM;;;;;cACN;QAAC,IAAI,EAAE,QAAQ,OAAO,oBAAoB,EAAE,GAAG,CAAC,CAAA;KAAC;;;;;uBAEjD,OAAO;;;;gBAEP,MAAM;;;;wBACN,MAAM;;;;;sBACN,OAAO;;;;oBAEP,MAAM;;;;WACN,OAAO;;;;qBACP,OAAO;;;;gBACP,OAAO;;;;cACP,MAAM;;;;oBACN,OAAO"}
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../src/env.js"],"names":[],"mappings":"AA0CA;;GAEG;AACH;IACI,sDAAsD;;IAGtD,yDAAyD;;IAGzD,yCAAyC;;IAGzC,0CAA0C;;IAG1C,yCAAyC;;IAGzC,mDAAmD;;IAGnD,sDAAsD;;IAGtD,8CAA8C;;IAG9C,wCAAwC;;GAEzC;AA6BH;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,sCAAsC;AACtC,kBADW,uBAAuB,CA6BjC;;;;;;;;aAhDa,MAAM;;;;;cACN;QAAC,IAAI,EAAE,QAAQ,OAAO,oBAAoB,EAAE,GAAG,CAAC,CAAA;KAAC;;;;;uBAEjD,OAAO;;;;gBAEP,MAAM;;;;wBACN,MAAM;;;;;sBACN,OAAO;;;;oBAEP,MAAM;;;;WACN,OAAO;;;;qBACP,OAAO;;;;gBACP,OAAO;;;;cACP,MAAM;;;;oBACN,OAAO"}

package/types/models/audio_spectrogram_transformer/feature_extraction_audio_spectrogram_transformer.d.ts

@@ -0,0 +1,25 @@
+export class ASTFeatureExtractor extends FeatureExtractor {
+    constructor(config: any);
+    mel_filters: number[][];
+    window: Float64Array;
+    mean: any;
+    std: any;
+    /**
+     * Computes the log-Mel spectrogram of the provided audio waveform.
+     * @param {Float32Array|Float64Array} waveform The audio waveform to process.
+     * @param {number} max_length The maximum number of frames to return.
+     * @returns {Promise<Tensor>} An object containing the log-Mel spectrogram data as a Float32Array and its dimensions as an array of numbers.
+     */
+    _extract_fbank_features(waveform: Float32Array | Float64Array, max_length: number): Promise<Tensor>;
+    /**
+     * Asynchronously extracts features from a given audio using the provided configuration.
+     * @param {Float32Array|Float64Array} audio The audio data as a Float32Array/Float64Array.
+     * @returns {Promise<{ input_values: Tensor }>} A Promise resolving to an object containing the extracted input features as a Tensor.
+     */
+    _call(audio: Float32Array | Float64Array): Promise<{
+        input_values: Tensor;
+    }>;
+}
+import { FeatureExtractor } from '../../base/feature_extraction_utils.js';
+import { Tensor } from '../../utils/tensor.js';
+//# sourceMappingURL=feature_extraction_audio_spectrogram_transformer.d.ts.map

package/types/models/audio_spectrogram_transformer/feature_extraction_audio_spectrogram_transformer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature_extraction_audio_spectrogram_transformer.d.ts","sourceRoot":"","sources":["../../../src/models/audio_spectrogram_transformer/feature_extraction_audio_spectrogram_transformer.js"],"names":[],"mappings":"AAKA;IAEI,yBA2BC;IARG,wBAA8B;IAE9B,qBAEE;IAEF,UAA4B;IAC5B,SAA0B;IAG9B;;;;;OAKG;IACH,kCAJW,YAAY,GAAC,YAAY,cACzB,MAAM,GACJ,QAAQ,MAAM,CAAC,CAwB3B;IAGD;;;;OAIG;IACH,aAHW,YAAY,GAAC,YAAY,GACvB,QAAQ;QAAE,YAAY,EAAE,MAAM,CAAA;KAAE,CAAC,CAkB7C;CACJ;iCAzFuD,wCAAwC;uBACzE,uBAAuB"}

package/types/models/auto/feature_extraction_auto.d.ts

@@ -0,0 +1,5 @@
+export class AutoFeatureExtractor {
+    static from_pretrained(pretrained_model_name_or_path: string, options: import("../../utils/hub.js").PretrainedOptions): Promise<FeatureExtractor>;
+}
+import { FeatureExtractor } from '../../base/feature_extraction_utils.js';
+//# sourceMappingURL=feature_extraction_auto.d.ts.map

package/types/models/auto/feature_extraction_auto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature_extraction_auto.d.ts","sourceRoot":"","sources":["../../../src/models/auto/feature_extraction_auto.js"],"names":[],"mappings":"AAMA;IAKsD,kJAoBH;CASlD;iCArCgC,wCAAwC"}

package/types/models/auto/image_processing_auto.d.ts

@@ -0,0 +1,5 @@
+export class AutoImageProcessor {
+    static from_pretrained(pretrained_model_name_or_path: string, options: import("../../utils/hub.js").PretrainedOptions): Promise<ImageProcessor>;
+}
+import { ImageProcessor } from '../../base/image_processors_utils.js';
+//# sourceMappingURL=image_processing_auto.d.ts.map

package/types/models/auto/image_processing_auto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image_processing_auto.d.ts","sourceRoot":"","sources":["../../../src/models/auto/image_processing_auto.js"],"names":[],"mappings":"AAMA;IAuBkkwC,gJAAqyC;CADt2yC;+BAzB8B,sCAAsC"}

package/types/models/auto/processing_auto.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Helper class which is used to instantiate pretrained processors with the `from_pretrained` function.
+ * The chosen processor class is determined by the type specified in the processor config.
+ *
+ * **Example:** Load a processor using `from_pretrained`.
+ * ```javascript
+ * let processor = await AutoProcessor.from_pretrained('openai/whisper-tiny.en');
+ * ```
+ *
+ * **Example:** Run an image through a processor.
+ * ```javascript
+ * let processor = await AutoProcessor.from_pretrained('Xenova/clip-vit-base-patch16');
+ * let image = await RawImage.read('https://huggingface.co/datasets/Xenova/transformers.js-docs/resolve/main/football-match.jpg');
+ * let image_inputs = await processor(image);
+ * // {
+ * //   "pixel_values": {
+ * //     "dims": [ 1, 3, 224, 224 ],
+ * //     "type": "float32",
+ * //     "data": Float32Array [ -1.558687686920166, -1.558687686920166, -1.5440893173217773, ... ],
+ * //     "size": 150528
+ * //   },
+ * //   "original_sizes": [
+ * //     [ 533, 800 ]
+ * //   ],
+ * //   "reshaped_input_sizes": [
+ * //     [ 224, 224 ]
+ * //   ]
+ * // }
+ * ```
+ */
+export class AutoProcessor {
+    static from_pretrained(pretrained_model_name_or_path: string, options: any): Promise<Processor>;
+}
+import { Processor } from '../../base/processing_utils.js';
+//# sourceMappingURL=processing_auto.d.ts.map

package/types/models/auto/processing_auto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"processing_auto.d.ts","sourceRoot":"","sources":["../../../src/models/auto/processing_auto.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;IAoCuB,gGAwB8qB;CADpsB;0BA/FyB,gCAAgC"}

package/types/models/beit/image_processing_beit.d.ts

@@ -0,0 +1,4 @@
+export class BeitFeatureExtractor extends ImageProcessor {
+}
+import { ImageProcessor } from "../../base/image_processors_utils.js";
+//# sourceMappingURL=image_processing_beit.d.ts.map

package/types/models/beit/image_processing_beit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image_processing_beit.d.ts","sourceRoot":"","sources":["../../../src/models/beit/image_processing_beit.js"],"names":[],"mappings":"AAIA;CAA4D;+BAFrD,sCAAsC"}

package/types/models/bit/image_processing_bit.d.ts

@@ -0,0 +1,4 @@
+export class BitImageProcessor extends ImageProcessor {
+}
+import { ImageProcessor } from "../../base/image_processors_utils.js";
+//# sourceMappingURL=image_processing_bit.d.ts.map

package/types/models/bit/image_processing_bit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image_processing_bit.d.ts","sourceRoot":"","sources":["../../../src/models/bit/image_processing_bit.js"],"names":[],"mappings":"AAIA;CAAyD;+BAFlD,sCAAsC"}

package/types/models/chinese_clip/image_processing_chinese_clip.d.ts

@@ -0,0 +1,4 @@
+export class ChineseCLIPFeatureExtractor extends ImageProcessor {
+}
+import { ImageProcessor } from "../../base/image_processors_utils.js";
+//# sourceMappingURL=image_processing_chinese_clip.d.ts.map

package/types/models/chinese_clip/image_processing_chinese_clip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image_processing_chinese_clip.d.ts","sourceRoot":"","sources":["../../../src/models/chinese_clip/image_processing_chinese_clip.js"],"names":[],"mappings":"AAIA;CAAmE;+BAF5D,sCAAsC"}

package/types/models/clap/feature_extraction_clap.d.ts

@@ -0,0 +1,57 @@
+export class ClapFeatureExtractor extends FeatureExtractor {
+    constructor(config: any);
+    mel_filters: number[][];
+    mel_filters_slaney: number[][];
+    window: Float64Array;
+    /**
+     * Extracts the mel spectrogram and prepares it for the mode based on the `truncation` and `padding` arguments.
+     *
+     * Four different path are possible:
+     *   - `truncation="fusion"` and the length of the waveform is greater than the max length: the mel spectrogram
+     *     will be computed on the entire audio. 3 random crops and a dowsampled version of the full mel spectrogram
+     *     are then stacked together. They will later be used for `feature_fusion`.
+     *   - `truncation="rand_trunc"` and the length of the waveform is smaller than the max length: the audio is
+     *     padded based on `padding`.
+     *   - `truncation="fusion"` and the length of the waveform is smaller than the max length: the audio is padded
+     *     based on `padding`, and is repeated `4` times.
+     *   - `truncation="rand_trunc"` and the length of the waveform is greater than the max length: the mel
+     *     spectrogram will be computed on a random crop of the waveform.
+     *
+     * @param {Float32Array|Float64Array} waveform The input waveform.
+     * @param {number} max_length The maximum length of the waveform.
+     * @param {string} truncation The truncation strategy to use.
+     * @param {string} padding The padding strategy to use.
+     * @returns {Promise<Tensor>} An object containing the mel spectrogram data as a Float32Array, its dimensions as an array of numbers, and a boolean indicating whether the waveform was longer than the max length.
+     * @private
+     */
+    private _get_input_mel;
+    /**
+     * Compute the log-mel spectrogram of the provided `waveform` using the Hann window.
+     * In CLAP, two different filter banks are used depending on the truncation pattern:
+     *  - `self.mel_filters`: they correspond to the default parameters of `torchaudio` which can be obtained from
+     *    calling `torchaudio.transforms.MelSpectrogram().mel_scale.fb`. These filters are used when `truncation`
+     *    is set to `"fusion"`.
+     *  - `self.mel_filteres_slaney` : they correspond to the default parameters of `librosa` which used
+     *    `librosa.filters.mel` when computing the mel spectrogram. These filters were only used in the original
+     *    implementation when the truncation mode is not `"fusion"`.
+     *
+     * @param {Float32Array|Float64Array} waveform The audio waveform to process.
+     * @param {number[][]} mel_filters The mel filters to use.
+     * @param {number} [max_length=null] The maximum number of frames to return.
+     * @returns {Promise<Tensor>} An object containing the log-Mel spectrogram data as a Float32Array and its dimensions as an array of numbers.
+     */
+    _extract_fbank_features(waveform: Float32Array | Float64Array, mel_filters: number[][], max_length?: number): Promise<Tensor>;
+    /**
+     * Asynchronously extracts features from a given audio using the provided configuration.
+     * @param {Float32Array|Float64Array} audio The audio data as a Float32Array/Float64Array.
+     * @returns {Promise<{ input_features: Tensor }>} A Promise resolving to an object containing the extracted input features as a Tensor.
+     */
+    _call(audio: Float32Array | Float64Array, { max_length, }?: {
+        max_length?: any;
+    }): Promise<{
+        input_features: Tensor;
+    }>;
+}
+import { FeatureExtractor } from '../../base/feature_extraction_utils.js';
+import { Tensor } from '../../utils/tensor.js';
+//# sourceMappingURL=feature_extraction_clap.d.ts.map

package/types/models/clap/feature_extraction_clap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature_extraction_clap.d.ts","sourceRoot":"","sources":["../../../src/models/clap/feature_extraction_clap.js"],"names":[],"mappings":"AAKA;IAEI,yBAyBC;IAtBG,wBAQC;IAED,+BAQC;IAED,qBAAkE;IAKtE;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,uBA0CC;IAED;;;;;;;;;;;;;;OAcG;IACH,kCALW,YAAY,GAAC,YAAY,eACzB,MAAM,EAAE,EAAE,eACV,MAAM,GACJ,QAAQ,MAAM,CAAC,CAoB3B;IAGD;;;;OAIG;IACH,aAHW,YAAY,GAAC,YAAY;;QACvB,QAAQ;QAAE,cAAc,EAAE,MAAM,CAAA;KAAE,CAAC,CAkB/C;CACJ;iCA9JuD,wCAAwC;uBACzE,uBAAuB"}

package/types/models/clip/image_processing_clip.d.ts

@@ -0,0 +1,6 @@
+export class CLIPImageProcessor extends ImageProcessor {
+}
+export class CLIPFeatureExtractor extends CLIPImageProcessor {
+}
+import { ImageProcessor } from "../../base/image_processors_utils.js";
+//# sourceMappingURL=image_processing_clip.d.ts.map

package/types/models/clip/image_processing_clip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image_processing_clip.d.ts","sourceRoot":"","sources":["../../../src/models/clip/image_processing_clip.js"],"names":[],"mappings":"AAIA;CAA0D;AAC1D;CAAgE;+BAHzD,sCAAsC"}