@webex/ladon-ts 4.5.1 → 5.0.1

package/build/module/lib/shared-resource-manager.d.ts

@@ -1,5 +1,5 @@
+import { PreloadConfig, ResolutionConfig, WorkerConfig } from './config-types';
 import * as ort from 'onnxruntime-web';
-import { PipelineConfig, PreloadConfig, SizeConfig } from './config';
 /**
  * Shared resource manager used to preload and share resources across different pipelines.
  * This is useful when multiple pipelines are using the same model or when the model needs
@@ -9,49 +9,45 @@ declare class SharedResourceManager {
     private modelSessions;
     private worker?;
     private workerUrl?;
+    private resolvedUriCache;
     /**
      * Initialize the worker using the provided configuration.
      *
-     * @param {PreloadConfig} config The configuration object.
-     * @returns {Promise<Worker>} A promise that resolves when the worker is initialized.
-     * @example
-     * await initializeWorker(config);
+     * @param config - The configuration object.
+     * @returns A promise that resolves when the worker is initialized.
      */
-    initializeWorker(config: PreloadConfig): Promise<Worker>;
+    initializeWorker(config: WorkerConfig): Promise<Worker>;
     /**
      * Terminate the worker.
      */
     terminateWorker(): void;
     /**
-     * Preload the model using the provided configuration.
+     * Load the model using the provided configuration. This gets called by the worker when using
+     * the worker generator.
      *
-     * @param {PreloadConfig} config The configuration object.
-     * @returns {Promise<void>} A promise that resolves when the model is preloaded.
-     * @example
-     * await preloadModel(config);
+     * @param config - The configuration object.
+     * @returns A promise that resolves when the model is preloaded.
      */
-    preloadModel(config: PreloadConfig): Promise<ort.InferenceSession>;
+    loadModel(config: PreloadConfig): Promise<ort.InferenceSession>;
     /**
      * Preload the worker using the provided configuration.
      *
-     * @param {PreloadConfig} config The configuration object.
-     * @returns {Promise<void>} A promise that resolves when the worker is preloaded.
-     * @example
-     * await preloadWorker(config);
+     * @param config - The configuration object.
+     * @returns A promise that resolves when the worker is preloaded.
      */
     preloadWorker(config: PreloadConfig): Promise<void>;
     /**
      * Warmup the model session with a dummy input to avoid latency when running the model for the first time.
      *
      * @param {ort.InferenceSession} session The model session.
-     * @param {SizeConfig} inputSize The input size of the model.
+     * @param {ResolutionConfig} inputSize The input size of the model.
      * @param {number} inputChannels The number of input channels (e.g., RGB is 3).
      * @param {ort.Tensor.Type} inputType The input tensor type.
      * @returns {Promise<void>} A promise that resolves when the model is warmed up.
      * @example
      * await warmupModel(session, inputSize, inputChannels, inputType);
      */
-    warmupModel(session: ort.InferenceSession, inputSize?: SizeConfig, inputChannels?: number, inputType?: ort.Tensor.Type): Promise<void>;
+    warmupModel(session: ort.InferenceSession, inputSize?: ResolutionConfig, inputChannels?: number, inputType?: ort.Tensor.Type): Promise<void>;
     /**
      * Get the model session for the provided model URL.
      *
@@ -62,23 +58,36 @@ declare class SharedResourceManager {
      */
     getModelSession(modelUrl: string): ort.InferenceSession;
     /**
-     * Resolves the model URL based on the configuration.
+     * Resolves the full URL for a given asset. Non-file URIs are treated as paths
+     * and resolved using the `toAbsoluteURI` method.
      *
-     * @param {PipelineConfig} config The configuration object.
-     * @returns {Promise<string>} The resolved model URL.
-     * @example
-     * const modelUrl = await getModelUrl(config);
+     * @param config - The preload configuration.
+     * @param assetUri - The asset URI from the config.
+     * @returns The resolved full URL.
+     */
+    /**
+     * Resolves the full URL for a given asset. Non-file URIs are treated as paths and resolved
+     * using the `toAbsoluteURI` method. If the assetUri is already resolved, or if it's found in
+     * cache, it will be returned directly. If an assetUrlResolver function is provided in the
+     * configuration, it will be used to resolve the URL if the assetUri is not fully qualified,
+     * a blob URL, or in the cache.
+     *
+     * @param config - The preload configuration.
+     * @param assetUri - The asset URI from the config.
+     * @returns The resolved full URL.
      */
-    getModelUrl({ mask: { model_url_resolver, model_uri } }: PipelineConfig | PreloadConfig): Promise<string>;
+    resolveUri(config: PreloadConfig, assetUri?: string): Promise<string>;
     getWorker(): Worker | undefined;
     getWorkerUrl(): string | undefined;
+    /**
+     * Prepare the worker configuration by resolving the final URLs and paths to send to the
+     * worker. This is necessary because we can't send functions to the worker. We also need to
+     * remove the assetUrlResolver function from the configuration.
+     *
+     * @param config - The preload configuration.
+     * @returns The worker configuration.
+     */
+    prepareWorkerConfig(config: PreloadConfig): Promise<any>;
 }
 export declare const sharedResourceManager: SharedResourceManager;
-/**
- * Preload the resources using the provided configuration. This function is used to preload the model
- * and the worker before creating the pipeline.
- *
- * @param config - The configuration object.
- */
-export declare const preload: (config: PreloadConfig) => Promise<void>;
 export {};

package/build/module/lib/shared-resource-manager.js

@@ -1,189 +1,151 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import * as ort from 'onnxruntime-web';
-import { toAbsoluteURI } from './util';
-/**
- * Shared resource manager used to preload and share resources across different pipelines.
- * This is useful when multiple pipelines are using the same model or when the model needs
- * to be preloaded before the pipeline is created.
- */
-class SharedResourceManager {
-    constructor() {
-        this.modelSessions = {};
-    }
-    /**
-     * Initialize the worker using the provided configuration.
-     *
-     * @param {PreloadConfig} config The configuration object.
-     * @returns {Promise<Worker>} A promise that resolves when the worker is initialized.
-     * @example
-     * await initializeWorker(config);
-     */
-    initializeWorker(config) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (typeof Worker === 'undefined') {
-                throw new Error('[ladon-ts] web workers are not supported in this environment');
-            }
-            const crossOriginScriptUrl = config.mask.worker_uri;
-            const content = yield (yield fetch(crossOriginScriptUrl, { cache: 'force-cache' })).text();
-            this.workerUrl = URL.createObjectURL(new Blob([content], { type: 'text/javascript' }));
-            this.worker = new Worker(this.workerUrl, { type: 'module' });
-            return this.worker;
-        });
-    }
-    /**
-     * Terminate the worker.
-     */
-    terminateWorker() {
-        if (this.worker) {
-            this.worker.terminate();
-            this.worker = undefined;
-        }
-    }
-    /**
-     * Preload the model using the provided configuration.
-     *
-     * @param {PreloadConfig} config The configuration object.
-     * @returns {Promise<void>} A promise that resolves when the model is preloaded.
-     * @example
-     * await preloadModel(config);
-     */
-    preloadModel(config) {
-        var _a;
-        var _b;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (config.wasm_uri) {
-                ort.env.wasm.wasmPaths = toAbsoluteURI(config.wasm_uri, config.base_url);
-            }
-            ort.env.wasm.numThreads = 0;
-            // Resolve the model URL based on the configuration.
-            const modelUrl = yield this.getModelUrl(config);
-            // Use the model session cache to avoid creating multiple sessions for the same model.
-            (_a = (_b = this.modelSessions)[modelUrl]) !== null && _a !== void 0 ? _a : (_b[modelUrl] = yield ort.InferenceSession.create(modelUrl, {
-                executionProviders: ['wasm'],
-            }));
-            // Warmup the model with a dummy input to avoid latency when running the model for the first time.
-            yield this.warmupModel(this.modelSessions[modelUrl], config.mask.input_size, config.mask.model_rank);
-            return this.modelSessions[modelUrl];
-        });
-    }
-    /**
-     * Preload the worker using the provided configuration.
-     *
-     * @param {PreloadConfig} config The configuration object.
-     * @returns {Promise<void>} A promise that resolves when the worker is preloaded.
-     * @example
-     * await preloadWorker(config);
-     */
-    preloadWorker(config) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            // If the model URL resolver is a function, We can't send the function to the worker so
-            // we resolve the model URL here and send the resolved URL to the worker.
-            const modelUrl = yield this.getModelUrl(config);
-            const newConfig = Object.assign(Object.assign({}, config), { mask: Object.assign(Object.assign({}, config.mask), { model_url_resolver: modelUrl }) });
-            // Initialize the worker.
-            yield this.initializeWorker(newConfig);
-            // Send the preload message to the worker.
-            (_a = this.worker) === null || _a === void 0 ? void 0 : _a.postMessage({ type: 'preload', config: newConfig });
-        });
-    }
-    /**
-     * Warmup the model session with a dummy input to avoid latency when running the model for the first time.
-     *
-     * @param {ort.InferenceSession} session The model session.
-     * @param {SizeConfig} inputSize The input size of the model.
-     * @param {number} inputChannels The number of input channels (e.g., RGB is 3).
-     * @param {ort.Tensor.Type} inputType The input tensor type.
-     * @returns {Promise<void>} A promise that resolves when the model is warmed up.
-     * @example
-     * await warmupModel(session, inputSize, inputChannels, inputType);
-     */
-    warmupModel(session, inputSize = { width: 1280, height: 720 }, inputChannels = 3, inputType = 'float32') {
-        return __awaiter(this, void 0, void 0, function* () {
-            const numPixels = inputSize.height * inputSize.width;
-            const dummyInputData = new Float32Array(inputChannels * numPixels).fill(0);
-            const dummyInput = new ort.Tensor(inputType, dummyInputData, [
-                1,
-                inputChannels,
-                inputSize.height,
-                inputSize.width,
-            ]);
-            const feed = { [session.inputNames[0]]: dummyInput };
-            // Use an additional dummy tensor if the model expects a previous mask.
-            if (inputChannels === 3) {
-                const dummyMaskData = new Float32Array(numPixels).fill(0);
-                const prevMaskTensor = new ort.Tensor(inputType, dummyMaskData, [
-                    1,
-                    1,
-                    inputSize.height,
-                    inputSize.width,
-                ]);
-                feed[session.inputNames[1]] = prevMaskTensor;
-            }
-            // Run the model with the dummy input to warm it up.
-            yield session.run(feed);
-        });
-    }
-    /**
-     * Get the model session for the provided model URL.
-     *
-     * @param {string} modelUrl The model URL.
-     * @returns {ort.InferenceSession} The model session.
-     * @example
-     * const session = getModelSession(modelUrl);
-     */
-    getModelSession(modelUrl) {
-        return this.modelSessions[modelUrl];
-    }
-    /**
-     * Resolves the model URL based on the configuration.
-     *
-     * @param {PipelineConfig} config The configuration object.
-     * @returns {Promise<string>} The resolved model URL.
-     * @example
-     * const modelUrl = await getModelUrl(config);
-     */
-    getModelUrl({ mask: { model_url_resolver, model_uri } }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let modelUrl;
-            if (typeof model_url_resolver === 'string') {
-                modelUrl = model_url_resolver;
-            }
-            else {
-                modelUrl = yield model_url_resolver(model_uri);
-            }
-            return modelUrl;
-        });
-    }
-    getWorker() {
-        return this.worker;
-    }
-    getWorkerUrl() {
-        return this.workerUrl;
-    }
-}
-// Global instance of the shared resource manager.
-export const sharedResourceManager = new SharedResourceManager();
-/**
- * Preload the resources using the provided configuration. This function is used to preload the model
- * and the worker before creating the pipeline.
- *
- * @param config - The configuration object.
- */
-export const preload = (config) => __awaiter(void 0, void 0, void 0, function* () {
-    if (config.mask.generator === 'worker') {
-        yield sharedResourceManager.preloadWorker(config);
-    }
-    else {
-        yield sharedResourceManager.preloadModel(config);
-    }
-});
-//# sourceMappingURL=data:application/json;base64,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
+import * as a from "onnxruntime-web";
+import { isResolvedUri as d, toAbsoluteURI as m } from "./util.js";
+class c {
+  constructor() {
+    this.modelSessions = {}, this.resolvedUriCache = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Initialize the worker using the provided configuration.
+   *
+   * @param config - The configuration object.
+   * @returns A promise that resolves when the worker is initialized.
+   */
+  async initializeWorker(e) {
+    if (typeof Worker > "u")
+      throw new Error("[ladon-ts] web workers are not supported in this environment");
+    const r = await this.resolveUri(e, e.mask.workerUri), o = await (await fetch(r, { cache: "force-cache" })).text();
+    return this.workerUrl = URL.createObjectURL(new Blob([o], { type: "text/javascript" })), new Worker(this.workerUrl, { type: "module" });
+  }
+  /**
+   * Terminate the worker.
+   */
+  terminateWorker() {
+    this.worker && (this.worker.terminate(), this.worker = void 0);
+  }
+  /**
+   * Load the model using the provided configuration. This gets called by the worker when using
+   * the worker generator.
+   *
+   * @param config - The configuration object.
+   * @returns A promise that resolves when the model is preloaded.
+   */
+  async loadModel(e) {
+    var i;
+    const { mask: r, executionProviders: s } = e, o = await this.resolveUri(e, e.wasmUri);
+    o && (a.env.wasm.wasmPaths = o), a.env.wasm.numThreads = 1;
+    const t = await this.resolveUri(e, r.modelUri), n = s != null && s.length ? s : ["wasm"];
+    return (i = this.modelSessions)[t] || (i[t] = await a.InferenceSession.create(t, {
+      executionProviders: n
+    })), await this.warmupModel(this.modelSessions[t], r.inputSize, r.modelRank), this.modelSessions[t];
+  }
+  /**
+   * Preload the worker using the provided configuration.
+   *
+   * @param config - The configuration object.
+   * @returns A promise that resolves when the worker is preloaded.
+   */
+  async preloadWorker(e) {
+    const r = await this.prepareWorkerConfig(e);
+    this.worker = await this.initializeWorker(r), this.worker.postMessage({ type: "preload", config: r });
+  }
+  /**
+   * Warmup the model session with a dummy input to avoid latency when running the model for the first time.
+   *
+   * @param {ort.InferenceSession} session The model session.
+   * @param {ResolutionConfig} inputSize The input size of the model.
+   * @param {number} inputChannels The number of input channels (e.g., RGB is 3).
+   * @param {ort.Tensor.Type} inputType The input tensor type.
+   * @returns {Promise<void>} A promise that resolves when the model is warmed up.
+   * @example
+   * await warmupModel(session, inputSize, inputChannels, inputType);
+   */
+  async warmupModel(e, r = { width: 1280, height: 720 }, s = 3, o = "float32") {
+    const t = r.height * r.width, n = new Float32Array(s * t).fill(0), i = new a.Tensor(o, n, [
+      1,
+      s,
+      r.height,
+      r.width
+    ]), l = { [e.inputNames[0]]: i };
+    if (s === 3) {
+      const w = new Float32Array(t).fill(0), h = new a.Tensor(o, w, [
+        1,
+        1,
+        r.height,
+        r.width
+      ]);
+      l[e.inputNames[1]] = h;
+    }
+    await e.run(l);
+  }
+  /**
+   * Get the model session for the provided model URL.
+   *
+   * @param {string} modelUrl The model URL.
+   * @returns {ort.InferenceSession} The model session.
+   * @example
+   * const session = getModelSession(modelUrl);
+   */
+  getModelSession(e) {
+    return this.modelSessions[e];
+  }
+  /**
+   * Resolves the full URL for a given asset. Non-file URIs are treated as paths
+   * and resolved using the `toAbsoluteURI` method.
+   *
+   * @param config - The preload configuration.
+   * @param assetUri - The asset URI from the config.
+   * @returns The resolved full URL.
+   */
+  /**
+   * Resolves the full URL for a given asset. Non-file URIs are treated as paths and resolved
+   * using the `toAbsoluteURI` method. If the assetUri is already resolved, or if it's found in
+   * cache, it will be returned directly. If an assetUrlResolver function is provided in the
+   * configuration, it will be used to resolve the URL if the assetUri is not fully qualified,
+   * a blob URL, or in the cache.
+   *
+   * @param config - The preload configuration.
+   * @param assetUri - The asset URI from the config.
+   * @returns The resolved full URL.
+   */
+  async resolveUri(e, r) {
+    if (!r)
+      throw new Error("Asset URI is undefined.");
+    if (this.resolvedUriCache.has(r))
+      return this.resolvedUriCache.get(r);
+    let s;
+    if (d(r) ? s = r : r.match(/\.[a-z0-9]+$/i) ? typeof e.assetUrlResolver == "function" && (s = await e.assetUrlResolver(r, e)) : s = m(r, e.baseUrl), !s)
+      throw new Error(`Failed to resolve asset URI: ${r}`);
+    return this.resolvedUriCache.set(r, s), s;
+  }
+  getWorker() {
+    return this.worker;
+  }
+  getWorkerUrl() {
+    return this.workerUrl;
+  }
+  /**
+   * Prepare the worker configuration by resolving the final URLs and paths to send to the
+   * worker. This is necessary because we can't send functions to the worker. We also need to
+   * remove the assetUrlResolver function from the configuration.
+   *
+   * @param config - The preload configuration.
+   * @returns The worker configuration.
+   */
+  async prepareWorkerConfig(e) {
+    const s = { ...{
+      ...e,
+      mask: {
+        ...e.mask,
+        modelUri: await this.resolveUri(e, e.mask.modelUri),
+        workerUri: await this.resolveUri(e, e.mask.workerUri)
+      },
+      wasmUri: await this.resolveUri(e, e.wasmUri)
+    }, assetUrlResolver: void 0 };
+    return JSON.parse(JSON.stringify(s));
+  }
+}
+const U = new c();
+export {
+  U as sharedResourceManager
+};
+//# sourceMappingURL=shared-resource-manager.js.map

package/build/module/lib/shared-resource-manager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-resource-manager.js","sources":["../../../src/lib/shared-resource-manager.ts"],"sourcesContent":["import * as ort from 'onnxruntime-web';\n\nimport { PreloadConfig, ResolutionConfig, WorkerConfig } from './config-types';\nimport { isResolvedUri, toAbsoluteURI } from './util';\n\n/**\n * Shared resource manager used to preload and share resources across different pipelines.\n * This is useful when multiple pipelines are using the same model or when the model needs\n * to be preloaded before the pipeline is created.\n */\nclass SharedResourceManager {\n    private modelSessions: Record<string, ort.InferenceSession> = {};\n    private worker?: Worker;\n    private workerUrl?: string;\n\n    // In-memory cache for resolved URLs\n    private resolvedUriCache: Map<string, string> = new Map();\n\n    /**\n     * Initialize the worker using the provided configuration.\n     *\n     * @param config - The configuration object.\n     * @returns A promise that resolves when the worker is initialized.\n     */\n    public async initializeWorker(config: WorkerConfig): Promise<Worker> {\n        if (typeof Worker === 'undefined') {\n            throw new Error('[ladon-ts] web workers are not supported in this environment');\n        }\n\n        const scriptUri = await this.resolveUri(config, config.mask.workerUri);\n        const response = await fetch(scriptUri, { cache: 'force-cache' });\n        const workerSource = await response.text();\n\n        this.workerUrl = URL.createObjectURL(new Blob([workerSource], { type: 'text/javascript' }));\n\n        return new Worker(this.workerUrl, { type: 'module' });\n    }\n\n    /**\n     * Terminate the worker.\n     */\n    public terminateWorker() {\n        if (this.worker) {\n            this.worker.terminate();\n            this.worker = undefined;\n        }\n    }\n\n    /**\n     * Load the model using the provided configuration. This gets called by the worker when using\n     * the worker generator.\n     *\n     * @param config - The configuration object.\n     * @returns A promise that resolves when the model is preloaded.\n     */\n    public async loadModel(config: PreloadConfig) {\n        const { mask, executionProviders: providers } = config;\n\n        const wasmPaths = await this.resolveUri(config, config.wasmUri);\n        if (wasmPaths) {\n            ort.env.wasm.wasmPaths = wasmPaths;\n        }\n\n        // Lock to a single thread to avoid performance issues.\n        ort.env.wasm.numThreads = 1;\n\n        const modelUrl = await this.resolveUri(config, mask.modelUri);\n        const executionProviders = providers?.length ? providers : ['wasm'];\n\n        // Use the model session cache to avoid creating multiple sessions for the same model.\n        this.modelSessions[modelUrl] ||= await ort.InferenceSession.create(modelUrl, {\n            executionProviders,\n        });\n\n        // Warmup the model with a dummy input to avoid latency when running the model for the first time.\n        await this.warmupModel(this.modelSessions[modelUrl], mask.inputSize, mask.modelRank);\n\n        return this.modelSessions[modelUrl];\n    }\n\n    /**\n     * Preload the worker using the provided configuration.\n     *\n     * @param config - The configuration object.\n     * @returns A promise that resolves when the worker is preloaded.\n     */\n    public async preloadWorker(config: PreloadConfig) {\n        const workerConfig = await this.prepareWorkerConfig(config);\n\n        this.worker = await this.initializeWorker(workerConfig);\n        this.worker.postMessage({ type: 'preload', config: workerConfig });\n    }\n\n    /**\n     * Warmup the model session with a dummy input to avoid latency when running the model for the first time.\n     *\n     * @param {ort.InferenceSession} session The model session.\n     * @param {ResolutionConfig} inputSize The input size of the model.\n     * @param {number} inputChannels The number of input channels (e.g., RGB is 3).\n     * @param {ort.Tensor.Type} inputType The input tensor type.\n     * @returns {Promise<void>} A promise that resolves when the model is warmed up.\n     * @example\n     * await warmupModel(session, inputSize, inputChannels, inputType);\n     */\n    public async warmupModel(\n        session: ort.InferenceSession,\n        inputSize: ResolutionConfig = { width: 1280, height: 720 },\n        inputChannels = 3,\n        inputType: ort.Tensor.Type = 'float32'\n    ): Promise<void> {\n        const numPixels = inputSize.height * inputSize.width;\n        const dummyInputData = new Float32Array(inputChannels * numPixels).fill(0);\n        const dummyInput = new ort.Tensor(inputType, dummyInputData, [\n            1,\n            inputChannels,\n            inputSize.height,\n            inputSize.width,\n        ]);\n        const feed = { [session.inputNames[0]]: dummyInput };\n\n        // Use an additional dummy tensor if the model expects a previous mask.\n        if (inputChannels === 3) {\n            const dummyMaskData = new Float32Array(numPixels).fill(0);\n            const prevMaskTensor = new ort.Tensor(inputType, dummyMaskData, [\n                1,\n                1,\n                inputSize.height,\n                inputSize.width,\n            ]);\n            feed[session.inputNames[1]] = prevMaskTensor;\n        }\n\n        // Run the model with the dummy input to warm it up.\n        await session.run(feed);\n    }\n\n    /**\n     * Get the model session for the provided model URL.\n     *\n     * @param {string} modelUrl The model URL.\n     * @returns {ort.InferenceSession} The model session.\n     * @example\n     * const session = getModelSession(modelUrl);\n     */\n    public getModelSession(modelUrl: string) {\n        return this.modelSessions[modelUrl];\n    }\n\n    /**\n     * Resolves the full URL for a given asset. Non-file URIs are treated as paths\n     * and resolved using the `toAbsoluteURI` method.\n     *\n     * @param config - The preload configuration.\n     * @param assetUri - The asset URI from the config.\n     * @returns The resolved full URL.\n     */\n    /**\n     * Resolves the full URL for a given asset. Non-file URIs are treated as paths and resolved\n     * using the `toAbsoluteURI` method. If the assetUri is already resolved, or if it's found in\n     * cache, it will be returned directly. If an assetUrlResolver function is provided in the\n     * configuration, it will be used to resolve the URL if the assetUri is not fully qualified,\n     * a blob URL, or in the cache.\n     *\n     * @param config - The preload configuration.\n     * @param assetUri - The asset URI from the config.\n     * @returns The resolved full URL.\n     */\n    public async resolveUri(config: PreloadConfig, assetUri?: string): Promise<string> {\n        if (!assetUri) {\n            throw new Error('Asset URI is undefined.');\n        }\n\n        // Check if the URL is already cached\n        if (this.resolvedUriCache.has(assetUri)) {\n            return this.resolvedUriCache.get(assetUri) as string;\n        }\n\n        let resolvedUrl: string | undefined;\n\n        if (isResolvedUri(assetUri)) {\n            // If the assetUri is fully qualified or a blob URL, return it directly.\n            // (Assets uris are resolved before being sent to the worker.)\n            resolvedUrl = assetUri;\n        } else if (!assetUri.match(/\\.[a-z0-9]+$/i)) {\n            // Resolve as an absolute path to a non-file endpoint (e.g., wasmPaths).\n            resolvedUrl = toAbsoluteURI(assetUri, config.baseUrl);\n        } else if (typeof config.assetUrlResolver === 'function') {\n            // Resolve via assetUrlResolver. This delegates the resolution logic to the caller.\n            resolvedUrl = await config.assetUrlResolver(assetUri, config);\n        }\n\n        if (!resolvedUrl) {\n            throw new Error(`Failed to resolve asset URI: ${assetUri}`);\n        }\n\n        // Cache the resolved URL\n        this.resolvedUriCache.set(assetUri, resolvedUrl);\n\n        return resolvedUrl;\n    }\n\n    public getWorker() {\n        return this.worker;\n    }\n\n    public getWorkerUrl() {\n        return this.workerUrl;\n    }\n\n    /**\n     * Prepare the worker configuration by resolving the final URLs and paths to send to the\n     * worker. This is necessary because we can't send functions to the worker. We also need to\n     * remove the assetUrlResolver function from the configuration.\n     *\n     * @param config - The preload configuration.\n     * @returns The worker configuration.\n     */\n    public async prepareWorkerConfig(config: PreloadConfig) {\n        // Resolve and cache the URIs before sending the config to the worker. Future calls to the\n        // resolveUri method will use the cache.\n        const resolvedConfig: PreloadConfig = {\n            ...config,\n            mask: {\n                ...config.mask,\n                modelUri: await this.resolveUri(config, config.mask.modelUri),\n                workerUri: await this.resolveUri(config, config.mask.workerUri),\n            },\n            wasmUri: await this.resolveUri(config, config.wasmUri),\n        };\n\n        // We can't send the assetUrlResolver function to the worker so we remove it from the config.\n        const workerConfig = { ...resolvedConfig, assetUrlResolver: undefined };\n\n        // This is a workaround to ensure the worker configuration can be sent to the worker.\n        return JSON.parse(JSON.stringify(workerConfig));\n    }\n}\n\n// Global instance of the shared resource manager.\nexport const sharedResourceManager = new SharedResourceManager();\n"],"names":["SharedResourceManager","config","scriptUri","workerSource","mask","providers","wasmPaths","ort","modelUrl","executionProviders","_a","workerConfig","session","inputSize","inputChannels","inputType","numPixels","dummyInputData","dummyInput","feed","dummyMaskData","prevMaskTensor","assetUri","resolvedUrl","isResolvedUri","toAbsoluteURI","sharedResourceManager"],"mappings":";;AAUA,MAAMA,EAAsB;AAAA,EAA5B,cAAA;AACI,SAAQ,gBAAsD,CAAC,GAKvD,KAAA,uCAA4C,IAAI;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQxD,MAAa,iBAAiBC,GAAuC;AAC7D,QAAA,OAAO,SAAW;AACZ,YAAA,IAAI,MAAM,8DAA8D;AAGlF,UAAMC,IAAY,MAAM,KAAK,WAAWD,GAAQA,EAAO,KAAK,SAAS,GAE/DE,IAAe,OADJ,MAAM,MAAMD,GAAW,EAAE,OAAO,eAAe,GAC5B,KAAK;AAEzC,gBAAK,YAAY,IAAI,gBAAgB,IAAI,KAAK,CAACC,CAAY,GAAG,EAAE,MAAM,kBAAmB,CAAA,CAAC,GAEnF,IAAI,OAAO,KAAK,WAAW,EAAE,MAAM,UAAU;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA,EAMjD,kBAAkB;AACrB,IAAI,KAAK,WACL,KAAK,OAAO,UAAU,GACtB,KAAK,SAAS;AAAA,EAClB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUJ,MAAa,UAAUF,GAAuB;;AAC1C,UAAM,EAAE,MAAAG,GAAM,oBAAoBC,EAAc,IAAAJ,GAE1CK,IAAY,MAAM,KAAK,WAAWL,GAAQA,EAAO,OAAO;AAC9D,IAAIK,MACIC,EAAA,IAAI,KAAK,YAAYD,IAIzBC,EAAA,IAAI,KAAK,aAAa;AAE1B,UAAMC,IAAW,MAAM,KAAK,WAAWP,GAAQG,EAAK,QAAQ,GACtDK,IAAqBJ,KAAA,QAAAA,EAAW,SAASA,IAAY,CAAC,MAAM;AAGlE,YAAAK,IAAA,KAAK,eAALF,OAAAE,EAAAF,KAAiC,MAAMD,EAAI,iBAAiB,OAAOC,GAAU;AAAA,MACzE,oBAAAC;AAAA,IAAA,CACH,IAGK,MAAA,KAAK,YAAY,KAAK,cAAcD,CAAQ,GAAGJ,EAAK,WAAWA,EAAK,SAAS,GAE5E,KAAK,cAAcI,CAAQ;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAStC,MAAa,cAAcP,GAAuB;AAC9C,UAAMU,IAAe,MAAM,KAAK,oBAAoBV,CAAM;AAE1D,SAAK,SAAS,MAAM,KAAK,iBAAiBU,CAAY,GACtD,KAAK,OAAO,YAAY,EAAE,MAAM,WAAW,QAAQA,GAAc;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcrE,MAAa,YACTC,GACAC,IAA8B,EAAE,OAAO,MAAM,QAAQ,IAAI,GACzDC,IAAgB,GAChBC,IAA6B,WAChB;AACP,UAAAC,IAAYH,EAAU,SAASA,EAAU,OACzCI,IAAiB,IAAI,aAAaH,IAAgBE,CAAS,EAAE,KAAK,CAAC,GACnEE,IAAa,IAAIX,EAAI,OAAOQ,GAAWE,GAAgB;AAAA,MACzD;AAAA,MACAH;AAAA,MACAD,EAAU;AAAA,MACVA,EAAU;AAAA,IAAA,CACb,GACKM,IAAO,EAAE,CAACP,EAAQ,WAAW,CAAC,CAAC,GAAGM,EAAW;AAGnD,QAAIJ,MAAkB,GAAG;AACrB,YAAMM,IAAgB,IAAI,aAAaJ,CAAS,EAAE,KAAK,CAAC,GAClDK,IAAiB,IAAId,EAAI,OAAOQ,GAAWK,GAAe;AAAA,QAC5D;AAAA,QACA;AAAA,QACAP,EAAU;AAAA,QACVA,EAAU;AAAA,MAAA,CACb;AACD,MAAAM,EAAKP,EAAQ,WAAW,CAAC,CAAC,IAAIS;AAAA,IAAA;AAI5B,UAAAT,EAAQ,IAAIO,CAAI;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWnB,gBAAgBX,GAAkB;AAC9B,WAAA,KAAK,cAAcA,CAAQ;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAsBtC,MAAa,WAAWP,GAAuBqB,GAAoC;AAC/E,QAAI,CAACA;AACK,YAAA,IAAI,MAAM,yBAAyB;AAI7C,QAAI,KAAK,iBAAiB,IAAIA,CAAQ;AAC3B,aAAA,KAAK,iBAAiB,IAAIA,CAAQ;AAGzC,QAAAC;AAcJ,QAZIC,EAAcF,CAAQ,IAGRC,IAAAD,IACNA,EAAS,MAAM,eAAe,IAG/B,OAAOrB,EAAO,oBAAqB,eAE1CsB,IAAc,MAAMtB,EAAO,iBAAiBqB,GAAUrB,CAAM,KAH9CsB,IAAAE,EAAcH,GAAUrB,EAAO,OAAO,GAMpD,CAACsB;AACD,YAAM,IAAI,MAAM,gCAAgCD,CAAQ,EAAE;AAIzD,gBAAA,iBAAiB,IAAIA,GAAUC,CAAW,GAExCA;AAAA,EAAA;AAAA,EAGJ,YAAY;AACf,WAAO,KAAK;AAAA,EAAA;AAAA,EAGT,eAAe;AAClB,WAAO,KAAK;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWhB,MAAa,oBAAoBtB,GAAuB;AAcpD,UAAMU,IAAe,EAAE,GAXe;AAAA,MAClC,GAAGV;AAAA,MACH,MAAM;AAAA,QACF,GAAGA,EAAO;AAAA,QACV,UAAU,MAAM,KAAK,WAAWA,GAAQA,EAAO,KAAK,QAAQ;AAAA,QAC5D,WAAW,MAAM,KAAK,WAAWA,GAAQA,EAAO,KAAK,SAAS;AAAA,MAClE;AAAA,MACA,SAAS,MAAM,KAAK,WAAWA,GAAQA,EAAO,OAAO;AAAA,IACzD,GAG0C,kBAAkB,OAAU;AAGtE,WAAO,KAAK,MAAM,KAAK,UAAUU,CAAY,CAAC;AAAA,EAAA;AAEtD;AAGa,MAAAe,IAAwB,IAAI1B,EAAsB;"}

package/build/module/lib/util.d.ts

@@ -51,3 +51,13 @@ export declare function lanczos3Upsample(input: Float32Array, srcWidth: number,
 export declare const toAbsoluteURI: (relativeURL: string, baseURL?: string) => string;
 export declare function compileShader(gl: WebGL2RenderingContext, shader_type: number, source: string): WebGLShader;
 export declare function linkProgram(gl: WebGL2RenderingContext, vertex_shader: WebGLShader, fragment_shader: WebGLShader): WebGLProgram;
+/**
+ * Determines if a URI is already resolved.
+ * A resolved URI is either:
+ *  - A blob URL (starts with 'blob:')
+ *  - A fully qualified URL (e.g., http:// or https://)
+ *
+ * @param uri - The URI to check.
+ * @returns Whether the URI is already resolved.
+ */
+export declare function isResolvedUri(uri: string): boolean;