diff --git "a/ort-wasm/ort.webgpu.mjs" "b/ort-wasm/ort.webgpu.mjs"
new file mode 100644--- /dev/null
+++ "b/ort-wasm/ort.webgpu.mjs"
@@ -0,0 +1,4467 @@
+/*!
+ * ONNX Runtime Web v1.26.0
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// common/dist/esm/backend-impl.js
+var backends, backendsSortedByPriority, registerBackend, tryResolveAndInitializeBackend, resolveBackendAndExecutionProviders;
+var init_backend_impl = __esm({
+  "common/dist/esm/backend-impl.js"() {
+    "use strict";
+    backends = /* @__PURE__ */ new Map();
+    backendsSortedByPriority = [];
+    registerBackend = (name, backend, priority) => {
+      if (backend && typeof backend.init === "function" && typeof backend.createInferenceSessionHandler === "function") {
+        const currentBackend = backends.get(name);
+        if (currentBackend === void 0) {
+          backends.set(name, { backend, priority });
+        } else if (currentBackend.priority > priority) {
+          return;
+        } else if (currentBackend.priority === priority) {
+          if (currentBackend.backend !== backend) {
+            throw new Error(`cannot register backend "${name}" using priority ${priority}`);
+          }
+        }
+        if (priority >= 0) {
+          const i = backendsSortedByPriority.indexOf(name);
+          if (i !== -1) {
+            backendsSortedByPriority.splice(i, 1);
+          }
+          for (let i2 = 0; i2 < backendsSortedByPriority.length; i2++) {
+            if (backends.get(backendsSortedByPriority[i2]).priority <= priority) {
+              backendsSortedByPriority.splice(i2, 0, name);
+              return;
+            }
+          }
+          backendsSortedByPriority.push(name);
+        }
+        return;
+      }
+      throw new TypeError("not a valid backend");
+    };
+    tryResolveAndInitializeBackend = async (backendName) => {
+      const backendInfo = backends.get(backendName);
+      if (!backendInfo) {
+        return "backend not found.";
+      }
+      if (backendInfo.initialized) {
+        return backendInfo.backend;
+      } else if (backendInfo.aborted) {
+        return backendInfo.error;
+      } else {
+        const isInitializing = !!backendInfo.initPromise;
+        try {
+          if (!isInitializing) {
+            backendInfo.initPromise = backendInfo.backend.init(backendName);
+          }
+          await backendInfo.initPromise;
+          backendInfo.initialized = true;
+          return backendInfo.backend;
+        } catch (e) {
+          if (!isInitializing) {
+            backendInfo.error = `${e}`;
+            backendInfo.aborted = true;
+          }
+          return backendInfo.error;
+        } finally {
+          delete backendInfo.initPromise;
+        }
+      }
+    };
+    resolveBackendAndExecutionProviders = async (options) => {
+      const eps = options.executionProviders || [];
+      const backendHints = eps.map((i) => typeof i === "string" ? i : i.name);
+      const backendNames = backendHints.length === 0 ? backendsSortedByPriority : backendHints;
+      let backend;
+      const errors = [];
+      const availableBackendNames = /* @__PURE__ */ new Set();
+      for (const backendName of backendNames) {
+        const resolveResult = await tryResolveAndInitializeBackend(backendName);
+        if (typeof resolveResult === "string") {
+          errors.push({ name: backendName, err: resolveResult });
+        } else {
+          if (!backend) {
+            backend = resolveResult;
+          }
+          if (backend === resolveResult) {
+            availableBackendNames.add(backendName);
+          }
+        }
+      }
+      if (!backend) {
+        throw new Error(`no available backend found. ERR: ${errors.map((e) => `[${e.name}] ${e.err}`).join(", ")}`);
+      }
+      for (const { name, err } of errors) {
+        if (backendHints.includes(name)) {
+          console.warn(`removing requested execution provider "${name}" from session options because it is not available: ${err}`);
+        }
+      }
+      const filteredEps = eps.filter((i) => availableBackendNames.has(typeof i === "string" ? i : i.name));
+      return [
+        backend,
+        new Proxy(options, {
+          get: (target, prop) => {
+            if (prop === "executionProviders") {
+              return filteredEps;
+            }
+            return Reflect.get(target, prop);
+          }
+        })
+      ];
+    };
+  }
+});
+
+// common/dist/esm/backend.js
+var init_backend = __esm({
+  "common/dist/esm/backend.js"() {
+    "use strict";
+    init_backend_impl();
+  }
+});
+
+// common/dist/esm/version.js
+var version;
+var init_version = __esm({
+  "common/dist/esm/version.js"() {
+    "use strict";
+    version = "1.26.0";
+  }
+});
+
+// common/dist/esm/env-impl.js
+var logLevelValue, env;
+var init_env_impl = __esm({
+  "common/dist/esm/env-impl.js"() {
+    "use strict";
+    init_version();
+    logLevelValue = "warning";
+    env = {
+      wasm: {},
+      webgl: {},
+      webgpu: {},
+      versions: { common: version },
+      set logLevel(value) {
+        if (value === void 0) {
+          return;
+        }
+        if (typeof value !== "string" || ["verbose", "info", "warning", "error", "fatal"].indexOf(value) === -1) {
+          throw new Error(`Unsupported logging level: ${value}`);
+        }
+        logLevelValue = value;
+      },
+      get logLevel() {
+        return logLevelValue;
+      }
+    };
+    Object.defineProperty(env, "logLevel", { enumerable: true });
+  }
+});
+
+// common/dist/esm/env.js
+var env2;
+var init_env = __esm({
+  "common/dist/esm/env.js"() {
+    "use strict";
+    init_env_impl();
+    env2 = env;
+  }
+});
+
+// common/dist/esm/tensor-conversion-impl.js
+var tensorToDataURL, tensorToImageData;
+var init_tensor_conversion_impl = __esm({
+  "common/dist/esm/tensor-conversion-impl.js"() {
+    "use strict";
+    tensorToDataURL = (tensor, options) => {
+      const canvas = typeof document !== "undefined" ? document.createElement("canvas") : new OffscreenCanvas(1, 1);
+      canvas.width = tensor.dims[3];
+      canvas.height = tensor.dims[2];
+      const pixels2DContext = canvas.getContext("2d");
+      if (pixels2DContext != null) {
+        let width;
+        let height;
+        if (options?.tensorLayout !== void 0 && options.tensorLayout === "NHWC") {
+          width = tensor.dims[2];
+          height = tensor.dims[3];
+        } else {
+          width = tensor.dims[3];
+          height = tensor.dims[2];
+        }
+        const inputformat = options?.format !== void 0 ? options.format : "RGB";
+        const norm = options?.norm;
+        let normMean;
+        let normBias;
+        if (norm === void 0 || norm.mean === void 0) {
+          normMean = [255, 255, 255, 255];
+        } else {
+          if (typeof norm.mean === "number") {
+            normMean = [norm.mean, norm.mean, norm.mean, norm.mean];
+          } else {
+            normMean = [norm.mean[0], norm.mean[1], norm.mean[2], 0];
+            if (norm.mean[3] !== void 0) {
+              normMean[3] = norm.mean[3];
+            }
+          }
+        }
+        if (norm === void 0 || norm.bias === void 0) {
+          normBias = [0, 0, 0, 0];
+        } else {
+          if (typeof norm.bias === "number") {
+            normBias = [norm.bias, norm.bias, norm.bias, norm.bias];
+          } else {
+            normBias = [norm.bias[0], norm.bias[1], norm.bias[2], 0];
+            if (norm.bias[3] !== void 0) {
+              normBias[3] = norm.bias[3];
+            }
+          }
+        }
+        const stride = height * width;
+        let rTensorPointer = 0, gTensorPointer = stride, bTensorPointer = stride * 2, aTensorPointer = -1;
+        if (inputformat === "RGBA") {
+          rTensorPointer = 0;
+          gTensorPointer = stride;
+          bTensorPointer = stride * 2;
+          aTensorPointer = stride * 3;
+        } else if (inputformat === "RGB") {
+          rTensorPointer = 0;
+          gTensorPointer = stride;
+          bTensorPointer = stride * 2;
+        } else if (inputformat === "RBG") {
+          rTensorPointer = 0;
+          bTensorPointer = stride;
+          gTensorPointer = stride * 2;
+        }
+        for (let i = 0; i < height; i++) {
+          for (let j = 0; j < width; j++) {
+            const R = (tensor.data[rTensorPointer++] - normBias[0]) * normMean[0];
+            const G = (tensor.data[gTensorPointer++] - normBias[1]) * normMean[1];
+            const B = (tensor.data[bTensorPointer++] - normBias[2]) * normMean[2];
+            const A = aTensorPointer === -1 ? 255 : (tensor.data[aTensorPointer++] - normBias[3]) * normMean[3];
+            pixels2DContext.fillStyle = "rgba(" + R + "," + G + "," + B + "," + A + ")";
+            pixels2DContext.fillRect(j, i, 1, 1);
+          }
+        }
+        if ("toDataURL" in canvas) {
+          return canvas.toDataURL();
+        } else {
+          throw new Error("toDataURL is not supported");
+        }
+      } else {
+        throw new Error("Can not access image data");
+      }
+    };
+    tensorToImageData = (tensor, options) => {
+      const pixels2DContext = typeof document !== "undefined" ? document.createElement("canvas").getContext("2d") : new OffscreenCanvas(1, 1).getContext("2d");
+      let image;
+      if (pixels2DContext != null) {
+        let width;
+        let height;
+        let channels;
+        if (options?.tensorLayout !== void 0 && options.tensorLayout === "NHWC") {
+          width = tensor.dims[2];
+          height = tensor.dims[1];
+          channels = tensor.dims[3];
+        } else {
+          width = tensor.dims[3];
+          height = tensor.dims[2];
+          channels = tensor.dims[1];
+        }
+        const inputformat = options !== void 0 ? options.format !== void 0 ? options.format : "RGB" : "RGB";
+        const norm = options?.norm;
+        let normMean;
+        let normBias;
+        if (norm === void 0 || norm.mean === void 0) {
+          normMean = [255, 255, 255, 255];
+        } else {
+          if (typeof norm.mean === "number") {
+            normMean = [norm.mean, norm.mean, norm.mean, norm.mean];
+          } else {
+            normMean = [norm.mean[0], norm.mean[1], norm.mean[2], 255];
+            if (norm.mean[3] !== void 0) {
+              normMean[3] = norm.mean[3];
+            }
+          }
+        }
+        if (norm === void 0 || norm.bias === void 0) {
+          normBias = [0, 0, 0, 0];
+        } else {
+          if (typeof norm.bias === "number") {
+            normBias = [norm.bias, norm.bias, norm.bias, norm.bias];
+          } else {
+            normBias = [norm.bias[0], norm.bias[1], norm.bias[2], 0];
+            if (norm.bias[3] !== void 0) {
+              normBias[3] = norm.bias[3];
+            }
+          }
+        }
+        const stride = height * width;
+        if (options !== void 0) {
+          if (options.format !== void 0 && channels === 4 && options.format !== "RGBA" || channels === 3 && options.format !== "RGB" && options.format !== "BGR") {
+            throw new Error("Tensor format doesn't match input tensor dims");
+          }
+        }
+        const step = 4;
+        let rImagePointer = 0, gImagePointer = 1, bImagePointer = 2, aImagePointer = 3;
+        let rTensorPointer = 0, gTensorPointer = stride, bTensorPointer = stride * 2, aTensorPointer = -1;
+        if (inputformat === "RGBA") {
+          rTensorPointer = 0;
+          gTensorPointer = stride;
+          bTensorPointer = stride * 2;
+          aTensorPointer = stride * 3;
+        } else if (inputformat === "RGB") {
+          rTensorPointer = 0;
+          gTensorPointer = stride;
+          bTensorPointer = stride * 2;
+        } else if (inputformat === "RBG") {
+          rTensorPointer = 0;
+          bTensorPointer = stride;
+          gTensorPointer = stride * 2;
+        }
+        image = pixels2DContext.createImageData(width, height);
+        for (let i = 0; i < height * width; rImagePointer += step, gImagePointer += step, bImagePointer += step, aImagePointer += step, i++) {
+          image.data[rImagePointer] = (tensor.data[rTensorPointer++] - normBias[0]) * normMean[0];
+          image.data[gImagePointer] = (tensor.data[gTensorPointer++] - normBias[1]) * normMean[1];
+          image.data[bImagePointer] = (tensor.data[bTensorPointer++] - normBias[2]) * normMean[2];
+          image.data[aImagePointer] = aTensorPointer === -1 ? 255 : (tensor.data[aTensorPointer++] - normBias[3]) * normMean[3];
+        }
+      } else {
+        throw new Error("Can not access image data");
+      }
+      return image;
+    };
+  }
+});
+
+// common/dist/esm/tensor-factory-impl.js
+var bufferToTensor, tensorFromImage, tensorFromTexture, tensorFromGpuBuffer, tensorFromMLTensor, tensorFromPinnedBuffer;
+var init_tensor_factory_impl = __esm({
+  "common/dist/esm/tensor-factory-impl.js"() {
+    "use strict";
+    init_tensor_impl();
+    bufferToTensor = (buffer, options) => {
+      if (buffer === void 0) {
+        throw new Error("Image buffer must be defined");
+      }
+      if (options.height === void 0 || options.width === void 0) {
+        throw new Error("Image height and width must be defined");
+      }
+      if (options.tensorLayout === "NHWC") {
+        throw new Error("NHWC Tensor layout is not supported yet");
+      }
+      const { height, width } = options;
+      const norm = options.norm ?? { mean: 255, bias: 0 };
+      let normMean;
+      let normBias;
+      if (typeof norm.mean === "number") {
+        normMean = [norm.mean, norm.mean, norm.mean, norm.mean];
+      } else {
+        normMean = [norm.mean[0], norm.mean[1], norm.mean[2], norm.mean[3] ?? 255];
+      }
+      if (typeof norm.bias === "number") {
+        normBias = [norm.bias, norm.bias, norm.bias, norm.bias];
+      } else {
+        normBias = [norm.bias[0], norm.bias[1], norm.bias[2], norm.bias[3] ?? 0];
+      }
+      const inputformat = options.format !== void 0 ? options.format : "RGBA";
+      const outputformat = options.tensorFormat !== void 0 ? options.tensorFormat !== void 0 ? options.tensorFormat : "RGB" : "RGB";
+      const stride = height * width;
+      const float32Data = outputformat === "RGBA" ? new Float32Array(stride * 4) : new Float32Array(stride * 3);
+      let step = 4, rImagePointer = 0, gImagePointer = 1, bImagePointer = 2, aImagePointer = 3;
+      let rTensorPointer = 0, gTensorPointer = stride, bTensorPointer = stride * 2, aTensorPointer = -1;
+      if (inputformat === "RGB") {
+        step = 3;
+        rImagePointer = 0;
+        gImagePointer = 1;
+        bImagePointer = 2;
+        aImagePointer = -1;
+      }
+      if (outputformat === "RGBA") {
+        aTensorPointer = stride * 3;
+      } else if (outputformat === "RBG") {
+        rTensorPointer = 0;
+        bTensorPointer = stride;
+        gTensorPointer = stride * 2;
+      } else if (outputformat === "BGR") {
+        bTensorPointer = 0;
+        gTensorPointer = stride;
+        rTensorPointer = stride * 2;
+      }
+      for (let i = 0; i < stride; i++, rImagePointer += step, bImagePointer += step, gImagePointer += step, aImagePointer += step) {
+        float32Data[rTensorPointer++] = (buffer[rImagePointer] + normBias[0]) / normMean[0];
+        float32Data[gTensorPointer++] = (buffer[gImagePointer] + normBias[1]) / normMean[1];
+        float32Data[bTensorPointer++] = (buffer[bImagePointer] + normBias[2]) / normMean[2];
+        if (aTensorPointer !== -1 && aImagePointer !== -1) {
+          float32Data[aTensorPointer++] = (buffer[aImagePointer] + normBias[3]) / normMean[3];
+        }
+      }
+      const outputTensor = outputformat === "RGBA" ? new Tensor("float32", float32Data, [1, 4, height, width]) : new Tensor("float32", float32Data, [1, 3, height, width]);
+      return outputTensor;
+    };
+    tensorFromImage = async (image, options) => {
+      const isHTMLImageEle = typeof HTMLImageElement !== "undefined" && image instanceof HTMLImageElement;
+      const isImageDataEle = typeof ImageData !== "undefined" && image instanceof ImageData;
+      const isImageBitmap = typeof ImageBitmap !== "undefined" && image instanceof ImageBitmap;
+      const isString = typeof image === "string";
+      let data;
+      let bufferToTensorOptions = options ?? {};
+      const createCanvas = () => {
+        if (typeof document !== "undefined") {
+          return document.createElement("canvas");
+        } else if (typeof OffscreenCanvas !== "undefined") {
+          return new OffscreenCanvas(1, 1);
+        } else {
+          throw new Error("Canvas is not supported");
+        }
+      };
+      const createCanvasContext = (canvas) => {
+        if (typeof HTMLCanvasElement !== "undefined" && canvas instanceof HTMLCanvasElement) {
+          return canvas.getContext("2d");
+        } else if (canvas instanceof OffscreenCanvas) {
+          return canvas.getContext("2d");
+        } else {
+          return null;
+        }
+      };
+      if (isHTMLImageEle) {
+        const canvas = createCanvas();
+        canvas.width = image.width;
+        canvas.height = image.height;
+        const pixels2DContext = createCanvasContext(canvas);
+        if (pixels2DContext != null) {
+          let height = image.height;
+          let width = image.width;
+          if (options !== void 0 && options.resizedHeight !== void 0 && options.resizedWidth !== void 0) {
+            height = options.resizedHeight;
+            width = options.resizedWidth;
+          }
+          if (options !== void 0) {
+            bufferToTensorOptions = options;
+            if (options.tensorFormat !== void 0) {
+              throw new Error("Image input config format must be RGBA for HTMLImageElement");
+            } else {
+              bufferToTensorOptions.tensorFormat = "RGBA";
+            }
+            bufferToTensorOptions.height = height;
+            bufferToTensorOptions.width = width;
+          } else {
+            bufferToTensorOptions.tensorFormat = "RGBA";
+            bufferToTensorOptions.height = height;
+            bufferToTensorOptions.width = width;
+          }
+          pixels2DContext.drawImage(image, 0, 0);
+          data = pixels2DContext.getImageData(0, 0, width, height).data;
+        } else {
+          throw new Error("Can not access image data");
+        }
+      } else if (isImageDataEle) {
+        let height;
+        let width;
+        if (options !== void 0 && options.resizedWidth !== void 0 && options.resizedHeight !== void 0) {
+          height = options.resizedHeight;
+          width = options.resizedWidth;
+        } else {
+          height = image.height;
+          width = image.width;
+        }
+        if (options !== void 0) {
+          bufferToTensorOptions = options;
+        }
+        bufferToTensorOptions.format = "RGBA";
+        bufferToTensorOptions.height = height;
+        bufferToTensorOptions.width = width;
+        if (options !== void 0) {
+          const tempCanvas = createCanvas();
+          tempCanvas.width = width;
+          tempCanvas.height = height;
+          const pixels2DContext = createCanvasContext(tempCanvas);
+          if (pixels2DContext != null) {
+            pixels2DContext.putImageData(image, 0, 0);
+            data = pixels2DContext.getImageData(0, 0, width, height).data;
+          } else {
+            throw new Error("Can not access image data");
+          }
+        } else {
+          data = image.data;
+        }
+      } else if (isImageBitmap) {
+        if (options === void 0) {
+          throw new Error("Please provide image config with format for Imagebitmap");
+        }
+        const canvas = createCanvas();
+        canvas.width = image.width;
+        canvas.height = image.height;
+        const pixels2DContext = createCanvasContext(canvas);
+        if (pixels2DContext != null) {
+          const height = image.height;
+          const width = image.width;
+          pixels2DContext.drawImage(image, 0, 0, width, height);
+          data = pixels2DContext.getImageData(0, 0, width, height).data;
+          bufferToTensorOptions.height = height;
+          bufferToTensorOptions.width = width;
+          return bufferToTensor(data, bufferToTensorOptions);
+        } else {
+          throw new Error("Can not access image data");
+        }
+      } else if (isString) {
+        return new Promise((resolve, reject) => {
+          const canvas = createCanvas();
+          const context = createCanvasContext(canvas);
+          if (!image || !context) {
+            return reject();
+          }
+          const newImage = new Image();
+          newImage.crossOrigin = "Anonymous";
+          newImage.src = image;
+          newImage.onload = () => {
+            canvas.width = newImage.width;
+            canvas.height = newImage.height;
+            context.drawImage(newImage, 0, 0, canvas.width, canvas.height);
+            const img = context.getImageData(0, 0, canvas.width, canvas.height);
+            bufferToTensorOptions.height = canvas.height;
+            bufferToTensorOptions.width = canvas.width;
+            resolve(bufferToTensor(img.data, bufferToTensorOptions));
+          };
+        });
+      } else {
+        throw new Error("Input data provided is not supported - aborted tensor creation");
+      }
+      if (data !== void 0) {
+        return bufferToTensor(data, bufferToTensorOptions);
+      } else {
+        throw new Error("Input data provided is not supported - aborted tensor creation");
+      }
+    };
+    tensorFromTexture = (texture, options) => {
+      const { width, height, download, dispose } = options;
+      const dims = [1, height, width, 4];
+      return new Tensor({ location: "texture", type: "float32", texture, dims, download, dispose });
+    };
+    tensorFromGpuBuffer = (gpuBuffer, options) => {
+      const { dataType, dims, download, dispose } = options;
+      return new Tensor({ location: "gpu-buffer", type: dataType ?? "float32", gpuBuffer, dims, download, dispose });
+    };
+    tensorFromMLTensor = (mlTensor, options) => {
+      const { dataType, dims, download, dispose } = options;
+      return new Tensor({ location: "ml-tensor", type: dataType ?? "float32", mlTensor, dims, download, dispose });
+    };
+    tensorFromPinnedBuffer = (type, buffer, dims) => new Tensor({ location: "cpu-pinned", type, data: buffer, dims: dims ?? [buffer.length] });
+  }
+});
+
+// common/dist/esm/tensor-impl-type-mapping.js
+var NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP, NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP, isTypedArrayChecked, checkTypedArray;
+var init_tensor_impl_type_mapping = __esm({
+  "common/dist/esm/tensor-impl-type-mapping.js"() {
+    "use strict";
+    NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP = /* @__PURE__ */ new Map([
+      ["float32", Float32Array],
+      ["uint8", Uint8Array],
+      ["int8", Int8Array],
+      ["uint16", Uint16Array],
+      ["int16", Int16Array],
+      ["int32", Int32Array],
+      ["bool", Uint8Array],
+      ["float64", Float64Array],
+      ["uint32", Uint32Array],
+      ["int4", Uint8Array],
+      ["uint4", Uint8Array]
+    ]);
+    NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP = /* @__PURE__ */ new Map([
+      [Float32Array, "float32"],
+      [Uint8Array, "uint8"],
+      [Int8Array, "int8"],
+      [Uint16Array, "uint16"],
+      [Int16Array, "int16"],
+      [Int32Array, "int32"],
+      [Float64Array, "float64"],
+      [Uint32Array, "uint32"]
+    ]);
+    isTypedArrayChecked = false;
+    checkTypedArray = () => {
+      if (!isTypedArrayChecked) {
+        isTypedArrayChecked = true;
+        const isBigInt64ArrayAvailable = typeof BigInt64Array !== "undefined" && BigInt64Array.from;
+        const isBigUint64ArrayAvailable = typeof BigUint64Array !== "undefined" && BigUint64Array.from;
+        const Float16Array2 = globalThis.Float16Array;
+        const isFloat16ArrayAvailable = typeof Float16Array2 !== "undefined" && Float16Array2.from;
+        if (isBigInt64ArrayAvailable) {
+          NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set("int64", BigInt64Array);
+          NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.set(BigInt64Array, "int64");
+        }
+        if (isBigUint64ArrayAvailable) {
+          NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set("uint64", BigUint64Array);
+          NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.set(BigUint64Array, "uint64");
+        }
+        if (isFloat16ArrayAvailable) {
+          NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set("float16", Float16Array2);
+          NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.set(Float16Array2, "float16");
+        } else {
+          NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set("float16", Uint16Array);
+        }
+      }
+    };
+  }
+});
+
+// common/dist/esm/tensor-utils-impl.js
+var calculateSize, tensorReshape;
+var init_tensor_utils_impl = __esm({
+  "common/dist/esm/tensor-utils-impl.js"() {
+    "use strict";
+    init_tensor_impl();
+    calculateSize = (dims) => {
+      let size = 1;
+      for (let i = 0; i < dims.length; i++) {
+        const dim = dims[i];
+        if (typeof dim !== "number" || !Number.isSafeInteger(dim)) {
+          throw new TypeError(`dims[${i}] must be an integer, got: ${dim}`);
+        }
+        if (dim < 0) {
+          throw new RangeError(`dims[${i}] must be a non-negative integer, got: ${dim}`);
+        }
+        size *= dim;
+      }
+      return size;
+    };
+    tensorReshape = (tensor, dims) => {
+      switch (tensor.location) {
+        case "cpu":
+          return new Tensor(tensor.type, tensor.data, dims);
+        case "cpu-pinned":
+          return new Tensor({
+            location: "cpu-pinned",
+            data: tensor.data,
+            type: tensor.type,
+            dims
+          });
+        case "texture":
+          return new Tensor({
+            location: "texture",
+            texture: tensor.texture,
+            type: tensor.type,
+            dims
+          });
+        case "gpu-buffer":
+          return new Tensor({
+            location: "gpu-buffer",
+            gpuBuffer: tensor.gpuBuffer,
+            type: tensor.type,
+            dims
+          });
+        case "ml-tensor":
+          return new Tensor({
+            location: "ml-tensor",
+            mlTensor: tensor.mlTensor,
+            type: tensor.type,
+            dims
+          });
+        default:
+          throw new Error(`tensorReshape: tensor location ${tensor.location} is not supported`);
+      }
+    };
+  }
+});
+
+// common/dist/esm/tensor-impl.js
+var Tensor;
+var init_tensor_impl = __esm({
+  "common/dist/esm/tensor-impl.js"() {
+    "use strict";
+    init_tensor_conversion_impl();
+    init_tensor_factory_impl();
+    init_tensor_impl_type_mapping();
+    init_tensor_utils_impl();
+    Tensor = class {
+      /**
+       * implementation.
+       */
+      constructor(arg0, arg1, arg2) {
+        checkTypedArray();
+        let type;
+        let dims;
+        if (typeof arg0 === "object" && "location" in arg0) {
+          this.dataLocation = arg0.location;
+          type = arg0.type;
+          dims = arg0.dims;
+          switch (arg0.location) {
+            case "cpu-pinned": {
+              const expectedTypedArrayConstructor = NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.get(type);
+              if (!expectedTypedArrayConstructor) {
+                throw new TypeError(`unsupported type "${type}" to create tensor from pinned buffer`);
+              }
+              if (!(arg0.data instanceof expectedTypedArrayConstructor)) {
+                throw new TypeError(`buffer should be of type ${expectedTypedArrayConstructor.name}`);
+              }
+              this.cpuData = arg0.data;
+              break;
+            }
+            case "texture": {
+              if (type !== "float32") {
+                throw new TypeError(`unsupported type "${type}" to create tensor from texture`);
+              }
+              this.gpuTextureData = arg0.texture;
+              this.downloader = arg0.download;
+              this.disposer = arg0.dispose;
+              break;
+            }
+            case "gpu-buffer": {
+              if (type !== "float32" && type !== "float16" && type !== "int32" && type !== "int64" && type !== "uint32" && type !== "uint8" && type !== "bool" && type !== "uint4" && type !== "int4") {
+                throw new TypeError(`unsupported type "${type}" to create tensor from gpu buffer`);
+              }
+              this.gpuBufferData = arg0.gpuBuffer;
+              this.downloader = arg0.download;
+              this.disposer = arg0.dispose;
+              break;
+            }
+            case "ml-tensor": {
+              if (type !== "float32" && type !== "float16" && type !== "int32" && type !== "int64" && type !== "uint32" && type !== "uint64" && type !== "int8" && type !== "uint8" && type !== "bool" && type !== "uint4" && type !== "int4") {
+                throw new TypeError(`unsupported type "${type}" to create tensor from MLTensor`);
+              }
+              this.mlTensorData = arg0.mlTensor;
+              this.downloader = arg0.download;
+              this.disposer = arg0.dispose;
+              break;
+            }
+            default:
+              throw new Error(`Tensor constructor: unsupported location '${this.dataLocation}'`);
+          }
+        } else {
+          let data;
+          let maybeDims;
+          if (typeof arg0 === "string") {
+            type = arg0;
+            maybeDims = arg2;
+            if (arg0 === "string") {
+              if (!Array.isArray(arg1)) {
+                throw new TypeError("A string tensor's data must be a string array.");
+              }
+              data = arg1;
+            } else {
+              const typedArrayConstructor = NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.get(arg0);
+              if (typedArrayConstructor === void 0) {
+                throw new TypeError(`Unsupported tensor type: ${arg0}.`);
+              }
+              if (Array.isArray(arg1)) {
+                if (arg0 === "float16" && typedArrayConstructor === Uint16Array || arg0 === "uint4" || arg0 === "int4") {
+                  throw new TypeError(`Creating a ${arg0} tensor from number array is not supported. Please use ${typedArrayConstructor.name} as data.`);
+                } else if (arg0 === "uint64" || arg0 === "int64") {
+                  data = typedArrayConstructor.from(arg1, BigInt);
+                } else {
+                  data = typedArrayConstructor.from(arg1);
+                }
+              } else if (arg1 instanceof typedArrayConstructor) {
+                data = arg1;
+              } else if (arg1 instanceof Uint8ClampedArray) {
+                if (arg0 === "uint8") {
+                  data = Uint8Array.from(arg1);
+                } else {
+                  throw new TypeError(`A Uint8ClampedArray tensor's data must be type of uint8`);
+                }
+              } else if (arg0 === "float16" && arg1 instanceof Uint16Array && typedArrayConstructor !== Uint16Array) {
+                data = new globalThis.Float16Array(arg1.buffer, arg1.byteOffset, arg1.length);
+              } else {
+                throw new TypeError(`A ${type} tensor's data must be type of ${typedArrayConstructor}`);
+              }
+            }
+          } else {
+            maybeDims = arg1;
+            if (Array.isArray(arg0)) {
+              if (arg0.length === 0) {
+                throw new TypeError("Tensor type cannot be inferred from an empty array.");
+              }
+              const firstElementType = typeof arg0[0];
+              if (firstElementType === "string") {
+                type = "string";
+                data = arg0;
+              } else if (firstElementType === "boolean") {
+                type = "bool";
+                data = Uint8Array.from(arg0);
+              } else {
+                throw new TypeError(`Invalid element type of data array: ${firstElementType}.`);
+              }
+            } else if (arg0 instanceof Uint8ClampedArray) {
+              type = "uint8";
+              data = Uint8Array.from(arg0);
+            } else {
+              const mappedType = NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.get(arg0.constructor);
+              if (mappedType === void 0) {
+                throw new TypeError(`Unsupported type for tensor data: ${arg0.constructor}.`);
+              }
+              type = mappedType;
+              data = arg0;
+            }
+          }
+          if (maybeDims === void 0) {
+            maybeDims = [data.length];
+          } else if (!Array.isArray(maybeDims)) {
+            throw new TypeError("A tensor's dims must be a number array");
+          }
+          dims = maybeDims;
+          this.cpuData = data;
+          this.dataLocation = "cpu";
+        }
+        const size = calculateSize(dims);
+        if (this.cpuData && size !== this.cpuData.length) {
+          if ((type === "uint4" || type === "int4") && Math.ceil(size / 2) === this.cpuData.length) {
+          } else {
+            throw new Error(`Tensor's size(${size}) does not match data length(${this.cpuData.length}).`);
+          }
+        }
+        this.type = type;
+        this.dims = dims;
+        this.size = size;
+      }
+      // #endregion
+      // #region factory
+      static async fromImage(image, options) {
+        return tensorFromImage(image, options);
+      }
+      static fromTexture(texture, options) {
+        return tensorFromTexture(texture, options);
+      }
+      static fromGpuBuffer(gpuBuffer, options) {
+        return tensorFromGpuBuffer(gpuBuffer, options);
+      }
+      static fromMLTensor(mlTensor, options) {
+        return tensorFromMLTensor(mlTensor, options);
+      }
+      static fromPinnedBuffer(type, buffer, dims) {
+        return tensorFromPinnedBuffer(type, buffer, dims);
+      }
+      // #endregion
+      // #region conversions
+      toDataURL(options) {
+        return tensorToDataURL(this, options);
+      }
+      toImageData(options) {
+        return tensorToImageData(this, options);
+      }
+      // #endregion
+      // #region properties
+      get data() {
+        this.ensureValid();
+        if (!this.cpuData) {
+          throw new Error("The data is not on CPU. Use `getData()` to download GPU data to CPU, or use `texture` or `gpuBuffer` property to access the GPU data directly.");
+        }
+        return this.cpuData;
+      }
+      get location() {
+        return this.dataLocation;
+      }
+      get texture() {
+        this.ensureValid();
+        if (!this.gpuTextureData) {
+          throw new Error("The data is not stored as a WebGL texture.");
+        }
+        return this.gpuTextureData;
+      }
+      get gpuBuffer() {
+        this.ensureValid();
+        if (!this.gpuBufferData) {
+          throw new Error("The data is not stored as a WebGPU buffer.");
+        }
+        return this.gpuBufferData;
+      }
+      get mlTensor() {
+        this.ensureValid();
+        if (!this.mlTensorData) {
+          throw new Error("The data is not stored as a WebNN MLTensor.");
+        }
+        return this.mlTensorData;
+      }
+      // #endregion
+      // #region methods
+      async getData(releaseData) {
+        this.ensureValid();
+        switch (this.dataLocation) {
+          case "cpu":
+          case "cpu-pinned":
+            return this.data;
+          case "texture":
+          case "gpu-buffer":
+          case "ml-tensor": {
+            if (!this.downloader) {
+              throw new Error("The current tensor is not created with a specified data downloader.");
+            }
+            if (this.isDownloading) {
+              throw new Error("The current tensor is being downloaded.");
+            }
+            try {
+              this.isDownloading = true;
+              const data = await this.downloader();
+              this.downloader = void 0;
+              this.dataLocation = "cpu";
+              this.cpuData = data;
+              if (releaseData && this.disposer) {
+                this.disposer();
+                this.disposer = void 0;
+              }
+              return data;
+            } finally {
+              this.isDownloading = false;
+            }
+          }
+          default:
+            throw new Error(`cannot get data from location: ${this.dataLocation}`);
+        }
+      }
+      dispose() {
+        if (this.isDownloading) {
+          throw new Error("The current tensor is being downloaded.");
+        }
+        if (this.disposer) {
+          this.disposer();
+          this.disposer = void 0;
+        }
+        this.cpuData = void 0;
+        this.gpuTextureData = void 0;
+        this.gpuBufferData = void 0;
+        this.mlTensorData = void 0;
+        this.downloader = void 0;
+        this.isDownloading = void 0;
+        this.dataLocation = "none";
+      }
+      // #endregion
+      // #region tensor utilities
+      ensureValid() {
+        if (this.dataLocation === "none") {
+          throw new Error("The tensor is disposed.");
+        }
+      }
+      reshape(dims) {
+        this.ensureValid();
+        if (this.downloader || this.disposer) {
+          throw new Error("Cannot reshape a tensor that owns GPU resource.");
+        }
+        return tensorReshape(this, dims);
+      }
+    };
+  }
+});
+
+// common/dist/esm/tensor.js
+var Tensor2;
+var init_tensor = __esm({
+  "common/dist/esm/tensor.js"() {
+    "use strict";
+    init_tensor_impl();
+    Tensor2 = Tensor;
+  }
+});
+
+// common/dist/esm/trace.js
+var TRACE, TRACE_FUNC, TRACE_FUNC_BEGIN, TRACE_FUNC_END, TRACE_EVENT_BEGIN, TRACE_EVENT_END;
+var init_trace = __esm({
+  "common/dist/esm/trace.js"() {
+    "use strict";
+    init_env_impl();
+    TRACE = (deviceType, label) => {
+      if (typeof env.trace === "undefined" ? !env.wasm.trace : !env.trace) {
+        return;
+      }
+      console.timeStamp(`${deviceType}::ORT::${label}`);
+    };
+    TRACE_FUNC = (msg, extraMsg) => {
+      const stack = new Error().stack?.split(/\r\n|\r|\n/g) || [];
+      let hasTraceFunc = false;
+      for (let i = 0; i < stack.length; i++) {
+        if (hasTraceFunc && !stack[i].includes("TRACE_FUNC")) {
+          let label = `FUNC_${msg}::${stack[i].trim().split(" ")[1]}`;
+          if (extraMsg) {
+            label += `::${extraMsg}`;
+          }
+          TRACE("CPU", label);
+          return;
+        }
+        if (stack[i].includes("TRACE_FUNC")) {
+          hasTraceFunc = true;
+        }
+      }
+    };
+    TRACE_FUNC_BEGIN = (extraMsg) => {
+      if (typeof env.trace === "undefined" ? !env.wasm.trace : !env.trace) {
+        return;
+      }
+      TRACE_FUNC("BEGIN", extraMsg);
+    };
+    TRACE_FUNC_END = (extraMsg) => {
+      if (typeof env.trace === "undefined" ? !env.wasm.trace : !env.trace) {
+        return;
+      }
+      TRACE_FUNC("END", extraMsg);
+    };
+    TRACE_EVENT_BEGIN = (extraMsg) => {
+      if (typeof env.trace === "undefined" ? !env.wasm.trace : !env.trace) {
+        return;
+      }
+      console.time(`ORT::${extraMsg}`);
+    };
+    TRACE_EVENT_END = (extraMsg) => {
+      if (typeof env.trace === "undefined" ? !env.wasm.trace : !env.trace) {
+        return;
+      }
+      console.timeEnd(`ORT::${extraMsg}`);
+    };
+  }
+});
+
+// common/dist/esm/inference-session-impl.js
+var InferenceSession;
+var init_inference_session_impl = __esm({
+  "common/dist/esm/inference-session-impl.js"() {
+    "use strict";
+    init_backend_impl();
+    init_tensor();
+    init_trace();
+    InferenceSession = class _InferenceSession {
+      constructor(handler) {
+        this.handler = handler;
+      }
+      async run(feeds, arg1, arg2) {
+        TRACE_FUNC_BEGIN();
+        TRACE_EVENT_BEGIN("InferenceSession.run");
+        const fetches = {};
+        let options = {};
+        if (typeof feeds !== "object" || feeds === null || feeds instanceof Tensor2 || Array.isArray(feeds)) {
+          throw new TypeError("'feeds' must be an object that use input names as keys and OnnxValue as corresponding values.");
+        }
+        let isFetchesEmpty = true;
+        if (typeof arg1 === "object") {
+          if (arg1 === null) {
+            throw new TypeError("Unexpected argument[1]: cannot be null.");
+          }
+          if (arg1 instanceof Tensor2) {
+            throw new TypeError("'fetches' cannot be a Tensor");
+          }
+          if (Array.isArray(arg1)) {
+            if (arg1.length === 0) {
+              throw new TypeError("'fetches' cannot be an empty array.");
+            }
+            isFetchesEmpty = false;
+            for (const name of arg1) {
+              if (typeof name !== "string") {
+                throw new TypeError("'fetches' must be a string array or an object.");
+              }
+              if (this.outputNames.indexOf(name) === -1) {
+                throw new RangeError(`'fetches' contains invalid output name: ${name}.`);
+              }
+              fetches[name] = null;
+            }
+            if (typeof arg2 === "object" && arg2 !== null) {
+              options = arg2;
+            } else if (typeof arg2 !== "undefined") {
+              throw new TypeError("'options' must be an object.");
+            }
+          } else {
+            let isFetches = false;
+            const arg1Keys = Object.getOwnPropertyNames(arg1);
+            for (const name of this.outputNames) {
+              if (arg1Keys.indexOf(name) !== -1) {
+                const v = arg1[name];
+                if (v === null || v instanceof Tensor2) {
+                  isFetches = true;
+                  isFetchesEmpty = false;
+                  fetches[name] = v;
+                }
+              }
+            }
+            if (isFetches) {
+              if (typeof arg2 === "object" && arg2 !== null) {
+                options = arg2;
+              } else if (typeof arg2 !== "undefined") {
+                throw new TypeError("'options' must be an object.");
+              }
+            } else {
+              options = arg1;
+            }
+          }
+        } else if (typeof arg1 !== "undefined") {
+          throw new TypeError("Unexpected argument[1]: must be 'fetches' or 'options'.");
+        }
+        for (const name of this.inputNames) {
+          if (typeof feeds[name] === "undefined") {
+            throw new Error(`input '${name}' is missing in 'feeds'.`);
+          }
+        }
+        if (isFetchesEmpty) {
+          for (const name of this.outputNames) {
+            fetches[name] = null;
+          }
+        }
+        const results = await this.handler.run(feeds, fetches, options);
+        const returnValue = {};
+        for (const key in results) {
+          if (Object.hasOwnProperty.call(results, key)) {
+            const result = results[key];
+            if (result instanceof Tensor2) {
+              returnValue[key] = result;
+            } else {
+              returnValue[key] = new Tensor2(result.type, result.data, result.dims);
+            }
+          }
+        }
+        TRACE_EVENT_END("InferenceSession.run");
+        TRACE_FUNC_END();
+        return returnValue;
+      }
+      async release() {
+        return this.handler.dispose();
+      }
+      static async create(arg0, arg1, arg2, arg3) {
+        TRACE_FUNC_BEGIN();
+        TRACE_EVENT_BEGIN("InferenceSession.create");
+        let filePathOrUint8Array;
+        let options = {};
+        if (typeof arg0 === "string") {
+          filePathOrUint8Array = arg0;
+          if (typeof arg1 === "object" && arg1 !== null) {
+            options = arg1;
+          } else if (typeof arg1 !== "undefined") {
+            throw new TypeError("'options' must be an object.");
+          }
+        } else if (arg0 instanceof Uint8Array) {
+          filePathOrUint8Array = arg0;
+          if (typeof arg1 === "object" && arg1 !== null) {
+            options = arg1;
+          } else if (typeof arg1 !== "undefined") {
+            throw new TypeError("'options' must be an object.");
+          }
+        } else if (arg0 instanceof ArrayBuffer || typeof SharedArrayBuffer !== "undefined" && arg0 instanceof SharedArrayBuffer) {
+          const buffer = arg0;
+          let byteOffset = 0;
+          let byteLength = arg0.byteLength;
+          if (typeof arg1 === "object" && arg1 !== null) {
+            options = arg1;
+          } else if (typeof arg1 === "number") {
+            byteOffset = arg1;
+            if (!Number.isSafeInteger(byteOffset)) {
+              throw new RangeError("'byteOffset' must be an integer.");
+            }
+            if (byteOffset < 0 || byteOffset >= buffer.byteLength) {
+              throw new RangeError(`'byteOffset' is out of range [0, ${buffer.byteLength}).`);
+            }
+            byteLength = arg0.byteLength - byteOffset;
+            if (typeof arg2 === "number") {
+              byteLength = arg2;
+              if (!Number.isSafeInteger(byteLength)) {
+                throw new RangeError("'byteLength' must be an integer.");
+              }
+              if (byteLength <= 0 || byteOffset + byteLength > buffer.byteLength) {
+                throw new RangeError(`'byteLength' is out of range (0, ${buffer.byteLength - byteOffset}].`);
+              }
+              if (typeof arg3 === "object" && arg3 !== null) {
+                options = arg3;
+              } else if (typeof arg3 !== "undefined") {
+                throw new TypeError("'options' must be an object.");
+              }
+            } else if (typeof arg2 !== "undefined") {
+              throw new TypeError("'byteLength' must be a number.");
+            }
+          } else if (typeof arg1 !== "undefined") {
+            throw new TypeError("'options' must be an object.");
+          }
+          filePathOrUint8Array = new Uint8Array(buffer, byteOffset, byteLength);
+        } else {
+          throw new TypeError("Unexpected argument[0]: must be 'path' or 'buffer'.");
+        }
+        const [backend, optionsWithValidatedEPs] = await resolveBackendAndExecutionProviders(options);
+        const handler = await backend.createInferenceSessionHandler(filePathOrUint8Array, optionsWithValidatedEPs);
+        TRACE_EVENT_END("InferenceSession.create");
+        TRACE_FUNC_END();
+        return new _InferenceSession(handler);
+      }
+      startProfiling() {
+        this.handler.startProfiling();
+      }
+      endProfiling() {
+        this.handler.endProfiling();
+      }
+      get inputNames() {
+        return this.handler.inputNames;
+      }
+      get outputNames() {
+        return this.handler.outputNames;
+      }
+      get inputMetadata() {
+        return this.handler.inputMetadata;
+      }
+      get outputMetadata() {
+        return this.handler.outputMetadata;
+      }
+    };
+  }
+});
+
+// common/dist/esm/inference-session.js
+var InferenceSession2;
+var init_inference_session = __esm({
+  "common/dist/esm/inference-session.js"() {
+    "use strict";
+    init_inference_session_impl();
+    InferenceSession2 = InferenceSession;
+  }
+});
+
+// common/dist/esm/tensor-conversion.js
+var init_tensor_conversion = __esm({
+  "common/dist/esm/tensor-conversion.js"() {
+    "use strict";
+  }
+});
+
+// common/dist/esm/tensor-factory.js
+var init_tensor_factory = __esm({
+  "common/dist/esm/tensor-factory.js"() {
+    "use strict";
+  }
+});
+
+// common/dist/esm/onnx-model.js
+var init_onnx_model = __esm({
+  "common/dist/esm/onnx-model.js"() {
+    "use strict";
+  }
+});
+
+// common/dist/esm/onnx-value.js
+var init_onnx_value = __esm({
+  "common/dist/esm/onnx-value.js"() {
+    "use strict";
+  }
+});
+
+// common/dist/esm/index.js
+var esm_exports = {};
+__export(esm_exports, {
+  InferenceSession: () => InferenceSession2,
+  TRACE: () => TRACE,
+  TRACE_EVENT_BEGIN: () => TRACE_EVENT_BEGIN,
+  TRACE_EVENT_END: () => TRACE_EVENT_END,
+  TRACE_FUNC_BEGIN: () => TRACE_FUNC_BEGIN,
+  TRACE_FUNC_END: () => TRACE_FUNC_END,
+  Tensor: () => Tensor2,
+  env: () => env2,
+  registerBackend: () => registerBackend
+});
+var init_esm = __esm({
+  "common/dist/esm/index.js"() {
+    "use strict";
+    init_backend();
+    init_env();
+    init_inference_session();
+    init_tensor();
+    init_tensor_conversion();
+    init_tensor_factory();
+    init_trace();
+    init_onnx_model();
+    init_onnx_value();
+  }
+});
+
+// web/lib/wasm/wasm-utils-env.ts
+var isNode;
+var init_wasm_utils_env = __esm({
+  "web/lib/wasm/wasm-utils-env.ts"() {
+    "use strict";
+    isNode = false;
+  }
+});
+
+// web/lib/wasm/proxy-worker/main.ts
+var main_exports = {};
+__export(main_exports, {
+  default: () => main_default
+});
+var WORKER_NAME, isProxyWorker, main_default;
+var init_main = __esm({
+  "web/lib/wasm/proxy-worker/main.ts"() {
+    "use strict";
+    init_wasm_core_impl();
+    init_wasm_factory();
+    init_wasm_utils_import();
+    WORKER_NAME = "ort-wasm-proxy-worker";
+    isProxyWorker = globalThis.self?.name === WORKER_NAME;
+    if (isProxyWorker) {
+      self.onmessage = (ev) => {
+        const { type, in: message } = ev.data;
+        try {
+          switch (type) {
+            case "init-wasm":
+              initializeWebAssembly(message.wasm).then(
+                () => {
+                  initRuntime(message).then(
+                    () => {
+                      postMessage({ type });
+                    },
+                    (err) => {
+                      postMessage({ type, err });
+                    }
+                  );
+                },
+                (err) => {
+                  postMessage({ type, err });
+                }
+              );
+              break;
+            case "init-ep": {
+              const { epName, env: env3 } = message;
+              initEp(env3, epName).then(
+                () => {
+                  postMessage({ type });
+                },
+                (err) => {
+                  postMessage({ type, err });
+                }
+              );
+              break;
+            }
+            case "copy-from": {
+              const { buffer } = message;
+              const bufferData = copyFromExternalBuffer(buffer);
+              postMessage({ type, out: bufferData });
+              break;
+            }
+            case "create": {
+              const { model, options } = message;
+              createSession(model, options).then(
+                (sessionMetadata) => {
+                  postMessage({ type, out: sessionMetadata });
+                },
+                (err) => {
+                  postMessage({ type, err });
+                }
+              );
+              break;
+            }
+            case "release":
+              releaseSession(message);
+              postMessage({ type });
+              break;
+            case "run": {
+              const { sessionId, inputIndices, inputs, outputIndices, options } = message;
+              run(sessionId, inputIndices, inputs, outputIndices, new Array(outputIndices.length).fill(null), options).then(
+                (outputs) => {
+                  if (outputs.some((o) => o[3] !== "cpu")) {
+                    postMessage({ type, err: "Proxy does not support non-cpu tensor location." });
+                  } else {
+                    postMessage(
+                      { type, out: outputs },
+                      extractTransferableBuffers([...inputs, ...outputs])
+                    );
+                  }
+                },
+                (err) => {
+                  postMessage({ type, err });
+                }
+              );
+              break;
+            }
+            case "end-profiling":
+              endProfiling(message);
+              postMessage({ type });
+              break;
+            default:
+          }
+        } catch (err) {
+          postMessage({ type, err });
+        }
+      };
+    }
+    main_default = isProxyWorker ? null : (urlOverride) => new Worker(urlOverride ?? scriptSrc, { type: true ? "module" : "classic", name: WORKER_NAME });
+  }
+});
+
+// web/lib/wasm/wasm-utils-import.ts
+var origin, isEsmImportMetaUrlHardcodedAsFileUri, getScriptSrc, scriptSrc, inferWasmPathPrefixFromScriptSrc, isSameOrigin, normalizeUrl, fallbackUrl, preload, dynamicImportDefault, createProxyWorker, importProxyWorker, embeddedWasmModule, importWasmModule;
+var init_wasm_utils_import = __esm({
+  "web/lib/wasm/wasm-utils-import.ts"() {
+    "use strict";
+    init_wasm_utils_env();
+    origin = isNode || typeof location === "undefined" ? void 0 : location.origin;
+    isEsmImportMetaUrlHardcodedAsFileUri = import.meta.url > "file:" && import.meta.url < "file;";
+    getScriptSrc = () => {
+      if (isNode) {
+        return void 0;
+      }
+      if (true) {
+        if (isEsmImportMetaUrlHardcodedAsFileUri) {
+          const URL2 = URL;
+          return new URL(new URL2("ort.webgpu.mjs", import.meta.url).href, origin).href;
+        }
+        return import.meta.url;
+      }
+      return typeof document !== "undefined" ? document.currentScript?.src : (
+        // use `self.location.href` if available
+        typeof self !== "undefined" ? self.location?.href : void 0
+      );
+    };
+    scriptSrc = getScriptSrc();
+    inferWasmPathPrefixFromScriptSrc = () => {
+      if (scriptSrc && !scriptSrc.startsWith("blob:")) {
+        return scriptSrc.substring(0, scriptSrc.lastIndexOf("/") + 1);
+      }
+      return void 0;
+    };
+    isSameOrigin = (filename, prefixOverride) => {
+      try {
+        const baseUrl = prefixOverride ?? scriptSrc;
+        const url = baseUrl ? new URL(filename, baseUrl) : new URL(filename);
+        return url.origin === origin;
+      } catch {
+        return false;
+      }
+    };
+    normalizeUrl = (filename, prefixOverride) => {
+      const baseUrl = prefixOverride ?? scriptSrc;
+      try {
+        const url = baseUrl ? new URL(filename, baseUrl) : new URL(filename);
+        return url.href;
+      } catch {
+        return void 0;
+      }
+    };
+    fallbackUrl = (filename, prefixOverride) => `${prefixOverride ?? "./"}${filename}`;
+    preload = async (absoluteUrl) => {
+      const response = await fetch(absoluteUrl, { credentials: "same-origin" });
+      const blob = await response.blob();
+      return URL.createObjectURL(blob);
+    };
+    dynamicImportDefault = async (url) => (await import(
+      /* webpackIgnore: true */
+      /* @vite-ignore */
+      url
+    )).default;
+    createProxyWorker = // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires
+    false ? void 0 : (init_main(), __toCommonJS(main_exports)).default;
+    importProxyWorker = async () => {
+      if (!scriptSrc) {
+        throw new Error("Failed to load proxy worker: cannot determine the script source URL.");
+      }
+      if (isSameOrigin(scriptSrc)) {
+        return [void 0, createProxyWorker()];
+      }
+      const url = await preload(scriptSrc);
+      return [url, createProxyWorker(url)];
+    };
+    embeddedWasmModule = false ? (
+      // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires
+      (false ? null : false ? null : true ? null : null).default
+    ) : void 0;
+    importWasmModule = async (urlOverride, prefixOverride, isMultiThreaded, isWasmOverridden) => {
+      let useEmbeddedModule = embeddedWasmModule && !(urlOverride || prefixOverride);
+      if (useEmbeddedModule) {
+        if (!scriptSrc) {
+          if (isWasmOverridden && !isMultiThreaded) {
+            useEmbeddedModule = true;
+          } else {
+            throw new Error("cannot determine the script source URL.");
+          }
+        } else {
+          useEmbeddedModule = isSameOrigin(scriptSrc) || isWasmOverridden && !isMultiThreaded;
+        }
+      }
+      if (useEmbeddedModule) {
+        return [void 0, embeddedWasmModule];
+      } else {
+        const wasmModuleFilename = false ? "ort-wasm-simd-threaded.jsep.mjs" : false ? "ort-wasm-simd-threaded.jspi.mjs" : true ? "ort-wasm-simd-threaded.asyncify.mjs" : "ort-wasm-simd-threaded.mjs";
+        const wasmModuleUrl = urlOverride ?? normalizeUrl(wasmModuleFilename, prefixOverride);
+        const needPreload = !isNode && isMultiThreaded && wasmModuleUrl && !isSameOrigin(wasmModuleUrl, prefixOverride);
+        const url = needPreload ? await preload(wasmModuleUrl) : wasmModuleUrl ?? fallbackUrl(wasmModuleFilename, prefixOverride);
+        return [needPreload ? url : void 0, await dynamicImportDefault(url)];
+      }
+    };
+  }
+});
+
+// web/lib/wasm/wasm-factory.ts
+var wasm, initialized, initializing, aborted, isMultiThreadSupported, isSimdSupported, isRelaxedSimdSupported, initializeWebAssembly, getInstance;
+var init_wasm_factory = __esm({
+  "web/lib/wasm/wasm-factory.ts"() {
+    "use strict";
+    init_wasm_utils_import();
+    initialized = false;
+    initializing = false;
+    aborted = false;
+    isMultiThreadSupported = () => {
+      if (typeof SharedArrayBuffer === "undefined") {
+        return false;
+      }
+      try {
+        if (typeof MessageChannel !== "undefined") {
+          new MessageChannel().port1.postMessage(new SharedArrayBuffer(1));
+        }
+        return WebAssembly.validate(
+          new Uint8Array([
+            0,
+            97,
+            115,
+            109,
+            1,
+            0,
+            0,
+            0,
+            1,
+            4,
+            1,
+            96,
+            0,
+            0,
+            3,
+            2,
+            1,
+            0,
+            5,
+            4,
+            1,
+            3,
+            1,
+            1,
+            10,
+            11,
+            1,
+            9,
+            0,
+            65,
+            0,
+            254,
+            16,
+            2,
+            0,
+            26,
+            11
+          ])
+        );
+      } catch {
+        return false;
+      }
+    };
+    isSimdSupported = () => {
+      try {
+        return WebAssembly.validate(
+          new Uint8Array([
+            0,
+            97,
+            115,
+            109,
+            1,
+            0,
+            0,
+            0,
+            1,
+            4,
+            1,
+            96,
+            0,
+            0,
+            3,
+            2,
+            1,
+            0,
+            10,
+            30,
+            1,
+            28,
+            0,
+            65,
+            0,
+            253,
+            15,
+            253,
+            12,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            253,
+            186,
+            1,
+            26,
+            11
+          ])
+        );
+      } catch {
+        return false;
+      }
+    };
+    isRelaxedSimdSupported = () => {
+      try {
+        return WebAssembly.validate(
+          new Uint8Array([
+            0,
+            97,
+            115,
+            109,
+            1,
+            0,
+            0,
+            0,
+            1,
+            5,
+            1,
+            96,
+            0,
+            1,
+            123,
+            3,
+            2,
+            1,
+            0,
+            10,
+            19,
+            1,
+            17,
+            0,
+            65,
+            1,
+            253,
+            15,
+            65,
+            2,
+            253,
+            15,
+            65,
+            3,
+            253,
+            15,
+            253,
+            147,
+            2,
+            11
+          ])
+        );
+      } catch {
+        return false;
+      }
+    };
+    initializeWebAssembly = async (flags) => {
+      if (initialized) {
+        return Promise.resolve();
+      }
+      if (initializing) {
+        throw new Error("multiple calls to 'initializeWebAssembly()' detected.");
+      }
+      if (aborted) {
+        throw new Error("previous call to 'initializeWebAssembly()' failed.");
+      }
+      initializing = true;
+      const timeout = flags.initTimeout;
+      let numThreads = flags.numThreads;
+      if (flags.simd === false) {
+      } else if (flags.simd === "relaxed") {
+        if (!isRelaxedSimdSupported()) {
+          throw new Error("Relaxed WebAssembly SIMD is not supported in the current environment.");
+        }
+      } else if (!isSimdSupported()) {
+        throw new Error("WebAssembly SIMD is not supported in the current environment.");
+      }
+      if (false) {
+        if (!("Suspending" in WebAssembly)) {
+          throw new Error("WebAssembly JSPI is not supported in the current environment.");
+        }
+      }
+      const multiThreadSupported = isMultiThreadSupported();
+      if (numThreads > 1 && !multiThreadSupported) {
+        if (typeof self !== "undefined" && !self.crossOriginIsolated) {
+          console.warn(
+            "env.wasm.numThreads is set to " + numThreads + ", but this will not work unless you enable crossOriginIsolated mode. See https://web.dev/cross-origin-isolation-guide/ for more info."
+          );
+        }
+        console.warn(
+          "WebAssembly multi-threading is not supported in the current environment. Falling back to single-threading."
+        );
+        flags.numThreads = numThreads = 1;
+      }
+      const wasmPaths = flags.wasmPaths;
+      const wasmPrefixOverride = typeof wasmPaths === "string" ? wasmPaths : void 0;
+      const mjsPathOverrideFlag = wasmPaths?.mjs;
+      const mjsPathOverride = mjsPathOverrideFlag?.href ?? mjsPathOverrideFlag;
+      const wasmPathOverrideFlag = wasmPaths?.wasm;
+      const wasmPathOverride = wasmPathOverrideFlag?.href ?? wasmPathOverrideFlag;
+      const wasmBinaryOverride = flags.wasmBinary;
+      const [objectUrl, ortWasmFactory] = await importWasmModule(
+        mjsPathOverride,
+        wasmPrefixOverride,
+        numThreads > 1,
+        !!wasmBinaryOverride || !!wasmPathOverride
+      );
+      let isTimeout = false;
+      const tasks = [];
+      if (timeout > 0) {
+        tasks.push(
+          new Promise((resolve) => {
+            setTimeout(() => {
+              isTimeout = true;
+              resolve();
+            }, timeout);
+          })
+        );
+      }
+      tasks.push(
+        new Promise((resolve, reject) => {
+          const config = {
+            /**
+             * The number of threads. WebAssembly will create (Module.numThreads - 1) workers. If it is 1, no worker will be
+             * created.
+             */
+            numThreads
+          };
+          if (wasmBinaryOverride) {
+            config.wasmBinary = wasmBinaryOverride;
+            config.locateFile = (fileName) => fileName;
+          } else if (wasmPathOverride || wasmPrefixOverride) {
+            config.locateFile = (fileName) => wasmPathOverride ?? wasmPrefixOverride + fileName;
+          } else if (mjsPathOverride && mjsPathOverride.indexOf("blob:") !== 0) {
+            config.locateFile = (fileName) => new URL(fileName, mjsPathOverride).href;
+          } else if (objectUrl) {
+            const inferredWasmPathPrefix = inferWasmPathPrefixFromScriptSrc();
+            if (inferredWasmPathPrefix) {
+              config.locateFile = (fileName) => inferredWasmPathPrefix + fileName;
+            }
+          }
+          ortWasmFactory(config).then(
+            // wasm module initialized successfully
+            (module) => {
+              initializing = false;
+              initialized = true;
+              wasm = module;
+              resolve();
+              if (objectUrl) {
+                URL.revokeObjectURL(objectUrl);
+              }
+            },
+            // wasm module failed to initialize
+            (what) => {
+              initializing = false;
+              aborted = true;
+              reject(what);
+            }
+          );
+        })
+      );
+      await Promise.race(tasks);
+      if (isTimeout) {
+        throw new Error(`WebAssembly backend initializing failed due to timeout: ${timeout}ms`);
+      }
+    };
+    getInstance = () => {
+      if (initialized && wasm) {
+        return wasm;
+      }
+      throw new Error("WebAssembly is not initialized yet.");
+    };
+  }
+});
+
+// web/lib/wasm/wasm-utils.ts
+var allocWasmString, iterateExtraOptions, checkLastError;
+var init_wasm_utils = __esm({
+  "web/lib/wasm/wasm-utils.ts"() {
+    "use strict";
+    init_wasm_factory();
+    allocWasmString = (data, allocs) => {
+      const wasm2 = getInstance();
+      const dataLength = wasm2.lengthBytesUTF8(data) + 1;
+      const dataOffset = wasm2._malloc(dataLength);
+      wasm2.stringToUTF8(data, dataOffset, dataLength);
+      allocs.push(dataOffset);
+      return dataOffset;
+    };
+    iterateExtraOptions = (options, prefix, seen, handler) => {
+      if (typeof options == "object" && options !== null) {
+        if (seen.has(options)) {
+          throw new Error("Circular reference in options");
+        } else {
+          seen.add(options);
+        }
+      }
+      Object.entries(options).forEach(([key, value]) => {
+        const name = prefix ? prefix + key : key;
+        if (typeof value === "object") {
+          iterateExtraOptions(value, name + ".", seen, handler);
+        } else if (typeof value === "string" || typeof value === "number") {
+          handler(name, value.toString());
+        } else if (typeof value === "boolean") {
+          handler(name, value ? "1" : "0");
+        } else {
+          throw new Error(`Can't handle extra config type: ${typeof value}`);
+        }
+      });
+    };
+    checkLastError = (message) => {
+      const wasm2 = getInstance();
+      const stack = wasm2.stackSave();
+      try {
+        const ptrSize = wasm2.PTR_SIZE;
+        const paramsOffset = wasm2.stackAlloc(2 * ptrSize);
+        wasm2._OrtGetLastError(paramsOffset, paramsOffset + ptrSize);
+        const errorCode = Number(wasm2.getValue(paramsOffset, ptrSize === 4 ? "i32" : "i64"));
+        const errorMessagePointer = wasm2.getValue(paramsOffset + ptrSize, "*");
+        const errorMessage = errorMessagePointer ? wasm2.UTF8ToString(errorMessagePointer) : "";
+        throw new Error(`${message} ERROR_CODE: ${errorCode}, ERROR_MESSAGE: ${errorMessage}`);
+      } finally {
+        wasm2.stackRestore(stack);
+      }
+    };
+  }
+});
+
+// web/lib/wasm/run-options.ts
+var setRunOptions;
+var init_run_options = __esm({
+  "web/lib/wasm/run-options.ts"() {
+    "use strict";
+    init_wasm_factory();
+    init_wasm_utils();
+    setRunOptions = (options) => {
+      const wasm2 = getInstance();
+      let runOptionsHandle = 0;
+      const allocs = [];
+      const runOptions = options || {};
+      try {
+        if (options?.logSeverityLevel === void 0) {
+          runOptions.logSeverityLevel = 2;
+        } else if (typeof options.logSeverityLevel !== "number" || !Number.isInteger(options.logSeverityLevel) || options.logSeverityLevel < 0 || options.logSeverityLevel > 4) {
+          throw new Error(`log severity level is not valid: ${options.logSeverityLevel}`);
+        }
+        if (options?.logVerbosityLevel === void 0) {
+          runOptions.logVerbosityLevel = 0;
+        } else if (typeof options.logVerbosityLevel !== "number" || !Number.isInteger(options.logVerbosityLevel)) {
+          throw new Error(`log verbosity level is not valid: ${options.logVerbosityLevel}`);
+        }
+        if (options?.terminate === void 0) {
+          runOptions.terminate = false;
+        }
+        let tagDataOffset = 0;
+        if (options?.tag !== void 0) {
+          tagDataOffset = allocWasmString(options.tag, allocs);
+        }
+        runOptionsHandle = wasm2._OrtCreateRunOptions(
+          runOptions.logSeverityLevel,
+          runOptions.logVerbosityLevel,
+          !!runOptions.terminate,
+          tagDataOffset
+        );
+        if (runOptionsHandle === 0) {
+          checkLastError("Can't create run options.");
+        }
+        if (options?.extra !== void 0) {
+          iterateExtraOptions(options.extra, "", /* @__PURE__ */ new WeakSet(), (key, value) => {
+            const keyDataOffset = allocWasmString(key, allocs);
+            const valueDataOffset = allocWasmString(value, allocs);
+            if (wasm2._OrtAddRunConfigEntry(runOptionsHandle, keyDataOffset, valueDataOffset) !== 0) {
+              checkLastError(`Can't set a run config entry: ${key} - ${value}.`);
+            }
+          });
+        }
+        return [runOptionsHandle, allocs];
+      } catch (e) {
+        if (runOptionsHandle !== 0) {
+          wasm2._OrtReleaseRunOptions(runOptionsHandle);
+        }
+        allocs.forEach((alloc) => wasm2._free(alloc));
+        throw e;
+      }
+    };
+  }
+});
+
+// web/lib/wasm/session-options.ts
+var getGraphOptimzationLevel, getExecutionMode, appendDefaultOptions, appendSessionConfig, appendEpOption, setExecutionProviders, setSessionOptions;
+var init_session_options = __esm({
+  "web/lib/wasm/session-options.ts"() {
+    "use strict";
+    init_wasm_factory();
+    init_wasm_utils();
+    getGraphOptimzationLevel = (graphOptimizationLevel) => {
+      switch (graphOptimizationLevel) {
+        case "disabled":
+          return 0;
+        case "basic":
+          return 1;
+        case "extended":
+          return 2;
+        case "layout":
+          return 3;
+        case "all":
+          return 99;
+        default:
+          throw new Error(`unsupported graph optimization level: ${graphOptimizationLevel}`);
+      }
+    };
+    getExecutionMode = (executionMode) => {
+      switch (executionMode) {
+        case "sequential":
+          return 0;
+        case "parallel":
+          return 1;
+        default:
+          throw new Error(`unsupported execution mode: ${executionMode}`);
+      }
+    };
+    appendDefaultOptions = (options) => {
+      if (!options.extra) {
+        options.extra = {};
+      }
+      if (!options.extra.session) {
+        options.extra.session = {};
+      }
+      const session = options.extra.session;
+      if (!session.use_ort_model_bytes_directly) {
+        session.use_ort_model_bytes_directly = "1";
+      }
+      if (options.executionProviders && options.executionProviders.some((ep) => (typeof ep === "string" ? ep : ep.name) === "webgpu")) {
+        options.enableMemPattern = false;
+      }
+    };
+    appendSessionConfig = (sessionOptionsHandle, key, value, allocs) => {
+      const keyDataOffset = allocWasmString(key, allocs);
+      const valueDataOffset = allocWasmString(value, allocs);
+      if (getInstance()._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !== 0) {
+        checkLastError(`Can't set a session config entry: ${key} - ${value}.`);
+      }
+    };
+    appendEpOption = (epOptions, key, value, allocs) => {
+      const keyDataOffset = allocWasmString(key, allocs);
+      const valueDataOffset = allocWasmString(value, allocs);
+      epOptions.push([keyDataOffset, valueDataOffset]);
+    };
+    setExecutionProviders = async (sessionOptionsHandle, sessionOptions, allocs) => {
+      const executionProviders = sessionOptions.executionProviders;
+      for (const ep of executionProviders) {
+        let epName = typeof ep === "string" ? ep : ep.name;
+        const epOptions = [];
+        switch (epName) {
+          case "webnn":
+            epName = "WEBNN";
+            appendSessionConfig(sessionOptionsHandle, "session.disable_quant_qdq", "1", allocs);
+            appendSessionConfig(sessionOptionsHandle, "session.disable_qdq_constant_folding", "1", allocs);
+            if (typeof ep !== "string") {
+              const webnnOptions = ep;
+              const deviceType = webnnOptions?.deviceType;
+              if (deviceType) {
+                appendSessionConfig(sessionOptionsHandle, "deviceType", deviceType, allocs);
+              }
+            }
+            break;
+          case "webgpu":
+            if (true) {
+              epName = "WebGPU";
+              let customDevice;
+              if (typeof ep !== "string") {
+                const webgpuOptions = ep;
+                if (webgpuOptions.device) {
+                  if (typeof GPUDevice !== "undefined" && webgpuOptions.device instanceof GPUDevice) {
+                    customDevice = webgpuOptions.device;
+                  } else {
+                    throw new Error("Invalid GPU device set in WebGPU EP options.");
+                  }
+                }
+                const { enableGraphCapture } = sessionOptions;
+                if (typeof enableGraphCapture === "boolean" && enableGraphCapture) {
+                  appendEpOption(epOptions, "enableGraphCapture", "1", allocs);
+                }
+                if (typeof webgpuOptions.preferredLayout === "string") {
+                  appendEpOption(epOptions, "preferredLayout", webgpuOptions.preferredLayout, allocs);
+                }
+                if (webgpuOptions.forceCpuNodeNames) {
+                  const names = Array.isArray(webgpuOptions.forceCpuNodeNames) ? webgpuOptions.forceCpuNodeNames : [webgpuOptions.forceCpuNodeNames];
+                  appendEpOption(epOptions, "forceCpuNodeNames", names.join("\n"), allocs);
+                }
+                if (webgpuOptions.validationMode) {
+                  appendEpOption(epOptions, "validationMode", webgpuOptions.validationMode, allocs);
+                }
+              }
+              const info = getInstance().webgpuRegisterDevice(customDevice);
+              if (info) {
+                const [deviceId, instanceHandle, deviceHandle] = info;
+                appendEpOption(epOptions, "deviceId", deviceId.toString(), allocs);
+                appendEpOption(epOptions, "webgpuInstance", instanceHandle.toString(), allocs);
+                appendEpOption(epOptions, "webgpuDevice", deviceHandle.toString(), allocs);
+              }
+            } else {
+              epName = "JS";
+              if (typeof ep !== "string") {
+                const webgpuOptions = ep;
+                if (webgpuOptions?.preferredLayout) {
+                  if (webgpuOptions.preferredLayout !== "NCHW" && webgpuOptions.preferredLayout !== "NHWC") {
+                    throw new Error(`preferredLayout must be either 'NCHW' or 'NHWC': ${webgpuOptions.preferredLayout}`);
+                  }
+                  appendSessionConfig(sessionOptionsHandle, "preferredLayout", webgpuOptions.preferredLayout, allocs);
+                }
+              }
+            }
+            break;
+          case "wasm":
+          case "cpu":
+            continue;
+          default:
+            throw new Error(`not supported execution provider: ${epName}`);
+        }
+        const epNameDataOffset = allocWasmString(epName, allocs);
+        const epOptionsCount = epOptions.length;
+        let keysOffset = 0;
+        let valuesOffset = 0;
+        if (epOptionsCount > 0) {
+          keysOffset = getInstance()._malloc(epOptionsCount * getInstance().PTR_SIZE);
+          allocs.push(keysOffset);
+          valuesOffset = getInstance()._malloc(epOptionsCount * getInstance().PTR_SIZE);
+          allocs.push(valuesOffset);
+          for (let i = 0; i < epOptionsCount; i++) {
+            getInstance().setValue(keysOffset + i * getInstance().PTR_SIZE, epOptions[i][0], "*");
+            getInstance().setValue(valuesOffset + i * getInstance().PTR_SIZE, epOptions[i][1], "*");
+          }
+        }
+        if (await getInstance()._OrtAppendExecutionProvider(
+          sessionOptionsHandle,
+          epNameDataOffset,
+          keysOffset,
+          valuesOffset,
+          epOptionsCount
+        ) !== 0) {
+          checkLastError(`Can't append execution provider: ${epName}.`);
+        }
+      }
+    };
+    setSessionOptions = async (options) => {
+      const wasm2 = getInstance();
+      let sessionOptionsHandle = 0;
+      const allocs = [];
+      const sessionOptions = options || {};
+      appendDefaultOptions(sessionOptions);
+      try {
+        const graphOptimizationLevel = getGraphOptimzationLevel(sessionOptions.graphOptimizationLevel ?? "all");
+        const executionMode = getExecutionMode(sessionOptions.executionMode ?? "sequential");
+        const logIdDataOffset = typeof sessionOptions.logId === "string" ? allocWasmString(sessionOptions.logId, allocs) : 0;
+        const logSeverityLevel = sessionOptions.logSeverityLevel ?? 2;
+        if (!Number.isInteger(logSeverityLevel) || logSeverityLevel < 0 || logSeverityLevel > 4) {
+          throw new Error(`log severity level is not valid: ${logSeverityLevel}`);
+        }
+        const logVerbosityLevel = sessionOptions.logVerbosityLevel ?? 0;
+        if (!Number.isInteger(logVerbosityLevel) || logVerbosityLevel < 0 || logVerbosityLevel > 4) {
+          throw new Error(`log verbosity level is not valid: ${logVerbosityLevel}`);
+        }
+        const optimizedModelFilePathOffset = typeof sessionOptions.optimizedModelFilePath === "string" ? allocWasmString(sessionOptions.optimizedModelFilePath, allocs) : 0;
+        sessionOptionsHandle = wasm2._OrtCreateSessionOptions(
+          graphOptimizationLevel,
+          !!sessionOptions.enableCpuMemArena,
+          !!sessionOptions.enableMemPattern,
+          executionMode,
+          !!sessionOptions.enableProfiling,
+          0,
+          logIdDataOffset,
+          logSeverityLevel,
+          logVerbosityLevel,
+          optimizedModelFilePathOffset
+        );
+        if (sessionOptionsHandle === 0) {
+          checkLastError("Can't create session options.");
+        }
+        if (sessionOptions.executionProviders) {
+          await setExecutionProviders(sessionOptionsHandle, sessionOptions, allocs);
+        }
+        if (sessionOptions.enableGraphCapture !== void 0) {
+          if (typeof sessionOptions.enableGraphCapture !== "boolean") {
+            throw new Error(`enableGraphCapture must be a boolean value: ${sessionOptions.enableGraphCapture}`);
+          }
+          appendSessionConfig(
+            sessionOptionsHandle,
+            "enableGraphCapture",
+            sessionOptions.enableGraphCapture.toString(),
+            allocs
+          );
+        }
+        if (sessionOptions.freeDimensionOverrides) {
+          for (const [name, value] of Object.entries(sessionOptions.freeDimensionOverrides)) {
+            if (typeof name !== "string") {
+              throw new Error(`free dimension override name must be a string: ${name}`);
+            }
+            if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+              throw new Error(`free dimension override value must be a non-negative integer: ${value}`);
+            }
+            const nameOffset = allocWasmString(name, allocs);
+            if (wasm2._OrtAddFreeDimensionOverride(sessionOptionsHandle, nameOffset, value) !== 0) {
+              checkLastError(`Can't set a free dimension override: ${name} - ${value}.`);
+            }
+          }
+        }
+        if (sessionOptions.extra !== void 0) {
+          iterateExtraOptions(sessionOptions.extra, "", /* @__PURE__ */ new WeakSet(), (key, value) => {
+            appendSessionConfig(sessionOptionsHandle, key, value, allocs);
+          });
+        }
+        return [sessionOptionsHandle, allocs];
+      } catch (e) {
+        if (sessionOptionsHandle !== 0) {
+          if (wasm2._OrtReleaseSessionOptions(sessionOptionsHandle) !== 0) {
+            checkLastError("Can't release session options.");
+          }
+        }
+        allocs.forEach((alloc) => wasm2._free(alloc));
+        throw e;
+      }
+    };
+  }
+});
+
+// web/lib/wasm/wasm-common.ts
+var tensorDataTypeStringToEnum, tensorDataTypeEnumToString, calculateTensorSizeInBytes, tensorTypeToTypedArrayConstructor, logLevelStringToEnum, isGpuBufferSupportedType, isMLTensorSupportedType, dataLocationStringToEnum;
+var init_wasm_common = __esm({
+  "web/lib/wasm/wasm-common.ts"() {
+    "use strict";
+    tensorDataTypeStringToEnum = (type) => {
+      switch (type) {
+        case "int8":
+          return 3 /* int8 */;
+        case "uint8":
+          return 2 /* uint8 */;
+        case "bool":
+          return 9 /* bool */;
+        case "int16":
+          return 5 /* int16 */;
+        case "uint16":
+          return 4 /* uint16 */;
+        case "int32":
+          return 6 /* int32 */;
+        case "uint32":
+          return 12 /* uint32 */;
+        case "float16":
+          return 10 /* float16 */;
+        case "float32":
+          return 1 /* float */;
+        case "float64":
+          return 11 /* double */;
+        case "string":
+          return 8 /* string */;
+        case "int64":
+          return 7 /* int64 */;
+        case "uint64":
+          return 13 /* uint64 */;
+        case "int4":
+          return 22 /* int4 */;
+        case "uint4":
+          return 21 /* uint4 */;
+        default:
+          throw new Error(`unsupported data type: ${type}`);
+      }
+    };
+    tensorDataTypeEnumToString = (typeProto) => {
+      switch (typeProto) {
+        case 3 /* int8 */:
+          return "int8";
+        case 2 /* uint8 */:
+          return "uint8";
+        case 9 /* bool */:
+          return "bool";
+        case 5 /* int16 */:
+          return "int16";
+        case 4 /* uint16 */:
+          return "uint16";
+        case 6 /* int32 */:
+          return "int32";
+        case 12 /* uint32 */:
+          return "uint32";
+        case 10 /* float16 */:
+          return "float16";
+        case 1 /* float */:
+          return "float32";
+        case 11 /* double */:
+          return "float64";
+        case 8 /* string */:
+          return "string";
+        case 7 /* int64 */:
+          return "int64";
+        case 13 /* uint64 */:
+          return "uint64";
+        case 22 /* int4 */:
+          return "int4";
+        case 21 /* uint4 */:
+          return "uint4";
+        default:
+          throw new Error(`unsupported data type: ${typeProto}`);
+      }
+    };
+    calculateTensorSizeInBytes = (dateType, dimsOrSize) => {
+      const elementSize = [
+        -1,
+        // undefined = 0
+        4,
+        // float = 1
+        1,
+        // uint8 = 2
+        1,
+        // int8 = 3
+        2,
+        // uint16 = 4
+        2,
+        // int16 = 5
+        4,
+        // int32 = 6
+        8,
+        // int64 = 7
+        -1,
+        // string = 8
+        1,
+        // bool = 9
+        2,
+        // float16 = 10
+        8,
+        // double = 11
+        4,
+        // uint32 = 12
+        8,
+        // uint64 = 13
+        -1,
+        // complex64 = 14
+        -1,
+        // complex128 = 15
+        -1,
+        // bfloat16 = 16
+        -1,
+        // FLOAT8E4M3FN = 17
+        -1,
+        // FLOAT8E4M3FNUZ = 18
+        -1,
+        // FLOAT8E5M2 = 19
+        -1,
+        // FLOAT8E5M2FNUZ = 20
+        0.5,
+        // uint4 = 21
+        0.5
+        // int4 = 22
+      ][dateType];
+      const size = typeof dimsOrSize === "number" ? dimsOrSize : dimsOrSize.reduce((a, b) => a * b, 1);
+      return elementSize > 0 ? Math.ceil(size * elementSize) : void 0;
+    };
+    tensorTypeToTypedArrayConstructor = (type) => {
+      switch (type) {
+        case "float16":
+          return typeof Float16Array !== "undefined" && Float16Array.from ? Float16Array : Uint16Array;
+        case "float32":
+          return Float32Array;
+        case "uint8":
+          return Uint8Array;
+        case "int8":
+          return Int8Array;
+        case "uint16":
+          return Uint16Array;
+        case "int16":
+          return Int16Array;
+        case "int32":
+          return Int32Array;
+        case "bool":
+          return Uint8Array;
+        case "float64":
+          return Float64Array;
+        case "uint32":
+          return Uint32Array;
+        case "int64":
+          return BigInt64Array;
+        case "uint64":
+          return BigUint64Array;
+        default:
+          throw new Error(`unsupported type: ${type}`);
+      }
+    };
+    logLevelStringToEnum = (logLevel) => {
+      switch (logLevel) {
+        case "verbose":
+          return 0;
+        case "info":
+          return 1;
+        case "warning":
+          return 2;
+        case "error":
+          return 3;
+        case "fatal":
+          return 4;
+        default:
+          throw new Error(`unsupported logging level: ${logLevel}`);
+      }
+    };
+    isGpuBufferSupportedType = (type) => type === "float32" || type === "float16" || type === "int32" || type === "int64" || type === "uint32" || type === "uint8" || type === "bool" || type === "uint4" || type === "int4";
+    isMLTensorSupportedType = (type) => type === "float32" || type === "float16" || type === "int32" || type === "int64" || type === "uint32" || type === "uint64" || type === "int8" || type === "uint8" || type === "bool" || type === "uint4" || type === "int4";
+    dataLocationStringToEnum = (location2) => {
+      switch (location2) {
+        case "none":
+          return 0;
+        case "cpu":
+          return 1;
+        case "cpu-pinned":
+          return 2;
+        case "texture":
+          return 3;
+        case "gpu-buffer":
+          return 4;
+        case "ml-tensor":
+          return 5;
+        default:
+          throw new Error(`unsupported data location: ${location2}`);
+      }
+    };
+  }
+});
+
+// web/lib/wasm/wasm-utils-load-file.ts
+var loadFile;
+var init_wasm_utils_load_file = __esm({
+  "web/lib/wasm/wasm-utils-load-file.ts"() {
+    "use strict";
+    init_wasm_utils_env();
+    loadFile = async (file) => {
+      if (typeof file === "string") {
+        if (isNode) {
+          try {
+            const { readFile } = __require("node:fs/promises");
+            return new Uint8Array(await readFile(file));
+          } catch (e) {
+            if (e.code === "ERR_FS_FILE_TOO_LARGE") {
+              const { createReadStream } = __require("node:fs");
+              const stream = createReadStream(file);
+              const chunks = [];
+              for await (const chunk of stream) {
+                chunks.push(chunk);
+              }
+              return new Uint8Array(Buffer.concat(chunks));
+            }
+            throw e;
+          }
+        } else {
+          const response = await fetch(file);
+          if (!response.ok) {
+            throw new Error(`failed to load external data file: ${file}`);
+          }
+          const contentLengthHeader = response.headers.get("Content-Length");
+          const fileSize = contentLengthHeader ? parseInt(contentLengthHeader, 10) : 0;
+          if (fileSize < 1073741824) {
+            return new Uint8Array(await response.arrayBuffer());
+          } else {
+            if (!response.body) {
+              throw new Error(`failed to load external data file: ${file}, no response body.`);
+            }
+            const reader = response.body.getReader();
+            let buffer;
+            try {
+              buffer = new ArrayBuffer(fileSize);
+            } catch (e) {
+              if (e instanceof RangeError) {
+                const pages = Math.ceil(fileSize / 65536);
+                buffer = new WebAssembly.Memory({ initial: pages, maximum: pages }).buffer;
+              } else {
+                throw e;
+              }
+            }
+            let offset = 0;
+            while (true) {
+              const { done, value } = await reader.read();
+              if (done) {
+                break;
+              }
+              const chunkSize = value.byteLength;
+              const chunk = new Uint8Array(buffer, offset, chunkSize);
+              chunk.set(value);
+              offset += chunkSize;
+            }
+            return new Uint8Array(buffer, 0, fileSize);
+          }
+        }
+      } else if (file instanceof Blob) {
+        return new Uint8Array(await file.arrayBuffer());
+      } else if (file instanceof Uint8Array) {
+        return file;
+      } else {
+        return new Uint8Array(file);
+      }
+    };
+  }
+});
+
+// web/lib/wasm/jsep/tensor-view.ts
+var createView;
+var init_tensor_view = __esm({
+  "web/lib/wasm/jsep/tensor-view.ts"() {
+    "use strict";
+    init_wasm_common();
+    createView = (dataBuffer, type) => new (tensorTypeToTypedArrayConstructor(type))(dataBuffer);
+  }
+});
+
+// web/lib/wasm/jsep/log.ts
+var logLevelPrefix, doLog, configLogLevel, debug, configureLogger, LOG, LOG_DEBUG;
+var init_log = __esm({
+  "web/lib/wasm/jsep/log.ts"() {
+    "use strict";
+    init_wasm_common();
+    logLevelPrefix = ["V", "I", "W", "E", "F"];
+    doLog = (level, message) => {
+      console.log(`[${logLevelPrefix[level]},${(/* @__PURE__ */ new Date()).toISOString()}]${message}`);
+    };
+    configureLogger = ($configLogLevel, $debug) => {
+      configLogLevel = $configLogLevel;
+      debug = $debug;
+    };
+    LOG = (logLevel, msg) => {
+      const messageLevel = logLevelStringToEnum(logLevel);
+      const configLevel = logLevelStringToEnum(configLogLevel);
+      if (messageLevel >= configLevel) {
+        doLog(messageLevel, typeof msg === "function" ? msg() : msg);
+      }
+    };
+    LOG_DEBUG = (...args) => {
+      if (debug) {
+        LOG(...args);
+      }
+    };
+  }
+});
+
+// web/lib/wasm/jsep/webnn/tensor-manager.ts
+var webnnDataTypeToSize, convertDataToInt32, convertInt32ToData, tensorGuid, createNewTensorId, webnnDataTypeToFallback, calculateByteLength, TensorWrapper, TensorIdTracker, TensorManagerImpl, createTensorManager;
+var init_tensor_manager = __esm({
+  "web/lib/wasm/jsep/webnn/tensor-manager.ts"() {
+    "use strict";
+    init_wasm_common();
+    init_log();
+    webnnDataTypeToSize = /* @__PURE__ */ new Map([
+      ["float32", 32],
+      ["float16", 16],
+      ["int32", 32],
+      ["uint32", 32],
+      ["int64", 64],
+      ["uint64", 64],
+      ["int8", 8],
+      ["uint8", 8],
+      ["int4", 4],
+      ["uint4", 4]
+    ]);
+    convertDataToInt32 = (data, dataType) => {
+      if (dataType === "int32") {
+        return data;
+      }
+      const dataTypeSize = webnnDataTypeToSize.get(dataType);
+      if (!dataTypeSize) {
+        throw new Error(`WebNN backend does not support data type: ${dataType}`);
+      }
+      const bytesPerElement = dataTypeSize / 8;
+      if (data.byteLength % bytesPerElement !== 0) {
+        throw new Error(`Invalid Uint8Array length - must be a multiple of ${bytesPerElement}.`);
+      }
+      const numElements = data.byteLength / bytesPerElement;
+      const originalArray = new (tensorTypeToTypedArrayConstructor(dataType))(data.buffer, data.byteOffset, numElements);
+      switch (dataType) {
+        case "int64":
+        case "uint64": {
+          const int32Array = new Int32Array(numElements);
+          for (let i = 0; i < numElements; i++) {
+            const value = originalArray[i];
+            if (value > 2147483647n || value < -2147483648n) {
+              throw new Error(`Can not convert int64 data to int32 - value out of range.`);
+            }
+            int32Array[i] = Number(value);
+          }
+          return new Uint8Array(int32Array.buffer);
+        }
+        case "int8":
+        case "uint8":
+        case "uint32": {
+          if (dataType === "uint32") {
+            if (originalArray.some((value) => value > 2147483647)) {
+              throw new Error(`Can not convert uint32 data to int32 - value out of range.`);
+            }
+          }
+          const int32Array = Int32Array.from(originalArray, Number);
+          return new Uint8Array(int32Array.buffer);
+        }
+        default:
+          throw new Error(`Unsupported data conversion from ${dataType} to 'int32'`);
+      }
+    };
+    convertInt32ToData = (data, dataType) => {
+      if (dataType === "int32") {
+        return data;
+      }
+      if (data.byteLength % 4 !== 0) {
+        throw new Error("Invalid Uint8Array length - must be a multiple of 4 (int32).");
+      }
+      const numElements = data.byteLength / 4;
+      const int32Array = new Int32Array(data.buffer, data.byteOffset, numElements);
+      switch (dataType) {
+        case "int64": {
+          const bigInt64Array = BigInt64Array.from(int32Array, BigInt);
+          return new Uint8Array(bigInt64Array.buffer);
+        }
+        case "uint64": {
+          if (int32Array.some((value) => value < 0)) {
+            throw new Error("Can not convert int32 data to uin64 - negative value found.");
+          }
+          const bigUint64Array = BigUint64Array.from(int32Array, BigInt);
+          return new Uint8Array(bigUint64Array.buffer);
+        }
+        case "int8": {
+          if (int32Array.some((value) => value < -128 || value > 127)) {
+            throw new Error("Can not convert int32 data to int8 - value out of range.");
+          }
+          const int8Array = Int8Array.from(int32Array, Number);
+          return new Uint8Array(int8Array.buffer);
+        }
+        case "uint8": {
+          if (int32Array.some((value) => value < 0 || value > 255)) {
+            throw new Error("Can not convert int32 data to uint8 - value out of range.");
+          }
+          return Uint8Array.from(int32Array, Number);
+        }
+        case "uint32": {
+          if (int32Array.some((value) => value < 0)) {
+            throw new Error("Can not convert int32 data to uint32 - negative value found.");
+          }
+          const uint32Array = Uint32Array.from(int32Array, Number);
+          return new Uint8Array(uint32Array.buffer);
+        }
+        default:
+          throw new Error(`Unsupported data conversion from 'int32' to ${dataType}`);
+      }
+    };
+    tensorGuid = 1;
+    createNewTensorId = () => tensorGuid++;
+    webnnDataTypeToFallback = /* @__PURE__ */ new Map([
+      ["int8", "int32"],
+      ["uint8", "int32"],
+      ["uint32", "int32"],
+      ["int64", "int32"]
+    ]);
+    calculateByteLength = (dataType, shape) => {
+      const dataTypeSize = webnnDataTypeToSize.get(dataType);
+      if (!dataTypeSize) {
+        throw new Error(`WebNN backend does not support data type: ${dataType}`);
+      }
+      return shape.length > 0 ? Math.ceil(shape.reduce((a, b) => a * b) * dataTypeSize / 8) : 0;
+    };
+    TensorWrapper = class {
+      constructor(descriptor) {
+        // This flag is used to indicate whether the data has been converted to fallback data type.
+        this.isDataConverted = false;
+        const { sessionId, context, tensor, dataType, shape, fallbackDataType } = descriptor;
+        this.sessionId = sessionId;
+        this.mlContext = context;
+        this.mlTensor = tensor;
+        this.dataType = dataType;
+        this.tensorShape = shape;
+        this.fallbackDataType = fallbackDataType;
+      }
+      get tensor() {
+        return this.mlTensor;
+      }
+      get type() {
+        return this.dataType;
+      }
+      get fallbackType() {
+        return this.fallbackDataType;
+      }
+      get shape() {
+        return this.tensorShape;
+      }
+      get byteLength() {
+        return calculateByteLength(this.dataType, this.tensorShape);
+      }
+      destroy() {
+        LOG_DEBUG("verbose", () => "[WebNN] TensorWrapper.destroy");
+        this.mlTensor.destroy();
+      }
+      write(data) {
+        this.mlContext.writeTensor(this.mlTensor, data);
+      }
+      async read(dstBuffer) {
+        if (this.fallbackDataType) {
+          const data = await this.mlContext.readTensor(this.mlTensor);
+          const originalData = convertInt32ToData(new Uint8Array(data), this.dataType);
+          if (dstBuffer) {
+            const targetBuffer = dstBuffer instanceof ArrayBuffer ? new Uint8Array(dstBuffer) : new Uint8Array(dstBuffer.buffer, dstBuffer.byteOffset, dstBuffer.byteLength);
+            targetBuffer.set(originalData);
+            return void 0;
+          } else {
+            return originalData.buffer;
+          }
+        } else {
+          return dstBuffer ? this.mlContext.readTensor(this.mlTensor, dstBuffer) : this.mlContext.readTensor(this.mlTensor);
+        }
+      }
+      canReuseTensor(context, dataType, shape) {
+        return this.mlContext === context && this.dataType === dataType && this.tensorShape.length === shape.length && this.tensorShape.every((v, i) => v === shape[i]);
+      }
+      setIsDataConverted(isConverted) {
+        this.isDataConverted = isConverted;
+      }
+    };
+    TensorIdTracker = class {
+      constructor(tensorManager, wrapper) {
+        this.tensorManager = tensorManager;
+        this.wrapper = wrapper;
+      }
+      get tensorWrapper() {
+        return this.wrapper;
+      }
+      releaseTensor() {
+        if (this.tensorWrapper) {
+          this.tensorManager.releaseTensor(this.tensorWrapper);
+          this.wrapper = void 0;
+        }
+      }
+      async ensureTensor(sessionId, dataType, shape, copyOld) {
+        const context = this.tensorManager.getMLContext(sessionId);
+        const opLimits = this.tensorManager.getMLOpSupportLimits(sessionId);
+        let fallbackDataType;
+        if (!opLimits?.input.dataTypes.includes(dataType)) {
+          fallbackDataType = webnnDataTypeToFallback.get(dataType);
+          if (!fallbackDataType || opLimits?.input.dataTypes.includes(fallbackDataType)) {
+            throw new Error(`WebNN backend does not support data type: ${dataType}`);
+          }
+          LOG_DEBUG(
+            "verbose",
+            () => `[WebNN] TensorIdTracker.ensureTensor: fallback dataType from ${dataType} to ${fallbackDataType}`
+          );
+        }
+        if (this.wrapper) {
+          if (this.wrapper.canReuseTensor(context, dataType, shape)) {
+            return this.wrapper.tensor;
+          } else {
+            if (copyOld) {
+              if (this.wrapper.byteLength !== calculateByteLength(dataType, shape)) {
+                throw new Error("Unable to copy data to tensor with different size.");
+              }
+              this.activeUpload = new Uint8Array(await this.wrapper.read());
+            }
+            this.tensorManager.releaseTensor(this.wrapper);
+          }
+        }
+        const usage = typeof MLTensorUsage == "undefined" ? void 0 : MLTensorUsage.READ | MLTensorUsage.WRITE;
+        this.wrapper = await this.tensorManager.getCachedTensor(
+          sessionId,
+          dataType,
+          shape,
+          usage,
+          true,
+          true,
+          fallbackDataType
+        );
+        if (copyOld && this.activeUpload) {
+          this.wrapper.write(this.activeUpload);
+          this.activeUpload = void 0;
+        }
+        return this.wrapper.tensor;
+      }
+      upload(data) {
+        let newData = data;
+        if (this.wrapper) {
+          if (this.wrapper.fallbackType) {
+            if (this.wrapper.fallbackType === "int32") {
+              newData = convertDataToInt32(data, this.wrapper.type);
+              this.wrapper.setIsDataConverted(true);
+            } else {
+              throw new Error(`Unsupported fallback data type: ${this.wrapper.fallbackType}`);
+            }
+          }
+          if (data.byteLength === this.wrapper.byteLength) {
+            this.wrapper.write(newData);
+            return;
+          } else {
+            LOG_DEBUG("verbose", () => "Data size does not match tensor size. Releasing tensor.");
+            this.releaseTensor();
+          }
+        }
+        if (this.activeUpload) {
+          this.activeUpload.set(newData);
+        } else {
+          this.activeUpload = new Uint8Array(newData);
+        }
+      }
+      async download(dstBuffer) {
+        if (this.activeUpload) {
+          const dstData = this.wrapper?.isDataConverted ? convertInt32ToData(this.activeUpload, this.wrapper?.type) : this.activeUpload;
+          if (dstBuffer) {
+            if (dstBuffer instanceof ArrayBuffer) {
+              new Uint8Array(dstBuffer).set(dstData);
+            } else {
+              new Uint8Array(dstBuffer.buffer, dstBuffer.byteOffset, dstBuffer.byteLength).set(dstData);
+            }
+            return;
+          } else {
+            return dstData.buffer;
+          }
+        }
+        if (!this.wrapper) {
+          throw new Error("Tensor has not been created.");
+        }
+        if (!dstBuffer) {
+          return this.wrapper.read();
+        }
+        return this.wrapper.read(dstBuffer);
+      }
+    };
+    TensorManagerImpl = class {
+      constructor(backend) {
+        this.backend = backend;
+        this.tensorTrackersById = /* @__PURE__ */ new Map();
+        this.freeTensors = [];
+        this.externalTensors = /* @__PURE__ */ new Set();
+      }
+      getMLContext(sessionId) {
+        const context = this.backend.getMLContext(sessionId);
+        if (!context) {
+          throw new Error("MLContext not found for session.");
+        }
+        return context;
+      }
+      getMLOpSupportLimits(sessionId) {
+        return this.backend.getMLOpSupportLimits(sessionId);
+      }
+      reserveTensorId() {
+        const tensorId = createNewTensorId();
+        this.tensorTrackersById.set(tensorId, new TensorIdTracker(this));
+        return tensorId;
+      }
+      releaseTensorId(tensorId) {
+        const tensorTracker = this.tensorTrackersById.get(tensorId);
+        if (!tensorTracker) {
+          return;
+        }
+        this.tensorTrackersById.delete(tensorId);
+        if (tensorTracker.tensorWrapper) {
+          this.releaseTensor(tensorTracker.tensorWrapper);
+        }
+      }
+      async ensureTensor(sessionId, tensorId, dataType, shape, copyOld) {
+        LOG_DEBUG(
+          "verbose",
+          () => `[WebNN] TensorManager.ensureTensor {tensorId: ${tensorId}, dataType: ${dataType}, shape: ${shape}, copyOld: ${copyOld}}`
+        );
+        const tensor = this.tensorTrackersById.get(tensorId);
+        if (!tensor) {
+          throw new Error("Tensor not found.");
+        }
+        return tensor.ensureTensor(sessionId, dataType, shape, copyOld);
+      }
+      upload(tensorId, data) {
+        const tensor = this.tensorTrackersById.get(tensorId);
+        if (!tensor) {
+          throw new Error("Tensor not found.");
+        }
+        tensor.upload(data);
+      }
+      async download(tensorId, dstBuffer) {
+        LOG_DEBUG(
+          "verbose",
+          () => `[WebNN] TensorManager.download {tensorId: ${tensorId}, dstBuffer: ${dstBuffer?.byteLength}}`
+        );
+        const tensorTracker = this.tensorTrackersById.get(tensorId);
+        if (!tensorTracker) {
+          throw new Error("Tensor not found.");
+        }
+        return tensorTracker.download(dstBuffer);
+      }
+      releaseTensorsForSession(sessionId) {
+        for (const tensor of this.freeTensors) {
+          if (tensor.sessionId === sessionId) {
+            tensor.destroy();
+          }
+        }
+        this.freeTensors = this.freeTensors.filter((tensor) => tensor.sessionId !== sessionId);
+      }
+      registerTensor(sessionId, mlTensor, dataType, shape) {
+        const context = this.getMLContext(sessionId);
+        const tensorId = createNewTensorId();
+        const wrapper = new TensorWrapper({
+          sessionId,
+          context,
+          tensor: mlTensor,
+          dataType,
+          shape
+        });
+        this.tensorTrackersById.set(tensorId, new TensorIdTracker(this, wrapper));
+        this.externalTensors.add(wrapper);
+        return tensorId;
+      }
+      /**
+       * Get or create an MLTensor with the given data type and shape.
+       */
+      async getCachedTensor(sessionId, dataType, shape, usage, writable, readable, fallbackDataType) {
+        const context = this.getMLContext(sessionId);
+        for (const [index, tensor2] of this.freeTensors.entries()) {
+          if (tensor2.canReuseTensor(context, dataType, shape)) {
+            LOG_DEBUG(
+              "verbose",
+              () => `[WebNN] Reusing tensor {dataType: ${dataType}, ${fallbackDataType ? `fallbackDataType: ${fallbackDataType},` : ""} shape: ${shape}`
+            );
+            const wrapper = this.freeTensors.splice(index, 1)[0];
+            wrapper.sessionId = sessionId;
+            return wrapper;
+          }
+        }
+        LOG_DEBUG(
+          "verbose",
+          () => `[WebNN] MLContext.createTensor {dataType: ${dataType}, ${fallbackDataType ? `fallbackDataType: ${fallbackDataType},` : ""} shape: ${shape}}`
+        );
+        const tensor = await context.createTensor({
+          dataType: fallbackDataType ?? dataType,
+          // If fallback data type is provided, use it.
+          shape,
+          dimensions: shape,
+          usage,
+          writable,
+          readable
+        });
+        return new TensorWrapper({ sessionId, context, tensor, dataType, shape, fallbackDataType });
+      }
+      /**
+       * Release tensor for reuse unless external.
+       */
+      releaseTensor(tensorWrapper) {
+        if (this.externalTensors.has(tensorWrapper)) {
+          this.externalTensors.delete(tensorWrapper);
+        }
+        this.freeTensors.push(tensorWrapper);
+      }
+    };
+    createTensorManager = (...args) => new TensorManagerImpl(...args);
+  }
+});
+
+// web/lib/wasm/jsep/backend-webnn.ts
+var backend_webnn_exports = {};
+__export(backend_webnn_exports, {
+  WebNNBackend: () => WebNNBackend
+});
+var onnxDataTypeToWebnnDataType, compareMLContextOptions, WebNNBackend;
+var init_backend_webnn = __esm({
+  "web/lib/wasm/jsep/backend-webnn.ts"() {
+    "use strict";
+    init_wasm_common();
+    init_wasm_factory();
+    init_tensor_view();
+    init_tensor_manager();
+    init_log();
+    onnxDataTypeToWebnnDataType = /* @__PURE__ */ new Map([
+      [1 /* float */, "float32"],
+      [10 /* float16 */, "float16"],
+      [6 /* int32 */, "int32"],
+      [12 /* uint32 */, "uint32"],
+      [7 /* int64 */, "int64"],
+      [13 /* uint64 */, "uint64"],
+      [22 /* int4 */, "int4"],
+      [21 /* uint4 */, "uint4"],
+      [3 /* int8 */, "int8"],
+      [2 /* uint8 */, "uint8"],
+      [9 /* bool */, "uint8"]
+    ]);
+    compareMLContextOptions = (a, b) => {
+      if (a === b) {
+        return true;
+      }
+      if (a === void 0 || b === void 0) {
+        return false;
+      }
+      const aKeys = Object.keys(a).sort();
+      const bKeys = Object.keys(b).sort();
+      return aKeys.length === bKeys.length && aKeys.every((key, index) => key === bKeys[index] && a[key] === b[key]);
+    };
+    WebNNBackend = class {
+      constructor(env3) {
+        /**
+         * Tensor managers for each session.
+         */
+        this.tensorManager = createTensorManager(this);
+        /**
+         * Maps from session id to MLContexts.
+         */
+        this.mlContextBySessionId = /* @__PURE__ */ new Map();
+        /**
+         * Maps from MLContext to session ids.
+         */
+        this.sessionIdsByMLContext = /* @__PURE__ */ new Map();
+        /**
+         * Cache of MLContexts.
+         */
+        this.mlContextCache = [];
+        /**
+         * Maps from session id to list of graph inputs.
+         */
+        this.sessionGraphInputs = /* @__PURE__ */ new Map();
+        /**
+         * Maps from session id to list of graph outputs.
+         */
+        this.sessionGraphOutputs = /* @__PURE__ */ new Map();
+        /**
+         * Temporary graph inputs for the current session.
+         * These inputs will be registered when the session is created.
+         */
+        this.temporaryGraphInputs = [];
+        /**
+         * Temporary graph outputs for the current session.
+         * These outputs will be registered when the session is created.
+         */
+        this.temporaryGraphOutputs = [];
+        /**
+         * Temporary tensors for the current session.
+         */
+        this.temporarySessionTensorIds = /* @__PURE__ */ new Map();
+        /**
+         * Maps from session id to MLOpSupportLimits.
+         */
+        this.mlOpSupportLimitsBySessionId = /* @__PURE__ */ new Map();
+        configureLogger(env3.logLevel, !!env3.debug);
+      }
+      get currentSessionId() {
+        if (this.activeSessionId === void 0) {
+          throw new Error("No active session");
+        }
+        return this.activeSessionId;
+      }
+      onRunStart(sessionId) {
+        LOG_DEBUG("verbose", () => `[WebNN] onRunStart {sessionId: ${sessionId}}`);
+        this.activeSessionId = sessionId;
+      }
+      onRunEnd(sessionId) {
+        LOG_DEBUG("verbose", () => `[WebNN] onRunEnd {sessionId: ${sessionId}}`);
+        const tensorIds = this.temporarySessionTensorIds.get(sessionId);
+        if (!tensorIds) {
+          return;
+        }
+        for (const tensorId of tensorIds) {
+          LOG_DEBUG("verbose", () => `[WebNN] releasing temporary tensor {tensorId: ${tensorId}}`);
+          this.tensorManager.releaseTensorId(tensorId);
+        }
+        this.temporarySessionTensorIds.delete(sessionId);
+        this.activeSessionId = void 0;
+      }
+      async createMLContext(optionsOrDevice) {
+        if (optionsOrDevice instanceof GPUDevice) {
+          const mlContextIndex2 = this.mlContextCache.findIndex((entry) => entry.gpuDevice === optionsOrDevice);
+          if (mlContextIndex2 !== -1) {
+            return this.mlContextCache[mlContextIndex2].mlContext;
+          } else {
+            const mlContext = await navigator.ml.createContext(optionsOrDevice);
+            this.mlContextCache.push({ gpuDevice: optionsOrDevice, mlContext });
+            return mlContext;
+          }
+        } else if (optionsOrDevice === void 0) {
+          const mlContextIndex2 = this.mlContextCache.findIndex(
+            (entry) => entry.options === void 0 && entry.gpuDevice === void 0
+          );
+          if (mlContextIndex2 !== -1) {
+            return this.mlContextCache[mlContextIndex2].mlContext;
+          } else {
+            const mlContext = await navigator.ml.createContext();
+            this.mlContextCache.push({ mlContext });
+            return mlContext;
+          }
+        }
+        const mlContextIndex = this.mlContextCache.findIndex(
+          (entry) => compareMLContextOptions(entry.options, optionsOrDevice)
+        );
+        if (mlContextIndex !== -1) {
+          return this.mlContextCache[mlContextIndex].mlContext;
+        } else {
+          const mlContext = await navigator.ml.createContext(optionsOrDevice);
+          this.mlContextCache.push({ options: optionsOrDevice, mlContext });
+          return mlContext;
+        }
+      }
+      registerMLContext(sessionId, mlContext) {
+        this.mlContextBySessionId.set(sessionId, mlContext);
+        let sessionIds = this.sessionIdsByMLContext.get(mlContext);
+        if (!sessionIds) {
+          sessionIds = /* @__PURE__ */ new Set();
+          this.sessionIdsByMLContext.set(mlContext, sessionIds);
+        }
+        sessionIds.add(sessionId);
+        if (!this.mlOpSupportLimitsBySessionId.has(sessionId)) {
+          this.mlOpSupportLimitsBySessionId.set(sessionId, mlContext.opSupportLimits());
+        }
+        if (this.temporaryGraphInputs.length > 0) {
+          this.sessionGraphInputs.set(sessionId, this.temporaryGraphInputs);
+          this.temporaryGraphInputs = [];
+        }
+        if (this.temporaryGraphOutputs.length > 0) {
+          this.sessionGraphOutputs.set(sessionId, this.temporaryGraphOutputs);
+          this.temporaryGraphOutputs = [];
+        }
+      }
+      onReleaseSession(sessionId) {
+        this.sessionGraphInputs.delete(sessionId);
+        this.sessionGraphOutputs.delete(sessionId);
+        const mlContext = this.mlContextBySessionId.get(sessionId);
+        if (!mlContext) {
+          return;
+        }
+        this.tensorManager.releaseTensorsForSession(sessionId);
+        this.mlContextBySessionId.delete(sessionId);
+        this.mlOpSupportLimitsBySessionId.delete(sessionId);
+        const sessionIds = this.sessionIdsByMLContext.get(mlContext);
+        sessionIds.delete(sessionId);
+        if (sessionIds.size === 0) {
+          this.sessionIdsByMLContext.delete(mlContext);
+          const mlContextIndex = this.mlContextCache.findIndex((entry) => entry.mlContext === mlContext);
+          if (mlContextIndex !== -1) {
+            this.mlContextCache.splice(mlContextIndex, 1);
+          }
+        }
+      }
+      getMLContext(sessionId) {
+        return this.mlContextBySessionId.get(sessionId);
+      }
+      getMLOpSupportLimits(sessionId) {
+        return this.mlOpSupportLimitsBySessionId.get(sessionId);
+      }
+      reserveTensorId() {
+        return this.tensorManager.reserveTensorId();
+      }
+      releaseTensorId(tensorId) {
+        LOG_DEBUG("verbose", () => `[WebNN] releaseTensorId {tensorId: ${tensorId}}`);
+        this.tensorManager.releaseTensorId(tensorId);
+      }
+      async ensureTensor(sessionId, tensorId, onnxDataType, dimensions, copyOld) {
+        const webnnDataType = onnxDataTypeToWebnnDataType.get(onnxDataType);
+        if (!webnnDataType) {
+          throw new Error(`Unsupported ONNX data type: ${onnxDataType}`);
+        }
+        return this.tensorManager.ensureTensor(
+          sessionId ?? this.currentSessionId,
+          tensorId,
+          webnnDataType,
+          dimensions,
+          copyOld
+        );
+      }
+      async createTemporaryTensor(sessionId, onnxDataType, shape) {
+        LOG_DEBUG("verbose", () => `[WebNN] createTemporaryTensor {onnxDataType: ${onnxDataType}, shape: ${shape}}`);
+        const dataType = onnxDataTypeToWebnnDataType.get(onnxDataType);
+        if (!dataType) {
+          throw new Error(`Unsupported ONNX data type: ${onnxDataType}`);
+        }
+        const tensorId = this.tensorManager.reserveTensorId();
+        await this.tensorManager.ensureTensor(sessionId, tensorId, dataType, shape, false);
+        const tensorIds = this.temporarySessionTensorIds.get(sessionId);
+        if (!tensorIds) {
+          this.temporarySessionTensorIds.set(sessionId, [tensorId]);
+        } else {
+          tensorIds.push(tensorId);
+        }
+        return tensorId;
+      }
+      uploadTensor(tensorId, data) {
+        const wasm2 = getInstance();
+        if (!wasm2.shouldTransferToMLTensor) {
+          throw new Error("Trying to upload to a MLTensor while shouldTransferToMLTensor is false");
+        }
+        LOG_DEBUG("verbose", () => `[WebNN] uploadTensor {tensorId: ${tensorId}, data: ${data.byteLength}}`);
+        this.tensorManager.upload(tensorId, data);
+      }
+      async downloadTensor(tensorId, dstBuffer) {
+        return this.tensorManager.download(tensorId, dstBuffer);
+      }
+      createMLTensorDownloader(tensorId, type) {
+        return async () => {
+          const data = await this.tensorManager.download(tensorId);
+          return createView(data, type);
+        };
+      }
+      registerMLTensor(sessionId, tensor, onnxDataType, dimensions) {
+        const webnnDataType = onnxDataTypeToWebnnDataType.get(onnxDataType);
+        if (!webnnDataType) {
+          throw new Error(`Unsupported ONNX data type: ${onnxDataType}`);
+        }
+        const id = this.tensorManager.registerTensor(sessionId, tensor, webnnDataType, dimensions);
+        LOG_DEBUG(
+          "verbose",
+          () => `[WebNN] registerMLTensor {tensor: ${tensor}, dataType: ${webnnDataType}, dimensions: ${dimensions}} -> {tensorId: ${id}}`
+        );
+        return id;
+      }
+      // Register a WebNN Constant operand from external data.
+      registerMLConstant(externalFilePath, dataOffset, dataLength, builder, desc, mountedFiles, shouldConvertInt64ToInt32 = false) {
+        if (!mountedFiles) {
+          throw new Error("External mounted files are not available.");
+        }
+        let filePath = externalFilePath;
+        if (externalFilePath.startsWith("./")) {
+          filePath = externalFilePath.substring(2);
+        }
+        const fileData = mountedFiles.get(filePath);
+        if (!fileData) {
+          throw new Error(`File with name ${filePath} not found in preloaded files.`);
+        }
+        if (dataOffset + dataLength > fileData.byteLength) {
+          throw new Error("Out of bounds: data offset and length exceed the external file data size.");
+        }
+        const buffer = fileData.slice(dataOffset, dataOffset + dataLength).buffer;
+        let bufferView;
+        switch (desc.dataType) {
+          case "float32":
+            bufferView = new Float32Array(buffer);
+            break;
+          case "float16":
+            bufferView = typeof Float16Array !== "undefined" && Float16Array.from ? new Float16Array(buffer) : new Uint16Array(buffer);
+            break;
+          case "int32":
+            bufferView = new Int32Array(buffer);
+            break;
+          case "uint32":
+            bufferView = new Uint32Array(buffer);
+            break;
+          case "int64":
+            if (shouldConvertInt64ToInt32) {
+              const int32Buffer = convertDataToInt32(new Uint8Array(buffer), "int64");
+              bufferView = new Int32Array(int32Buffer.buffer);
+              desc.dataType = "int32";
+            } else {
+              bufferView = new BigInt64Array(buffer);
+            }
+            break;
+          case "uint64":
+            bufferView = new BigUint64Array(buffer);
+            break;
+          case "int8":
+            bufferView = new Int8Array(buffer);
+            break;
+          case "int4":
+          case "uint4":
+          case "uint8":
+            bufferView = new Uint8Array(buffer);
+            break;
+          default:
+            throw new Error(`Unsupported data type: ${desc.dataType} in creating WebNN Constant from external data.`);
+        }
+        LOG_DEBUG(
+          "verbose",
+          () => `[WebNN] registerMLConstant {dataType: ${desc.dataType}, shape: ${desc.shape}}} ${shouldConvertInt64ToInt32 ? "(Note: it was int64 data type and registered to int32 as workaround)" : ""}`
+        );
+        return builder.constant(desc, bufferView);
+      }
+      registerGraphInput(inputName) {
+        this.temporaryGraphInputs.push(inputName);
+      }
+      registerGraphOutput(outputName) {
+        this.temporaryGraphOutputs.push(outputName);
+      }
+      isGraphInput(sessionId, inputName) {
+        const inputNames = this.sessionGraphInputs.get(sessionId);
+        if (!inputNames) {
+          return false;
+        }
+        return inputNames.includes(inputName);
+      }
+      isGraphOutput(sessionId, outputName) {
+        const outputNames = this.sessionGraphOutputs.get(sessionId);
+        if (!outputNames) {
+          return false;
+        }
+        return outputNames.includes(outputName);
+      }
+      isGraphInputOutputTypeSupported(sessionId, type, isInput = true) {
+        const dataType = onnxDataTypeToWebnnDataType.get(tensorDataTypeStringToEnum(type));
+        const opLimits = this.mlOpSupportLimitsBySessionId.get(sessionId);
+        if (typeof dataType === "undefined") {
+          return false;
+        }
+        if (isInput) {
+          return !!opLimits?.input.dataTypes.includes(dataType);
+        } else {
+          return !!opLimits?.output.dataTypes.includes(dataType);
+        }
+      }
+      flush() {
+      }
+    };
+  }
+});
+
+// web/lib/wasm/wasm-core-impl.ts
+var initOrt, initRuntime, initEp, activeSessions, getSessionInputOutputCount, getSessionInputOutputMetadata, copyFromExternalBuffer, createSession, releaseSession, prepareInputOutputTensor, run, endProfiling, extractTransferableBuffers;
+var init_wasm_core_impl = __esm({
+  "web/lib/wasm/wasm-core-impl.ts"() {
+    "use strict";
+    init_esm();
+    init_run_options();
+    init_session_options();
+    init_wasm_common();
+    init_wasm_factory();
+    init_wasm_utils();
+    init_wasm_utils_load_file();
+    initOrt = (numThreads, loggingLevel) => {
+      const errorCode = getInstance()._OrtInit(numThreads, loggingLevel);
+      if (errorCode !== 0) {
+        checkLastError("Can't initialize onnxruntime.");
+      }
+    };
+    initRuntime = async (env3) => {
+      initOrt(env3.wasm.numThreads, logLevelStringToEnum(env3.logLevel));
+    };
+    initEp = async (env3, epName) => {
+      getInstance().asyncInit?.();
+      let webgpuAdapter = env3.webgpu.adapter;
+      if (epName === "webgpu") {
+        if (typeof navigator === "undefined" || !navigator.gpu) {
+          throw new Error("WebGPU is not supported in current environment");
+        }
+        if (!webgpuAdapter) {
+          const powerPreference = env3.webgpu.powerPreference;
+          if (powerPreference !== void 0 && powerPreference !== "low-power" && powerPreference !== "high-performance") {
+            throw new Error(`Invalid powerPreference setting: "${powerPreference}"`);
+          }
+          const forceFallbackAdapter = env3.webgpu.forceFallbackAdapter;
+          if (forceFallbackAdapter !== void 0 && typeof forceFallbackAdapter !== "boolean") {
+            throw new Error(`Invalid forceFallbackAdapter setting: "${forceFallbackAdapter}"`);
+          }
+          webgpuAdapter = await navigator.gpu.requestAdapter({ powerPreference, forceFallbackAdapter });
+          if (!webgpuAdapter) {
+            throw new Error(
+              'Failed to get GPU adapter. You may need to enable flag "--enable-unsafe-webgpu" if you are using Chrome.'
+            );
+          }
+        } else {
+          if (typeof webgpuAdapter.limits !== "object" || typeof webgpuAdapter.features !== "object" || typeof webgpuAdapter.requestDevice !== "function") {
+            throw new Error("Invalid GPU adapter set in `env.webgpu.adapter`. It must be a GPUAdapter object.");
+          }
+        }
+      }
+      if (epName === "webnn") {
+        if (typeof navigator === "undefined" || !navigator.ml) {
+          throw new Error("WebNN is not supported in current environment");
+        }
+      }
+      if (false) {
+        const initJsep = null.init;
+        if (epName === "webgpu") {
+          await initJsep("webgpu", getInstance(), env3, webgpuAdapter);
+        }
+        if (epName === "webnn") {
+          await initJsep("webnn", getInstance(), env3);
+        }
+      } else {
+        if (epName === "webgpu") {
+          getInstance().webgpuInit((device) => {
+            env3.webgpu.device = device;
+          });
+        }
+        if (epName === "webnn") {
+          const backend = new (init_backend_webnn(), __toCommonJS(backend_webnn_exports)).WebNNBackend(env3);
+          getInstance().webnnInit([
+            backend,
+            // webnnReserveTensorId
+            () => backend.reserveTensorId(),
+            // webnnReleaseTensorId,
+            (tensorId) => backend.releaseTensorId(tensorId),
+            // webnnEnsureTensor
+            async (sessionId, tensorId, onnxDataType, shape, copyOld) => backend.ensureTensor(sessionId, tensorId, onnxDataType, shape, copyOld),
+            // webnnUploadTensor
+            (tensorId, data) => {
+              backend.uploadTensor(tensorId, data);
+            },
+            // webnnDownloadTensor
+            async (tensorId, dstBuffer) => backend.downloadTensor(tensorId, dstBuffer),
+            // webnnRegisterMLContext
+            (sessionId, mlContext) => backend.registerMLContext(sessionId, mlContext),
+            // webnnEnableTraceEvent
+            !!env3.trace
+          ]);
+        }
+      }
+    };
+    activeSessions = /* @__PURE__ */ new Map();
+    getSessionInputOutputCount = (sessionHandle) => {
+      const wasm2 = getInstance();
+      const stack = wasm2.stackSave();
+      try {
+        const ptrSize = wasm2.PTR_SIZE;
+        const dataOffset = wasm2.stackAlloc(2 * ptrSize);
+        const errorCode = wasm2._OrtGetInputOutputCount(sessionHandle, dataOffset, dataOffset + ptrSize);
+        if (errorCode !== 0) {
+          checkLastError("Can't get session input/output count.");
+        }
+        const type = ptrSize === 4 ? "i32" : "i64";
+        return [Number(wasm2.getValue(dataOffset, type)), Number(wasm2.getValue(dataOffset + ptrSize, type))];
+      } finally {
+        wasm2.stackRestore(stack);
+      }
+    };
+    getSessionInputOutputMetadata = (sessionHandle, index) => {
+      const wasm2 = getInstance();
+      const stack = wasm2.stackSave();
+      let metadataOffset = 0;
+      try {
+        const ptrSize = wasm2.PTR_SIZE;
+        const dataOffset = wasm2.stackAlloc(2 * ptrSize);
+        const errorCode = wasm2._OrtGetInputOutputMetadata(sessionHandle, index, dataOffset, dataOffset + ptrSize);
+        if (errorCode !== 0) {
+          checkLastError("Can't get session input/output metadata.");
+        }
+        const nameOffset = Number(wasm2.getValue(dataOffset, "*"));
+        metadataOffset = Number(wasm2.getValue(dataOffset + ptrSize, "*"));
+        const elementType = wasm2.HEAP32[metadataOffset / 4];
+        if (elementType === 0) {
+          return [nameOffset, 0];
+        }
+        const dimsCount = wasm2.HEAPU32[metadataOffset / 4 + 1];
+        const dims = [];
+        for (let i = 0; i < dimsCount; i++) {
+          const symbolicDimNameOffset = Number(wasm2.getValue(metadataOffset + 8 + i * ptrSize, "*"));
+          dims.push(
+            symbolicDimNameOffset !== 0 ? wasm2.UTF8ToString(symbolicDimNameOffset) : Number(wasm2.getValue(metadataOffset + 8 + (i + dimsCount) * ptrSize, "*"))
+          );
+        }
+        return [nameOffset, elementType, dims];
+      } finally {
+        wasm2.stackRestore(stack);
+        if (metadataOffset !== 0) {
+          wasm2._OrtFree(metadataOffset);
+        }
+      }
+    };
+    copyFromExternalBuffer = (model) => {
+      const wasm2 = getInstance();
+      const modelDataOffset = wasm2._malloc(model.byteLength);
+      if (modelDataOffset === 0) {
+        throw new Error(`Can't create a session. failed to allocate a buffer of size ${model.byteLength}.`);
+      }
+      wasm2.HEAPU8.set(model, modelDataOffset);
+      return [modelDataOffset, model.byteLength];
+    };
+    createSession = async (modelData, options) => {
+      let modelDataOffset, modelDataLength;
+      const wasm2 = getInstance();
+      if (Array.isArray(modelData)) {
+        [modelDataOffset, modelDataLength] = modelData;
+      } else if (modelData.buffer === wasm2.HEAPU8.buffer) {
+        [modelDataOffset, modelDataLength] = [modelData.byteOffset, modelData.byteLength];
+      } else {
+        [modelDataOffset, modelDataLength] = copyFromExternalBuffer(modelData);
+      }
+      let sessionHandle = 0;
+      let sessionOptionsHandle = 0;
+      let ioBindingHandle = 0;
+      let allocs = [];
+      const inputNamesUTF8Encoded = [];
+      const outputNamesUTF8Encoded = [];
+      try {
+        [sessionOptionsHandle, allocs] = await setSessionOptions(options);
+        if (options?.externalData && wasm2.mountExternalData) {
+          const loadingPromises = [];
+          for (const file of options.externalData) {
+            const path = typeof file === "string" ? file : file.path;
+            loadingPromises.push(
+              loadFile(typeof file === "string" ? file : file.data).then((data) => {
+                wasm2.mountExternalData(path, data);
+              })
+            );
+          }
+          await Promise.all(loadingPromises);
+        }
+        for (const provider of options?.executionProviders ?? []) {
+          const providerName = typeof provider === "string" ? provider : provider.name;
+          if (providerName === "webnn") {
+            wasm2.shouldTransferToMLTensor = false;
+            if (typeof provider !== "string") {
+              const webnnOptions = provider;
+              const context = webnnOptions?.context;
+              const gpuDevice = webnnOptions?.gpuDevice;
+              const deviceType = webnnOptions?.deviceType;
+              const powerPreference = webnnOptions?.powerPreference;
+              if (context) {
+                wasm2.currentContext = context;
+              } else if (gpuDevice) {
+                wasm2.currentContext = await wasm2.webnnCreateMLContext(gpuDevice);
+              } else {
+                wasm2.currentContext = await wasm2.webnnCreateMLContext({ deviceType, powerPreference });
+              }
+            } else {
+              wasm2.currentContext = await wasm2.webnnCreateMLContext();
+            }
+            break;
+          }
+        }
+        sessionHandle = await wasm2._OrtCreateSession(modelDataOffset, modelDataLength, sessionOptionsHandle);
+        wasm2.webgpuOnCreateSession?.(sessionHandle);
+        if (sessionHandle === 0) {
+          checkLastError("Can't create a session.");
+        }
+        wasm2.jsepOnCreateSession?.();
+        if (wasm2.currentContext) {
+          wasm2.webnnRegisterMLContext(sessionHandle, wasm2.currentContext);
+          wasm2.currentContext = void 0;
+          wasm2.shouldTransferToMLTensor = true;
+        }
+        const [inputCount, outputCount] = getSessionInputOutputCount(sessionHandle);
+        const enableGraphCapture = !!options?.enableGraphCapture;
+        const inputNames = [];
+        const outputNames = [];
+        const inputMetadata = [];
+        const outputMetadata = [];
+        const outputPreferredLocations = [];
+        for (let i = 0; i < inputCount; i++) {
+          const [nameOffset, elementType, shape] = getSessionInputOutputMetadata(sessionHandle, i);
+          if (nameOffset === 0) {
+            checkLastError("Can't get an input name.");
+          }
+          inputNamesUTF8Encoded.push(nameOffset);
+          const name = wasm2.UTF8ToString(nameOffset);
+          inputNames.push(name);
+          inputMetadata.push(
+            elementType === 0 ? { name, isTensor: false } : { name, isTensor: true, type: tensorDataTypeEnumToString(elementType), shape }
+          );
+        }
+        for (let i = 0; i < outputCount; i++) {
+          const [nameOffset, elementType, shape] = getSessionInputOutputMetadata(sessionHandle, i + inputCount);
+          if (nameOffset === 0) {
+            checkLastError("Can't get an output name.");
+          }
+          outputNamesUTF8Encoded.push(nameOffset);
+          const nameString = wasm2.UTF8ToString(nameOffset);
+          outputNames.push(nameString);
+          outputMetadata.push(
+            elementType === 0 ? { name: nameString, isTensor: false } : { name: nameString, isTensor: true, type: tensorDataTypeEnumToString(elementType), shape }
+          );
+          if (true) {
+            if (enableGraphCapture && options?.preferredOutputLocation === void 0) {
+              outputPreferredLocations.push("gpu-buffer");
+              continue;
+            }
+            const location2 = typeof options?.preferredOutputLocation === "string" ? options.preferredOutputLocation : options?.preferredOutputLocation?.[nameString] ?? "cpu";
+            const isGraphOutput = wasm2.webnnIsGraphOutput;
+            if (location2 === "cpu" && isGraphOutput && isGraphOutput(sessionHandle, nameString)) {
+              outputPreferredLocations.push("ml-tensor-cpu-output");
+              continue;
+            }
+            if (location2 !== "cpu" && location2 !== "cpu-pinned" && location2 !== "gpu-buffer" && location2 !== "ml-tensor") {
+              throw new Error(`Not supported preferred output location: ${location2}.`);
+            }
+            if (enableGraphCapture && location2 !== "gpu-buffer") {
+              throw new Error(
+                `Not supported preferred output location: ${location2}. Only 'gpu-buffer' location is supported when enableGraphCapture is true.`
+              );
+            }
+            outputPreferredLocations.push(location2);
+          }
+        }
+        let bindingState = null;
+        if (outputPreferredLocations.some((l) => l === "gpu-buffer" || l === "ml-tensor" || l === "ml-tensor-cpu-output")) {
+          ioBindingHandle = wasm2._OrtCreateBinding(sessionHandle);
+          if (ioBindingHandle === 0) {
+            checkLastError("Can't create IO binding.");
+          }
+          bindingState = {
+            handle: ioBindingHandle,
+            outputPreferredLocations,
+            outputPreferredLocationsEncoded: outputPreferredLocations.map((l) => l === "ml-tensor-cpu-output" ? "ml-tensor" : l).map((l) => dataLocationStringToEnum(l))
+          };
+        }
+        activeSessions.set(sessionHandle, [
+          sessionHandle,
+          inputNamesUTF8Encoded,
+          outputNamesUTF8Encoded,
+          bindingState,
+          enableGraphCapture,
+          false
+        ]);
+        return [sessionHandle, inputNames, outputNames, inputMetadata, outputMetadata];
+      } catch (e) {
+        inputNamesUTF8Encoded.forEach((buf) => wasm2._OrtFree(buf));
+        outputNamesUTF8Encoded.forEach((buf) => wasm2._OrtFree(buf));
+        if (ioBindingHandle !== 0) {
+          if (wasm2._OrtReleaseBinding(ioBindingHandle) !== 0) {
+            checkLastError("Can't release IO binding.");
+          }
+        }
+        if (sessionHandle !== 0) {
+          if (wasm2._OrtReleaseSession(sessionHandle) !== 0) {
+            checkLastError("Can't release session.");
+          }
+        }
+        throw e;
+      } finally {
+        wasm2._free(modelDataOffset);
+        if (sessionOptionsHandle !== 0) {
+          if (wasm2._OrtReleaseSessionOptions(sessionOptionsHandle) !== 0) {
+            checkLastError("Can't release session options.");
+          }
+        }
+        allocs.forEach((alloc) => wasm2._free(alloc));
+        wasm2.unmountExternalData?.();
+      }
+    };
+    releaseSession = (sessionId) => {
+      const wasm2 = getInstance();
+      const session = activeSessions.get(sessionId);
+      if (!session) {
+        throw new Error(`cannot release session. invalid session id: ${sessionId}`);
+      }
+      const [sessionHandle, inputNamesUTF8Encoded, outputNamesUTF8Encoded, ioBindingState, enableGraphCapture] = session;
+      if (ioBindingState) {
+        if (enableGraphCapture) {
+          if (wasm2._OrtClearBoundOutputs(ioBindingState.handle) !== 0) {
+            checkLastError("Can't clear bound outputs.");
+          }
+        }
+        if (wasm2._OrtReleaseBinding(ioBindingState.handle) !== 0) {
+          checkLastError("Can't release IO binding.");
+        }
+      }
+      wasm2.jsepOnReleaseSession?.(sessionId);
+      wasm2.webnnOnReleaseSession?.(sessionId);
+      wasm2.webgpuOnReleaseSession?.(sessionId);
+      inputNamesUTF8Encoded.forEach((buf) => wasm2._OrtFree(buf));
+      outputNamesUTF8Encoded.forEach((buf) => wasm2._OrtFree(buf));
+      if (wasm2._OrtReleaseSession(sessionHandle) !== 0) {
+        checkLastError("Can't release session.");
+      }
+      activeSessions.delete(sessionId);
+    };
+    prepareInputOutputTensor = async (tensor, tensorHandles, allocs, sessionId, tensorNameUTF8Encoded, index, enableGraphCapture = false) => {
+      if (!tensor) {
+        tensorHandles.push(0);
+        return;
+      }
+      const wasm2 = getInstance();
+      const ptrSize = wasm2.PTR_SIZE;
+      const dataType = tensor[0];
+      const dims = tensor[1];
+      const location2 = tensor[3];
+      let actualLocation = location2;
+      let rawData;
+      let dataByteLength;
+      if (dataType === "string" && (location2 === "gpu-buffer" || location2 === "ml-tensor")) {
+        throw new Error("String tensor is not supported on GPU.");
+      }
+      if (enableGraphCapture && location2 !== "gpu-buffer") {
+        throw new Error(
+          `External buffer must be provided for input/output index ${index} when enableGraphCapture is true.`
+        );
+      }
+      if (location2 === "gpu-buffer") {
+        const gpuBuffer = tensor[2].gpuBuffer;
+        dataByteLength = calculateTensorSizeInBytes(tensorDataTypeStringToEnum(dataType), dims);
+        if (true) {
+          const registerBuffer = wasm2.webgpuRegisterBuffer;
+          if (!registerBuffer) {
+            throw new Error('Tensor location "gpu-buffer" is not supported without using WebGPU.');
+          }
+          rawData = registerBuffer(gpuBuffer, sessionId);
+        } else {
+          const registerBuffer = wasm2.jsepRegisterBuffer;
+          if (!registerBuffer) {
+            throw new Error('Tensor location "gpu-buffer" is not supported without using WebGPU.');
+          }
+          rawData = registerBuffer(sessionId, index, gpuBuffer, dataByteLength);
+        }
+      } else if (location2 === "ml-tensor") {
+        const mlTensor = tensor[2].mlTensor;
+        dataByteLength = calculateTensorSizeInBytes(tensorDataTypeStringToEnum(dataType), dims);
+        const registerMLTensor = wasm2.webnnRegisterMLTensor;
+        if (!registerMLTensor) {
+          throw new Error('Tensor location "ml-tensor" is not supported without using WebNN.');
+        }
+        rawData = registerMLTensor(sessionId, mlTensor, tensorDataTypeStringToEnum(dataType), dims);
+      } else {
+        const data = tensor[2];
+        if (Array.isArray(data)) {
+          dataByteLength = ptrSize * data.length;
+          rawData = wasm2._malloc(dataByteLength);
+          allocs.push(rawData);
+          for (let i = 0; i < data.length; i++) {
+            if (typeof data[i] !== "string") {
+              throw new TypeError(`tensor data at index ${i} is not a string`);
+            }
+            wasm2.setValue(rawData + i * ptrSize, allocWasmString(data[i], allocs), "*");
+          }
+        } else {
+          const isGraphInput = wasm2.webnnIsGraphInput;
+          const isGraphOutput = wasm2.webnnIsGraphOutput;
+          if (dataType !== "string" && isGraphInput && isGraphOutput) {
+            const tensorName = wasm2.UTF8ToString(tensorNameUTF8Encoded);
+            if (isGraphInput(sessionId, tensorName) || isGraphOutput(sessionId, tensorName)) {
+              const dataTypeEnum = tensorDataTypeStringToEnum(dataType);
+              dataByteLength = calculateTensorSizeInBytes(dataTypeEnum, dims);
+              actualLocation = "ml-tensor";
+              const createTemporaryTensor = wasm2.webnnCreateTemporaryTensor;
+              const uploadTensor = wasm2.webnnUploadTensor;
+              if (!createTemporaryTensor || !uploadTensor) {
+                throw new Error('Tensor location "ml-tensor" is not supported without using WebNN.');
+              }
+              const tensorId = await createTemporaryTensor(sessionId, dataTypeEnum, dims);
+              uploadTensor(tensorId, new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+              rawData = tensorId;
+            } else {
+              dataByteLength = data.byteLength;
+              rawData = wasm2._malloc(dataByteLength);
+              allocs.push(rawData);
+              wasm2.HEAPU8.set(new Uint8Array(data.buffer, data.byteOffset, dataByteLength), rawData);
+            }
+          } else {
+            dataByteLength = data.byteLength;
+            rawData = wasm2._malloc(dataByteLength);
+            allocs.push(rawData);
+            wasm2.HEAPU8.set(new Uint8Array(data.buffer, data.byteOffset, dataByteLength), rawData);
+          }
+        }
+      }
+      const stack = wasm2.stackSave();
+      const dimsOffset = wasm2.stackAlloc(4 * dims.length);
+      try {
+        dims.forEach((d, index2) => wasm2.setValue(dimsOffset + index2 * ptrSize, d, ptrSize === 4 ? "i32" : "i64"));
+        const tensor2 = wasm2._OrtCreateTensor(
+          tensorDataTypeStringToEnum(dataType),
+          rawData,
+          dataByteLength,
+          dimsOffset,
+          dims.length,
+          dataLocationStringToEnum(actualLocation)
+        );
+        if (tensor2 === 0) {
+          checkLastError(`Can't create tensor for input/output. session=${sessionId}, index=${index}.`);
+        }
+        tensorHandles.push(tensor2);
+      } finally {
+        wasm2.stackRestore(stack);
+      }
+    };
+    run = async (sessionId, inputIndices, inputTensors, outputIndices, outputTensors, options) => {
+      const wasm2 = getInstance();
+      const ptrSize = wasm2.PTR_SIZE;
+      const session = activeSessions.get(sessionId);
+      if (!session) {
+        throw new Error(`cannot run inference. invalid session id: ${sessionId}`);
+      }
+      const sessionHandle = session[0];
+      const inputNamesUTF8Encoded = session[1];
+      const outputNamesUTF8Encoded = session[2];
+      const ioBindingState = session[3];
+      const enableGraphCapture = session[4];
+      const inputOutputBound = session[5];
+      const inputCount = inputIndices.length;
+      const outputCount = outputIndices.length;
+      let runOptionsHandle = 0;
+      let runOptionsAllocs = [];
+      const inputTensorHandles = [];
+      const outputTensorHandles = [];
+      const inputOutputAllocs = [];
+      const preAllocatedOutputs = [];
+      const beforeRunStack = wasm2.stackSave();
+      const inputValuesOffset = wasm2.stackAlloc(inputCount * ptrSize);
+      const inputNamesOffset = wasm2.stackAlloc(inputCount * ptrSize);
+      const outputValuesOffset = wasm2.stackAlloc(outputCount * ptrSize);
+      const outputNamesOffset = wasm2.stackAlloc(outputCount * ptrSize);
+      try {
+        [runOptionsHandle, runOptionsAllocs] = setRunOptions(options);
+        TRACE_EVENT_BEGIN("wasm prepareInputOutputTensor");
+        for (let i = 0; i < inputCount; i++) {
+          await prepareInputOutputTensor(
+            inputTensors[i],
+            inputTensorHandles,
+            inputOutputAllocs,
+            sessionId,
+            inputNamesUTF8Encoded[inputIndices[i]],
+            inputIndices[i],
+            enableGraphCapture
+          );
+        }
+        for (let i = 0; i < outputCount; i++) {
+          await prepareInputOutputTensor(
+            outputTensors[i],
+            outputTensorHandles,
+            inputOutputAllocs,
+            sessionId,
+            outputNamesUTF8Encoded[outputIndices[i]],
+            inputCount + outputIndices[i],
+            enableGraphCapture
+          );
+        }
+        TRACE_EVENT_END("wasm prepareInputOutputTensor");
+        for (let i = 0; i < inputCount; i++) {
+          wasm2.setValue(inputValuesOffset + i * ptrSize, inputTensorHandles[i], "*");
+          wasm2.setValue(inputNamesOffset + i * ptrSize, inputNamesUTF8Encoded[inputIndices[i]], "*");
+        }
+        for (let i = 0; i < outputCount; i++) {
+          wasm2.setValue(outputValuesOffset + i * ptrSize, outputTensorHandles[i], "*");
+          wasm2.setValue(outputNamesOffset + i * ptrSize, outputNamesUTF8Encoded[outputIndices[i]], "*");
+        }
+        if (ioBindingState && !inputOutputBound) {
+          const { handle, outputPreferredLocations, outputPreferredLocationsEncoded } = ioBindingState;
+          if (inputNamesUTF8Encoded.length !== inputCount) {
+            throw new Error(
+              `input count from feeds (${inputCount}) is expected to be always equal to model's input count (${inputNamesUTF8Encoded.length}).`
+            );
+          }
+          TRACE_EVENT_BEGIN("wasm bindInputsOutputs");
+          for (let i = 0; i < inputCount; i++) {
+            const index = inputIndices[i];
+            const errorCode2 = await wasm2._OrtBindInput(handle, inputNamesUTF8Encoded[index], inputTensorHandles[i]);
+            if (errorCode2 !== 0) {
+              checkLastError(`Can't bind input[${i}] for session=${sessionId}.`);
+            }
+          }
+          for (let i = 0; i < outputCount; i++) {
+            const index = outputIndices[i];
+            const location2 = outputTensors[i]?.[3];
+            if (location2) {
+              preAllocatedOutputs.push(outputTensorHandles[i]);
+              const errorCode2 = wasm2._OrtBindOutput(handle, outputNamesUTF8Encoded[index], outputTensorHandles[i], 0);
+              if (errorCode2 !== 0) {
+                checkLastError(`Can't bind pre-allocated output[${i}] for session=${sessionId}.`);
+              }
+            } else {
+              const errorCode2 = wasm2._OrtBindOutput(
+                handle,
+                outputNamesUTF8Encoded[index],
+                0,
+                outputPreferredLocationsEncoded[index]
+              );
+              if (errorCode2 !== 0) {
+                checkLastError(`Can't bind output[${i}] to ${outputPreferredLocations[i]} for session=${sessionId}.`);
+              }
+            }
+          }
+          TRACE_EVENT_END("wasm bindInputsOutputs");
+          activeSessions.set(sessionId, [
+            sessionHandle,
+            inputNamesUTF8Encoded,
+            outputNamesUTF8Encoded,
+            ioBindingState,
+            enableGraphCapture,
+            true
+          ]);
+        }
+        wasm2.jsepOnRunStart?.(sessionHandle);
+        wasm2.webnnOnRunStart?.(sessionHandle);
+        let errorCode;
+        if (ioBindingState) {
+          errorCode = await wasm2._OrtRunWithBinding(
+            sessionHandle,
+            ioBindingState.handle,
+            outputCount,
+            outputValuesOffset,
+            runOptionsHandle
+          );
+        } else {
+          errorCode = await wasm2._OrtRun(
+            sessionHandle,
+            inputNamesOffset,
+            inputValuesOffset,
+            inputCount,
+            outputNamesOffset,
+            outputCount,
+            outputValuesOffset,
+            runOptionsHandle
+          );
+        }
+        if (errorCode !== 0) {
+          checkLastError("failed to call OrtRun().");
+        }
+        const output = [];
+        const outputPromises = [];
+        TRACE_EVENT_BEGIN("wasm ProcessOutputTensor");
+        for (let i = 0; i < outputCount; i++) {
+          const tensor = Number(wasm2.getValue(outputValuesOffset + i * ptrSize, "*"));
+          if (tensor === outputTensorHandles[i] || preAllocatedOutputs.includes(outputTensorHandles[i])) {
+            output.push(outputTensors[i]);
+            if (tensor !== outputTensorHandles[i]) {
+              if (wasm2._OrtReleaseTensor(tensor) !== 0) {
+                checkLastError("Can't release tensor.");
+              }
+            }
+            continue;
+          }
+          const beforeGetTensorDataStack = wasm2.stackSave();
+          const tensorDataOffset = wasm2.stackAlloc(4 * ptrSize);
+          let keepOutputTensor = false;
+          let type, dataOffset = 0;
+          try {
+            const errorCode2 = wasm2._OrtGetTensorData(
+              tensor,
+              tensorDataOffset,
+              tensorDataOffset + ptrSize,
+              tensorDataOffset + 2 * ptrSize,
+              tensorDataOffset + 3 * ptrSize
+            );
+            if (errorCode2 !== 0) {
+              checkLastError(`Can't access output tensor data on index ${i}.`);
+            }
+            const valueType = ptrSize === 4 ? "i32" : "i64";
+            const dataType = Number(wasm2.getValue(tensorDataOffset, valueType));
+            dataOffset = wasm2.getValue(tensorDataOffset + ptrSize, "*");
+            const dimsOffset = wasm2.getValue(tensorDataOffset + ptrSize * 2, "*");
+            const dimsLength = Number(wasm2.getValue(tensorDataOffset + ptrSize * 3, valueType));
+            const dims = [];
+            for (let i2 = 0; i2 < dimsLength; i2++) {
+              dims.push(Number(wasm2.getValue(dimsOffset + i2 * ptrSize, valueType)));
+            }
+            if (wasm2._OrtFree(dimsOffset) !== 0) {
+              checkLastError("Can't free memory for tensor dims.");
+            }
+            const size = dims.reduce((a, b) => a * b, 1);
+            type = tensorDataTypeEnumToString(dataType);
+            const preferredLocation = ioBindingState?.outputPreferredLocations[outputIndices[i]];
+            if (type === "string") {
+              if (preferredLocation === "gpu-buffer" || preferredLocation === "ml-tensor") {
+                throw new Error("String tensor is not supported on GPU.");
+              }
+              const stringData = [];
+              for (let i2 = 0; i2 < size; i2++) {
+                const offset = wasm2.getValue(dataOffset + i2 * ptrSize, "*");
+                const nextOffset = wasm2.getValue(dataOffset + (i2 + 1) * ptrSize, "*");
+                const maxBytesToRead = i2 === size - 1 ? void 0 : nextOffset - offset;
+                stringData.push(wasm2.UTF8ToString(offset, maxBytesToRead));
+              }
+              output.push([type, dims, stringData, "cpu"]);
+            } else {
+              if (preferredLocation === "gpu-buffer" && size > 0) {
+                const getBuffer = true ? wasm2.webgpuGetBuffer : wasm2.jsepGetBuffer;
+                if (!getBuffer) {
+                  throw new Error('preferredLocation "gpu-buffer" is not supported without using WebGPU.');
+                }
+                const gpuBuffer = getBuffer(dataOffset);
+                const bufferSize = calculateTensorSizeInBytes(dataType, size);
+                if (bufferSize === void 0 || !isGpuBufferSupportedType(type)) {
+                  throw new Error(`Unsupported data type: ${type}`);
+                }
+                keepOutputTensor = true;
+                if (true) {
+                  wasm2.webgpuRegisterBuffer(gpuBuffer, sessionId, dataOffset);
+                  const downloadDataFunction = wasm2.webgpuCreateDownloader(gpuBuffer, bufferSize, sessionId);
+                  output.push([
+                    type,
+                    dims,
+                    {
+                      gpuBuffer,
+                      download: async () => {
+                        const arrayBuffer = await downloadDataFunction();
+                        const data = new (tensorTypeToTypedArrayConstructor(type))(arrayBuffer);
+                        return data;
+                      },
+                      dispose: () => {
+                        if (wasm2._OrtReleaseTensor(tensor) !== 0) {
+                          checkLastError("Can't release tensor.");
+                        }
+                      }
+                    },
+                    "gpu-buffer"
+                  ]);
+                } else {
+                  output.push([
+                    type,
+                    dims,
+                    {
+                      gpuBuffer,
+                      download: wasm2.jsepCreateDownloader(gpuBuffer, bufferSize, type),
+                      dispose: () => {
+                        if (wasm2._OrtReleaseTensor(tensor) !== 0) {
+                          checkLastError("Can't release tensor.");
+                        }
+                      }
+                    },
+                    "gpu-buffer"
+                  ]);
+                }
+              } else if (preferredLocation === "ml-tensor" && size > 0) {
+                const ensureTensor = wasm2.webnnEnsureTensor;
+                const isGraphInputOutputTypeSupported = wasm2.webnnIsGraphInputOutputTypeSupported;
+                if (!ensureTensor || !isGraphInputOutputTypeSupported) {
+                  throw new Error('preferredLocation "ml-tensor" is not supported without using WebNN.');
+                }
+                const tensorSize = calculateTensorSizeInBytes(dataType, size);
+                if (tensorSize === void 0 || !isMLTensorSupportedType(type)) {
+                  throw new Error(`Unsupported data type: ${type}`);
+                }
+                if (!isGraphInputOutputTypeSupported(sessionId, type, false)) {
+                  throw new Error(
+                    `preferredLocation "ml-tensor" for ${type} output is not supported by current WebNN Context.`
+                  );
+                }
+                const mlTensor = await ensureTensor(sessionId, dataOffset, dataType, dims, false);
+                keepOutputTensor = true;
+                output.push([
+                  type,
+                  dims,
+                  {
+                    mlTensor,
+                    download: wasm2.webnnCreateMLTensorDownloader(dataOffset, type),
+                    dispose: () => {
+                      wasm2.webnnReleaseTensorId(dataOffset);
+                      wasm2._OrtReleaseTensor(tensor);
+                    }
+                  },
+                  "ml-tensor"
+                ]);
+              } else if (preferredLocation === "ml-tensor-cpu-output" && size > 0) {
+                const data = wasm2.webnnCreateMLTensorDownloader(dataOffset, type)();
+                const index = output.length;
+                keepOutputTensor = true;
+                outputPromises.push(
+                  (async () => {
+                    const result = [index, await data];
+                    wasm2.webnnReleaseTensorId(dataOffset);
+                    wasm2._OrtReleaseTensor(tensor);
+                    return result;
+                  })()
+                );
+                output.push([type, dims, [], "cpu"]);
+              } else {
+                const typedArrayConstructor = tensorTypeToTypedArrayConstructor(type);
+                const data = new typedArrayConstructor(size);
+                new Uint8Array(data.buffer, data.byteOffset, data.byteLength).set(
+                  wasm2.HEAPU8.subarray(dataOffset, dataOffset + data.byteLength)
+                );
+                output.push([type, dims, data, "cpu"]);
+              }
+            }
+          } finally {
+            wasm2.stackRestore(beforeGetTensorDataStack);
+            if (type === "string" && dataOffset) {
+              wasm2._free(dataOffset);
+            }
+            if (!keepOutputTensor) {
+              wasm2._OrtReleaseTensor(tensor);
+            }
+          }
+        }
+        if (ioBindingState && !enableGraphCapture) {
+          if (wasm2._OrtClearBoundOutputs(ioBindingState.handle) !== 0) {
+            checkLastError("Can't clear bound outputs.");
+          }
+          activeSessions.set(sessionId, [
+            sessionHandle,
+            inputNamesUTF8Encoded,
+            outputNamesUTF8Encoded,
+            ioBindingState,
+            enableGraphCapture,
+            false
+          ]);
+        }
+        for (const [index, data] of await Promise.all(outputPromises)) {
+          output[index][2] = data;
+        }
+        TRACE_EVENT_END("wasm ProcessOutputTensor");
+        return output;
+      } finally {
+        wasm2.webnnOnRunEnd?.(sessionHandle);
+        wasm2.stackRestore(beforeRunStack);
+        if (true) {
+          inputTensors.forEach((t) => {
+            if (t && t[3] === "gpu-buffer") {
+              wasm2.webgpuUnregisterBuffer(t[2].gpuBuffer);
+            }
+          });
+          outputTensors.forEach((t) => {
+            if (t && t[3] === "gpu-buffer") {
+              wasm2.webgpuUnregisterBuffer(t[2].gpuBuffer);
+            }
+          });
+        }
+        inputTensorHandles.forEach((v) => wasm2._OrtReleaseTensor(v));
+        outputTensorHandles.forEach((v) => wasm2._OrtReleaseTensor(v));
+        inputOutputAllocs.forEach((p) => wasm2._free(p));
+        if (runOptionsHandle !== 0) {
+          wasm2._OrtReleaseRunOptions(runOptionsHandle);
+        }
+        runOptionsAllocs.forEach((p) => wasm2._free(p));
+      }
+    };
+    endProfiling = (sessionId) => {
+      const wasm2 = getInstance();
+      const session = activeSessions.get(sessionId);
+      if (!session) {
+        throw new Error("invalid session id");
+      }
+      const sessionHandle = session[0];
+      const profileFileName = wasm2._OrtEndProfiling(sessionHandle);
+      if (profileFileName === 0) {
+        checkLastError("Can't get an profile file name.");
+      }
+      wasm2._OrtFree(profileFileName);
+    };
+    extractTransferableBuffers = (tensors) => {
+      const buffers = [];
+      for (const tensor of tensors) {
+        const data = tensor[2];
+        if (!Array.isArray(data) && "buffer" in data) {
+          buffers.push(data.buffer);
+        }
+      }
+      return buffers;
+    };
+  }
+});
+
+// web/lib/wasm/proxy-wrapper.ts
+var isProxy, proxyWorker, initializing2, initialized2, aborted2, temporaryObjectUrl, initWasmCallbacks, queuedCallbacks, enqueueCallbacks, ensureWorker, onProxyWorkerMessage, initializeWebAssemblyAndOrtRuntime, initializeOrtEp, copyFromExternalBuffer2, createSession2, releaseSession2, run2, endProfiling2;
+var init_proxy_wrapper = __esm({
+  "web/lib/wasm/proxy-wrapper.ts"() {
+    "use strict";
+    init_esm();
+    init_wasm_core_impl();
+    init_wasm_factory();
+    init_wasm_utils_import();
+    isProxy = () => !!env2.wasm.proxy && typeof document !== "undefined";
+    initializing2 = false;
+    initialized2 = false;
+    aborted2 = false;
+    queuedCallbacks = /* @__PURE__ */ new Map();
+    enqueueCallbacks = (type, callbacks) => {
+      const queue = queuedCallbacks.get(type);
+      if (queue) {
+        queue.push(callbacks);
+      } else {
+        queuedCallbacks.set(type, [callbacks]);
+      }
+    };
+    ensureWorker = () => {
+      if (initializing2 || !initialized2 || aborted2 || !proxyWorker) {
+        throw new Error("worker not ready");
+      }
+    };
+    onProxyWorkerMessage = (ev) => {
+      switch (ev.data.type) {
+        case "init-wasm":
+          initializing2 = false;
+          if (ev.data.err) {
+            aborted2 = true;
+            initWasmCallbacks[1](ev.data.err);
+          } else {
+            initialized2 = true;
+            initWasmCallbacks[0]();
+          }
+          if (temporaryObjectUrl) {
+            URL.revokeObjectURL(temporaryObjectUrl);
+            temporaryObjectUrl = void 0;
+          }
+          break;
+        case "init-ep":
+        case "copy-from":
+        case "create":
+        case "release":
+        case "run":
+        case "end-profiling": {
+          const callbacks = queuedCallbacks.get(ev.data.type);
+          if (ev.data.err) {
+            callbacks.shift()[1](ev.data.err);
+          } else {
+            callbacks.shift()[0](ev.data.out);
+          }
+          break;
+        }
+        default:
+      }
+    };
+    initializeWebAssemblyAndOrtRuntime = async () => {
+      if (initialized2) {
+        return;
+      }
+      if (initializing2) {
+        throw new Error("multiple calls to 'initWasm()' detected.");
+      }
+      if (aborted2) {
+        throw new Error("previous call to 'initWasm()' failed.");
+      }
+      initializing2 = true;
+      if (isProxy()) {
+        return new Promise((resolve, reject) => {
+          proxyWorker?.terminate();
+          void importProxyWorker().then(([objectUrl, worker]) => {
+            try {
+              proxyWorker = worker;
+              proxyWorker.onerror = (ev) => reject(ev);
+              proxyWorker.onmessage = onProxyWorkerMessage;
+              initWasmCallbacks = [resolve, reject];
+              const message = { type: "init-wasm", in: env2 };
+              if (!message.in.wasm.wasmPaths && objectUrl) {
+                const inferredWasmPathPrefix = inferWasmPathPrefixFromScriptSrc();
+                if (inferredWasmPathPrefix) {
+                  message.in.wasm.wasmPaths = inferredWasmPathPrefix;
+                }
+              }
+              if (false) {
+                message.in.wasm.wasmPaths = {
+                  wasm: false ? new URL("ort-wasm-simd-threaded.jsep.wasm", import.meta.url).href : false ? new URL("ort-wasm-simd-threaded.jspi.wasm", import.meta.url).href : true ? new URL("ort-wasm-simd-threaded.asyncify.wasm", import.meta.url).href : new URL("ort-wasm-simd-threaded.wasm", import.meta.url).href
+                };
+              }
+              proxyWorker.postMessage(message);
+              temporaryObjectUrl = objectUrl;
+            } catch (e) {
+              reject(e);
+            }
+          }, reject);
+        });
+      } else {
+        try {
+          await initializeWebAssembly(env2.wasm);
+          await initRuntime(env2);
+          initialized2 = true;
+        } catch (e) {
+          aborted2 = true;
+          throw e;
+        } finally {
+          initializing2 = false;
+        }
+      }
+    };
+    initializeOrtEp = async (epName) => {
+      if (isProxy()) {
+        ensureWorker();
+        return new Promise((resolve, reject) => {
+          enqueueCallbacks("init-ep", [resolve, reject]);
+          const message = { type: "init-ep", in: { epName, env: env2 } };
+          proxyWorker.postMessage(message);
+        });
+      } else {
+        await initEp(env2, epName);
+      }
+    };
+    copyFromExternalBuffer2 = async (buffer) => {
+      if (isProxy()) {
+        ensureWorker();
+        return new Promise((resolve, reject) => {
+          enqueueCallbacks("copy-from", [resolve, reject]);
+          const message = { type: "copy-from", in: { buffer } };
+          proxyWorker.postMessage(message, [buffer.buffer]);
+        });
+      } else {
+        return copyFromExternalBuffer(buffer);
+      }
+    };
+    createSession2 = async (model, options) => {
+      if (isProxy()) {
+        if (options?.preferredOutputLocation) {
+          throw new Error('session option "preferredOutputLocation" is not supported for proxy.');
+        }
+        ensureWorker();
+        return new Promise((resolve, reject) => {
+          enqueueCallbacks("create", [resolve, reject]);
+          const message = { type: "create", in: { model, options: { ...options } } };
+          const transferable = [];
+          if (model instanceof Uint8Array) {
+            transferable.push(model.buffer);
+          }
+          proxyWorker.postMessage(message, transferable);
+        });
+      } else {
+        return createSession(model, options);
+      }
+    };
+    releaseSession2 = async (sessionId) => {
+      if (isProxy()) {
+        ensureWorker();
+        return new Promise((resolve, reject) => {
+          enqueueCallbacks("release", [resolve, reject]);
+          const message = { type: "release", in: sessionId };
+          proxyWorker.postMessage(message);
+        });
+      } else {
+        releaseSession(sessionId);
+      }
+    };
+    run2 = async (sessionId, inputIndices, inputs, outputIndices, outputs, options) => {
+      if (isProxy()) {
+        if (inputs.some((t) => t[3] !== "cpu")) {
+          throw new Error("input tensor on GPU is not supported for proxy.");
+        }
+        if (outputs.some((t) => t)) {
+          throw new Error("pre-allocated output tensor is not supported for proxy.");
+        }
+        ensureWorker();
+        return new Promise((resolve, reject) => {
+          enqueueCallbacks("run", [resolve, reject]);
+          const serializableInputs = inputs;
+          const message = {
+            type: "run",
+            in: { sessionId, inputIndices, inputs: serializableInputs, outputIndices, options }
+          };
+          proxyWorker.postMessage(message, extractTransferableBuffers(serializableInputs));
+        });
+      } else {
+        return run(sessionId, inputIndices, inputs, outputIndices, outputs, options);
+      }
+    };
+    endProfiling2 = async (sessionId) => {
+      if (isProxy()) {
+        ensureWorker();
+        return new Promise((resolve, reject) => {
+          enqueueCallbacks("end-profiling", [resolve, reject]);
+          const message = { type: "end-profiling", in: sessionId };
+          proxyWorker.postMessage(message);
+        });
+      } else {
+        endProfiling(sessionId);
+      }
+    };
+  }
+});
+
+// web/lib/wasm/session-handler-inference.ts
+var encodeTensorMetadata, decodeTensorMetadata, OnnxruntimeWebAssemblySessionHandler;
+var init_session_handler_inference = __esm({
+  "web/lib/wasm/session-handler-inference.ts"() {
+    "use strict";
+    init_esm();
+    init_proxy_wrapper();
+    init_wasm_common();
+    init_wasm_utils_env();
+    init_wasm_utils_load_file();
+    encodeTensorMetadata = (tensor, getName) => {
+      switch (tensor.location) {
+        case "cpu":
+          return [tensor.type, tensor.dims, tensor.data, "cpu"];
+        case "gpu-buffer":
+          return [tensor.type, tensor.dims, { gpuBuffer: tensor.gpuBuffer }, "gpu-buffer"];
+        case "ml-tensor":
+          return [tensor.type, tensor.dims, { mlTensor: tensor.mlTensor }, "ml-tensor"];
+        default:
+          throw new Error(`invalid data location: ${tensor.location} for ${getName()}`);
+      }
+    };
+    decodeTensorMetadata = (tensor) => {
+      switch (tensor[3]) {
+        case "cpu":
+          return new Tensor2(tensor[0], tensor[2], tensor[1]);
+        case "gpu-buffer": {
+          const dataType = tensor[0];
+          if (!isGpuBufferSupportedType(dataType)) {
+            throw new Error(`not supported data type: ${dataType} for deserializing GPU tensor`);
+          }
+          const { gpuBuffer, download, dispose } = tensor[2];
+          return Tensor2.fromGpuBuffer(gpuBuffer, { dataType, dims: tensor[1], download, dispose });
+        }
+        case "ml-tensor": {
+          const dataType = tensor[0];
+          if (!isMLTensorSupportedType(dataType)) {
+            throw new Error(`not supported data type: ${dataType} for deserializing MLTensor tensor`);
+          }
+          const { mlTensor, download, dispose } = tensor[2];
+          return Tensor2.fromMLTensor(mlTensor, { dataType, dims: tensor[1], download, dispose });
+        }
+        default:
+          throw new Error(`invalid data location: ${tensor[3]}`);
+      }
+    };
+    OnnxruntimeWebAssemblySessionHandler = class {
+      async fetchModelAndCopyToWasmMemory(path) {
+        return copyFromExternalBuffer2(await loadFile(path));
+      }
+      async loadModel(pathOrBuffer, options) {
+        TRACE_FUNC_BEGIN();
+        let model;
+        if (typeof pathOrBuffer === "string") {
+          if (isNode) {
+            model = await loadFile(pathOrBuffer);
+          } else {
+            model = await this.fetchModelAndCopyToWasmMemory(pathOrBuffer);
+          }
+        } else {
+          model = pathOrBuffer;
+        }
+        [this.sessionId, this.inputNames, this.outputNames, this.inputMetadata, this.outputMetadata] = await createSession2(
+          model,
+          options
+        );
+        TRACE_FUNC_END();
+      }
+      async dispose() {
+        return releaseSession2(this.sessionId);
+      }
+      async run(feeds, fetches, options) {
+        TRACE_FUNC_BEGIN();
+        const inputArray = [];
+        const inputIndices = [];
+        Object.entries(feeds).forEach((kvp) => {
+          const name = kvp[0];
+          const tensor = kvp[1];
+          const index = this.inputNames.indexOf(name);
+          if (index === -1) {
+            throw new Error(`invalid input '${name}'`);
+          }
+          inputArray.push(tensor);
+          inputIndices.push(index);
+        });
+        const outputArray = [];
+        const outputIndices = [];
+        Object.entries(fetches).forEach((kvp) => {
+          const name = kvp[0];
+          const tensor = kvp[1];
+          const index = this.outputNames.indexOf(name);
+          if (index === -1) {
+            throw new Error(`invalid output '${name}'`);
+          }
+          outputArray.push(tensor);
+          outputIndices.push(index);
+        });
+        const inputs = inputArray.map(
+          (t, i) => encodeTensorMetadata(t, () => `input "${this.inputNames[inputIndices[i]]}"`)
+        );
+        const outputs = outputArray.map(
+          (t, i) => t ? encodeTensorMetadata(t, () => `output "${this.outputNames[outputIndices[i]]}"`) : null
+        );
+        const results = await run2(this.sessionId, inputIndices, inputs, outputIndices, outputs, options);
+        const resultMap = {};
+        for (let i = 0; i < results.length; i++) {
+          resultMap[this.outputNames[outputIndices[i]]] = outputArray[i] ?? decodeTensorMetadata(results[i]);
+        }
+        TRACE_FUNC_END();
+        return resultMap;
+      }
+      startProfiling() {
+      }
+      endProfiling() {
+        void endProfiling2(this.sessionId);
+      }
+    };
+  }
+});
+
+// web/lib/backend-wasm.ts
+var backend_wasm_exports = {};
+__export(backend_wasm_exports, {
+  OnnxruntimeWebAssemblyBackend: () => OnnxruntimeWebAssemblyBackend,
+  initializeFlags: () => initializeFlags,
+  wasmBackend: () => wasmBackend
+});
+var initializeFlags, OnnxruntimeWebAssemblyBackend, wasmBackend;
+var init_backend_wasm = __esm({
+  "web/lib/backend-wasm.ts"() {
+    "use strict";
+    init_esm();
+    init_proxy_wrapper();
+    init_session_handler_inference();
+    initializeFlags = () => {
+      if (typeof env2.wasm.initTimeout !== "number" || env2.wasm.initTimeout < 0) {
+        env2.wasm.initTimeout = 0;
+      }
+      const simd = env2.wasm.simd;
+      if (typeof simd !== "boolean" && simd !== void 0 && simd !== "fixed" && simd !== "relaxed") {
+        console.warn(
+          `Property "env.wasm.simd" is set to unknown value "${simd}". Reset it to \`false\` and ignore SIMD feature checking.`
+        );
+        env2.wasm.simd = false;
+      }
+      if (typeof env2.wasm.proxy !== "boolean") {
+        env2.wasm.proxy = false;
+      }
+      if (typeof env2.wasm.trace !== "boolean") {
+        env2.wasm.trace = false;
+      }
+      if (typeof env2.wasm.numThreads !== "number" || !Number.isInteger(env2.wasm.numThreads) || env2.wasm.numThreads <= 0) {
+        if (typeof self !== "undefined" && !self.crossOriginIsolated) {
+          env2.wasm.numThreads = 1;
+        } else {
+          const numCpuLogicalCores = typeof navigator === "undefined" ? __require("node:os").cpus().length : navigator.hardwareConcurrency;
+          env2.wasm.numThreads = Math.min(4, Math.ceil((numCpuLogicalCores || 1) / 2));
+        }
+      }
+    };
+    OnnxruntimeWebAssemblyBackend = class {
+      /**
+       * This function initializes the WebAssembly backend.
+       *
+       * This function will be called only once for each backend name. It will be called the first time when
+       * `ort.InferenceSession.create()` is called with a registered backend name.
+       *
+       * @param backendName - the registered backend name.
+       */
+      async init(backendName) {
+        initializeFlags();
+        await initializeWebAssemblyAndOrtRuntime();
+        await initializeOrtEp(backendName);
+      }
+      async createInferenceSessionHandler(pathOrBuffer, options) {
+        const handler = new OnnxruntimeWebAssemblySessionHandler();
+        await handler.loadModel(pathOrBuffer, options);
+        return handler;
+      }
+    };
+    wasmBackend = new OnnxruntimeWebAssemblyBackend();
+  }
+});
+
+// web/lib/index.ts
+init_esm();
+init_esm();
+init_esm();
+
+// web/lib/version.ts
+var version2 = "1.26.0";
+
+// web/lib/index.ts
+var index_default = esm_exports;
+if (false) {
+  const onnxjsBackend = null.onnxjsBackend;
+  registerBackend("webgl", onnxjsBackend, -10);
+}
+if (false) {
+  throw new Error(
+    "The current build is specified to enable both JSEP and WebGPU EP. This is not a valid configuration. JSEP and WebGPU EPs cannot be enabled at the same time."
+  );
+}
+if (false) {
+  throw new Error(
+    "The current build is specified to enable WebNN EP without JSEP or WebGPU EP. This is not a valid configuration. WebNN EP requires either JSEP or WebGPU EP to be enabled."
+  );
+}
+if (true) {
+  const wasmBackend2 = (init_backend_wasm(), __toCommonJS(backend_wasm_exports)).wasmBackend;
+  if (true) {
+    registerBackend("webgpu", wasmBackend2, 5);
+  }
+  if (true) {
+    registerBackend("webnn", wasmBackend2, 5);
+  }
+  registerBackend("cpu", wasmBackend2, 10);
+  registerBackend("wasm", wasmBackend2, 10);
+}
+Object.defineProperty(env2.versions, "web", { value: version2, enumerable: true });
+export {
+  InferenceSession2 as InferenceSession,
+  TRACE,
+  TRACE_EVENT_BEGIN,
+  TRACE_EVENT_END,
+  TRACE_FUNC_BEGIN,
+  TRACE_FUNC_END,
+  Tensor2 as Tensor,
+  index_default as default,
+  env2 as env,
+  registerBackend
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../common/lib/backend-impl.ts", "../../common/lib/backend.ts", "../../common/lib/version.ts", "../../common/lib/env-impl.ts", "../../common/lib/env.ts", "../../common/lib/tensor-conversion-impl.ts", "../../common/lib/tensor-factory-impl.ts", "../../common/lib/tensor-impl-type-mapping.ts", "../../common/lib/tensor-utils-impl.ts", "../../common/lib/tensor-impl.ts", "../../common/lib/tensor.ts", "../../common/lib/trace.ts", "../../common/lib/inference-session-impl.ts", "../../common/lib/inference-session.ts", "../../common/lib/tensor-conversion.ts", "../../common/lib/tensor-factory.ts", "../../common/lib/onnx-model.ts", "../../common/lib/onnx-value.ts", "../../common/lib/index.ts", "../lib/wasm/wasm-utils-env.ts", "../lib/wasm/proxy-worker/main.ts", "../lib/wasm/wasm-utils-import.ts", "../lib/wasm/wasm-factory.ts", "../lib/wasm/wasm-utils.ts", "../lib/wasm/run-options.ts", "../lib/wasm/session-options.ts", "../lib/wasm/wasm-common.ts", "../lib/wasm/wasm-utils-load-file.ts", "../lib/wasm/jsep/tensor-view.ts", "../lib/wasm/jsep/log.ts", "../lib/wasm/jsep/webnn/tensor-manager.ts", "../lib/wasm/jsep/backend-webnn.ts", "../lib/wasm/wasm-core-impl.ts", "../lib/wasm/proxy-wrapper.ts", "../lib/wasm/session-handler-inference.ts", "../lib/backend-wasm.ts", "../lib/index.ts", "../lib/version.ts"],
  "sourcesContent": ["// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Backend } from './backend.js';\nimport { InferenceSession } from './inference-session.js';\n\ninterface BackendInfo {\n  backend: Backend;\n  priority: number;\n\n  initPromise?: Promise<void>;\n  initialized?: boolean;\n  aborted?: boolean;\n  error?: string;\n}\n\nconst backends: Map<string, BackendInfo> = new Map();\nconst backendsSortedByPriority: string[] = [];\n\n/**\n * Register a backend.\n *\n * @param name - the name as a key to lookup as an execution provider.\n * @param backend - the backend object.\n * @param priority - an integer indicating the priority of the backend. Higher number means higher priority. if priority\n * < 0, it will be considered as a 'beta' version and will not be used as a fallback backend by default.\n *\n * @ignore\n */\nexport const registerBackend = (name: string, backend: Backend, priority: number): void => {\n  if (backend && typeof backend.init === 'function' && typeof backend.createInferenceSessionHandler === 'function') {\n    const currentBackend = backends.get(name);\n    if (currentBackend === undefined) {\n      backends.set(name, { backend, priority });\n    } else if (currentBackend.priority > priority) {\n      // same name is already registered with a higher priority. skip registeration.\n      return;\n    } else if (currentBackend.priority === priority) {\n      if (currentBackend.backend !== backend) {\n        throw new Error(`cannot register backend \"${name}\" using priority ${priority}`);\n      }\n    }\n\n    if (priority >= 0) {\n      const i = backendsSortedByPriority.indexOf(name);\n      if (i !== -1) {\n        backendsSortedByPriority.splice(i, 1);\n      }\n\n      for (let i = 0; i < backendsSortedByPriority.length; i++) {\n        if (backends.get(backendsSortedByPriority[i])!.priority <= priority) {\n          backendsSortedByPriority.splice(i, 0, name);\n          return;\n        }\n      }\n      backendsSortedByPriority.push(name);\n    }\n    return;\n  }\n\n  throw new TypeError('not a valid backend');\n};\n\n/**\n * Try to resolve and initialize a backend.\n *\n * @param backendName - the name of the backend.\n * @returns the backend instance if resolved and initialized successfully, or an error message if failed.\n */\nconst tryResolveAndInitializeBackend = async (backendName: string): Promise<Backend | string> => {\n  const backendInfo = backends.get(backendName);\n  if (!backendInfo) {\n    return 'backend not found.';\n  }\n\n  if (backendInfo.initialized) {\n    return backendInfo.backend;\n  } else if (backendInfo.aborted) {\n    return backendInfo.error!;\n  } else {\n    const isInitializing = !!backendInfo.initPromise;\n    try {\n      if (!isInitializing) {\n        backendInfo.initPromise = backendInfo.backend.init(backendName);\n      }\n      await backendInfo.initPromise;\n      backendInfo.initialized = true;\n      return backendInfo.backend;\n    } catch (e) {\n      if (!isInitializing) {\n        backendInfo.error = `${e}`;\n        backendInfo.aborted = true;\n      }\n      return backendInfo.error!;\n    } finally {\n      delete backendInfo.initPromise;\n    }\n  }\n};\n\n/**\n * Resolve execution providers from the specific session options.\n *\n * @param options - the session options object.\n * @returns a promise that resolves to a tuple of an initialized backend instance and a session options object with\n * filtered EP list.\n *\n * @ignore\n */\nexport const resolveBackendAndExecutionProviders = async (\n  options: InferenceSession.SessionOptions,\n): Promise<[backend: Backend, options: InferenceSession.SessionOptions]> => {\n  // extract backend hints from session options\n  const eps = options.executionProviders || [];\n  const backendHints = eps.map((i) => (typeof i === 'string' ? i : i.name));\n  const backendNames = backendHints.length === 0 ? backendsSortedByPriority : backendHints;\n\n  // try to resolve and initialize all requested backends\n  let backend: Backend | undefined;\n  const errors = [];\n  const availableBackendNames = new Set<string>();\n  for (const backendName of backendNames) {\n    const resolveResult = await tryResolveAndInitializeBackend(backendName);\n    if (typeof resolveResult === 'string') {\n      errors.push({ name: backendName, err: resolveResult });\n    } else {\n      if (!backend) {\n        backend = resolveResult;\n      }\n      if (backend === resolveResult) {\n        availableBackendNames.add(backendName);\n      }\n    }\n  }\n\n  // if no backend is available, throw error.\n  if (!backend) {\n    throw new Error(`no available backend found. ERR: ${errors.map((e) => `[${e.name}] ${e.err}`).join(', ')}`);\n  }\n\n  // for each explicitly requested backend, if it's not available, output warning message.\n  for (const { name, err } of errors) {\n    if (backendHints.includes(name)) {\n      // eslint-disable-next-line no-console\n      console.warn(\n        `removing requested execution provider \"${name}\" from session options because it is not available: ${err}`,\n      );\n    }\n  }\n\n  const filteredEps = eps.filter((i) => availableBackendNames.has(typeof i === 'string' ? i : i.name));\n\n  return [\n    backend,\n    new Proxy(options, {\n      get: (target, prop) => {\n        if (prop === 'executionProviders') {\n          return filteredEps;\n        }\n        return Reflect.get(target, prop);\n      },\n    }),\n  ];\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { InferenceSession } from './inference-session.js';\nimport { OnnxValue } from './onnx-value.js';\n\n/**\n * @ignore\n */\nexport declare namespace SessionHandler {\n  type FeedsType = { [name: string]: OnnxValue };\n  type FetchesType = { [name: string]: OnnxValue | null };\n  type ReturnType = { [name: string]: OnnxValue };\n}\n\n/**\n * Represents shared SessionHandler functionality\n *\n * @ignore\n */\ninterface SessionHandler {\n  dispose(): Promise<void>;\n\n  readonly inputNames: readonly string[];\n  readonly outputNames: readonly string[];\n\n  readonly inputMetadata: readonly InferenceSession.ValueMetadata[];\n  readonly outputMetadata: readonly InferenceSession.ValueMetadata[];\n}\n\n/**\n * Represent a handler instance of an inference session.\n *\n * @ignore\n */\nexport interface InferenceSessionHandler extends SessionHandler {\n  startProfiling(): void;\n  endProfiling(): void;\n\n  run(\n    feeds: SessionHandler.FeedsType,\n    fetches: SessionHandler.FetchesType,\n    options: InferenceSession.RunOptions,\n  ): Promise<SessionHandler.ReturnType>;\n}\n\n/**\n * Represent a backend that provides implementation of model inferencing.\n *\n * @ignore\n */\nexport interface Backend {\n  /**\n   * Initialize the backend asynchronously. Should throw when failed.\n   */\n  init(backendName: string): Promise<void>;\n\n  createInferenceSessionHandler(\n    uriOrBuffer: string | Uint8Array,\n    options?: InferenceSession.SessionOptions,\n  ): Promise<InferenceSessionHandler>;\n}\n\nexport { registerBackend } from './backend-impl.js';\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n// This file is generated by /js/scripts/update-version.ts\n// Do not modify file content manually.\n\nexport const version = '1.26.0';\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Env } from './env.js';\nimport { version } from './version.js';\n\ntype LogLevelType = Env['logLevel'];\n\nlet logLevelValue: Required<LogLevelType> = 'warning';\n\nexport const env: Env = {\n  wasm: {} as Env.WebAssemblyFlags,\n  webgl: {} as Env.WebGLFlags,\n  webgpu: {} as Env.WebGpuFlags,\n  versions: { common: version },\n\n  set logLevel(value: LogLevelType) {\n    if (value === undefined) {\n      return;\n    }\n    if (typeof value !== 'string' || ['verbose', 'info', 'warning', 'error', 'fatal'].indexOf(value) === -1) {\n      throw new Error(`Unsupported logging level: ${value}`);\n    }\n    logLevelValue = value;\n  },\n  get logLevel(): Required<LogLevelType> {\n    return logLevelValue;\n  },\n};\n\n// set property 'logLevel' so that they can be correctly transferred to worker by `postMessage()`.\nObject.defineProperty(env, 'logLevel', { enumerable: true });\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { env as envImpl } from './env-impl.js';\nimport { TryGetGlobalType } from './type-helper.js';\n\nexport declare namespace Env {\n  export type WasmPathPrefix = string;\n  export interface WasmFilePaths {\n    /**\n     * Specify the override path for the main .wasm file.\n     *\n     * This path should be an absolute path.\n     *\n     * If not modified, the filename of the .wasm file is:\n     * - `ort-wasm-simd-threaded.wasm` for default build\n     * - `ort-wasm-simd-threaded.jsep.wasm` for JSEP build (with WebGPU and WebNN)\n     * - `ort-wasm-simd-threaded.asyncify.wasm` for WebGPU build with Asyncify (with WebNN)\n     * - `ort-wasm-simd-threaded.jspi.wasm` for WebGPU build with JSPI support (with WebNN)\n     */\n    wasm?: URL | string;\n    /**\n     * Specify the override path for the main .mjs file.\n     *\n     * This path should be an absolute path.\n     *\n     * If not modified, the filename of the .mjs file is:\n     * - `ort-wasm-simd-threaded.mjs` for default build\n     * - `ort-wasm-simd-threaded.jsep.mjs` for JSEP build (with WebGPU and WebNN)\n     * - `ort-wasm-simd-threaded.asyncify.mjs` for WebGPU build with Asyncify (with WebNN)\n     * - `ort-wasm-simd-threaded.jspi.mjs` for WebGPU build with JSPI support (with WebNN)\n     */\n    mjs?: URL | string;\n  }\n  export type WasmPrefixOrFilePaths = WasmPathPrefix | WasmFilePaths;\n  export interface WebAssemblyFlags {\n    /**\n     * set or get number of thread(s). If omitted or set to 0, number of thread(s) will be determined by system. If set\n     * to 1, no worker thread will be spawned.\n     *\n     * This setting is available only when WebAssembly multithread feature is available in current context.\n     *\n     * @defaultValue `0`\n     */\n    numThreads?: number;\n\n    /**\n     * set a value indicating whether to enable SIMD.\n     *\n     * ONNX Runtime will perform feature detection based on the value of this property. Specifically, when the value is\n     * set to:\n     * - `undefined`, `true` or `\"fixed\"`: will check availability of Fixed-width SIMD.\n     * - `\"relaxed\"`: will check availability of Relaxed SIMD.\n     * - `false`: will not perform SIMD feature checking.\n     *\n     * Setting this property does not make ONNX Runtime to switch to the corresponding runtime automatically. User need\n     * to set `wasmPaths` or `wasmBinary` property to load the corresponding runtime.\n     *\n     * This setting is available only when WebAssembly SIMD feature is available in current context.\n     *\n     * @defaultValue `true`\n     */\n    simd?: boolean | 'fixed' | 'relaxed';\n\n    /**\n     * set or get a boolean value indicating whether to enable trace.\n     *\n     * @defaultValue `false`\n     *\n     * @deprecated Use `env.trace` instead. If `env.trace` is set, this property will be ignored.\n     */\n    trace?: boolean;\n\n    /**\n     * Set or get a number specifying the timeout for initialization of WebAssembly backend, in milliseconds. A zero\n     * value indicates no timeout is set.\n     *\n     * @defaultValue `0`\n     */\n    initTimeout?: number;\n\n    /**\n     * Set a custom URL prefix to the .wasm/.mjs files, or an object of overrides for both .wasm/.mjs file. The override\n     * path should be an absolute path.\n     */\n    wasmPaths?: WasmPrefixOrFilePaths;\n\n    /**\n     * Set a custom buffer which contains the WebAssembly binary. If this property is set, the `wasmPaths` property will\n     * be ignored.\n     */\n    wasmBinary?: ArrayBufferLike | Uint8Array;\n\n    /**\n     * Set or get a boolean value indicating whether to proxy the execution of main thread to a worker thread.\n     *\n     * @defaultValue `false`\n     */\n    proxy?: boolean;\n  }\n\n  export interface WebGLFlags {\n    /**\n     * Set or get the WebGL Context ID (webgl or webgl2).\n     *\n     * @defaultValue `'webgl2'`\n     */\n    contextId?: 'webgl' | 'webgl2';\n    /**\n     * Get the WebGL rendering context.\n     */\n    readonly context: WebGLRenderingContext;\n    /**\n     * Set or get the maximum batch size for matmul. 0 means to disable batching.\n     *\n     * @deprecated\n     */\n    matmulMaxBatchSize?: number;\n    /**\n     * Set or get the texture cache mode.\n     *\n     * @defaultValue `'full'`\n     */\n    textureCacheMode?: 'initializerOnly' | 'full';\n    /**\n     * Set or get the packed texture mode\n     *\n     * @defaultValue `false`\n     */\n    pack?: boolean;\n    /**\n     * Set or get whether enable async download.\n     *\n     * @defaultValue `false`\n     */\n    async?: boolean;\n  }\n\n  export interface WebGpuProfilingDataV1TensorMetadata {\n    dims: readonly number[];\n    dataType: string;\n  }\n  export interface WebGpuProfilingDataV1 {\n    version: 1;\n    inputsMetadata: readonly WebGpuProfilingDataV1TensorMetadata[];\n    outputsMetadata: readonly WebGpuProfilingDataV1TensorMetadata[];\n    kernelId: number;\n    kernelType: string;\n    kernelName: string;\n    programName: string;\n    startTime: number;\n    endTime: number;\n  }\n\n  export type WebGpuProfilingData = WebGpuProfilingDataV1;\n\n  export interface WebGpuFlags {\n    /**\n     * Set or get the profiling mode.\n     *\n     * @deprecated Use `env.webgpu.profiling.mode` instead. If `env.webgpu.profiling.mode` is set, this property will be\n     * ignored.\n     */\n    profilingMode?: 'off' | 'default';\n    /**\n     * Set or get the profiling configuration.\n     */\n    profiling: {\n      /**\n       * Set or get the profiling mode.\n       *\n       * @defaultValue `'off'`\n       */\n      mode?: 'off' | 'default';\n\n      /**\n       * Set or get a callback function when a profiling data is received. If not set, the profiling data will be\n       * printed to console.\n       */\n      ondata?: (data: WebGpuProfilingData) => void;\n    };\n    /**\n     * Set or get the power preference.\n     *\n     * Setting this property only has effect before the first WebGPU inference session is created. The value will be\n     * used as options for `navigator.gpu.requestAdapter()`.\n     *\n     * See {@link https://gpuweb.github.io/gpuweb/#dictdef-gpurequestadapteroptions} for more details.\n     *\n     * @defaultValue `undefined`\n     *\n     * @deprecated Create your own GPUAdapter, use it to create a GPUDevice instance and set {@link device} property if\n     * you want to use a specific power preference.\n     */\n    powerPreference?: 'low-power' | 'high-performance';\n    /**\n     * Set or get the force fallback adapter flag.\n     *\n     * Setting this property only has effect before the first WebGPU inference session is created. The value will be\n     * used as options for `navigator.gpu.requestAdapter()`.\n     *\n     * See {@link https://gpuweb.github.io/gpuweb/#dictdef-gpurequestadapteroptions} for more details.\n     *\n     * @defaultValue `undefined`\n     *\n     * @deprecated Create your own GPUAdapter, use it to create a GPUDevice instance and set {@link device} property if\n     * you want to use a specific fallback option.\n     */\n    forceFallbackAdapter?: boolean;\n    /**\n     * Set or get the adapter for WebGPU.\n     *\n     * Setting this property only has effect before the first WebGPU inference session is created. The value will be\n     * used as the GPU adapter for the underlying WebGPU backend to create GPU device.\n     *\n     * If this property is not set, it will be available to get after the first WebGPU inference session is created. The\n     * value will be the GPU adapter that created by the underlying WebGPU backend.\n     *\n     * When use with TypeScript, the type of this property is `GPUAdapter` defined in \"@webgpu/types\".\n     *\n     * @deprecated It is no longer recommended to use this property. The latest WebGPU spec adds `GPUDevice.adapterInfo`\n     * (https://www.w3.org/TR/webgpu/#dom-gpudevice-adapterinfo), which allows to get the adapter information from the\n     * device. When it's available, there is no need to set/get the {@link adapter} property.\n     */\n    adapter: TryGetGlobalType<'GPUAdapter'>;\n    /**\n     * Set or get the GPU device for WebGPU.\n     *\n     * There are 3 valid scenarios of accessing this property:\n     * - Set a value before the first WebGPU inference session is created. The value will be used by the WebGPU backend\n     * to perform calculations. If the value is not a `GPUDevice` object, an error will be thrown.\n     * - Get the value before the first WebGPU inference session is created. This will try to create a new GPUDevice\n     * instance. Returns a `Promise` that resolves to a `GPUDevice` object.\n     * - Get the value after the first WebGPU inference session is created. Returns a resolved `Promise` to the\n     * `GPUDevice` object used by the WebGPU backend.\n     */\n    get device(): Promise<TryGetGlobalType<'GPUDevice'>>;\n    set device(value: TryGetGlobalType<'GPUDevice'>);\n    /**\n     * Set or get whether validate input content.\n     *\n     * @defaultValue `false`\n     */\n    validateInputContent?: boolean;\n  }\n}\n\nexport interface Env {\n  /**\n   * set the severity level for logging.\n   *\n   * @defaultValue `'warning'`\n   */\n  logLevel?: 'verbose' | 'info' | 'warning' | 'error' | 'fatal';\n\n  /**\n   * Indicate whether run in debug mode.\n   *\n   * @defaultValue `false`\n   */\n  debug?: boolean;\n\n  /**\n   * set or get a boolean value indicating whether to enable trace.\n   *\n   * @defaultValue `false`\n   */\n  trace?: boolean;\n\n  /**\n   * Get version of the current package.\n   */\n  readonly versions: {\n    readonly common: string;\n    readonly web?: string;\n    readonly node?: string;\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    readonly 'react-native'?: string;\n  };\n\n  /**\n   * Represent a set of flags for WebAssembly\n   */\n  readonly wasm: Env.WebAssemblyFlags;\n\n  /**\n   * Represent a set of flags for WebGL\n   */\n  readonly webgl: Env.WebGLFlags;\n\n  /**\n   * Represent a set of flags for WebGPU\n   */\n  readonly webgpu: Env.WebGpuFlags;\n\n  [name: string]: unknown;\n}\n\n/**\n * Represent a set of flags as a global singleton.\n */\nexport const env: Env = envImpl;\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { TensorToDataUrlOptions, TensorToImageDataOptions } from './tensor-conversion.js';\nimport { Tensor } from './tensor.js';\n\n/**\n * implementation of Tensor.toDataURL()\n */\nexport const tensorToDataURL = (tensor: Tensor, options?: TensorToDataUrlOptions): string => {\n  const canvas = typeof document !== 'undefined' ? document.createElement('canvas') : new OffscreenCanvas(1, 1);\n  canvas.width = tensor.dims[3];\n  canvas.height = tensor.dims[2];\n  const pixels2DContext = canvas.getContext('2d') as\n    | CanvasRenderingContext2D\n    | OffscreenCanvasRenderingContext2D\n    | null;\n\n  if (pixels2DContext != null) {\n    // Default values for height and width & format\n    let width: number;\n    let height: number;\n    if (options?.tensorLayout !== undefined && options.tensorLayout === 'NHWC') {\n      width = tensor.dims[2];\n      height = tensor.dims[3];\n    } else {\n      // Default layout is NCWH\n      width = tensor.dims[3];\n      height = tensor.dims[2];\n    }\n\n    const inputformat = options?.format !== undefined ? options.format : 'RGB';\n\n    const norm = options?.norm;\n    let normMean: [number, number, number, number];\n    let normBias: [number, number, number, number];\n    if (norm === undefined || norm.mean === undefined) {\n      normMean = [255, 255, 255, 255];\n    } else {\n      if (typeof norm.mean === 'number') {\n        normMean = [norm.mean, norm.mean, norm.mean, norm.mean];\n      } else {\n        normMean = [norm.mean[0], norm.mean[1], norm.mean[2], 0];\n        if (norm.mean[3] !== undefined) {\n          normMean[3] = norm.mean[3];\n        }\n      }\n    }\n    if (norm === undefined || norm.bias === undefined) {\n      normBias = [0, 0, 0, 0];\n    } else {\n      if (typeof norm.bias === 'number') {\n        normBias = [norm.bias, norm.bias, norm.bias, norm.bias];\n      } else {\n        normBias = [norm.bias[0], norm.bias[1], norm.bias[2], 0];\n        if (norm.bias[3] !== undefined) {\n          normBias[3] = norm.bias[3];\n        }\n      }\n    }\n\n    const stride = height * width;\n    // Default pointer assignments\n    let rTensorPointer = 0,\n      gTensorPointer = stride,\n      bTensorPointer = stride * 2,\n      aTensorPointer = -1;\n\n    // Updating the pointer assignments based on the input image format\n    if (inputformat === 'RGBA') {\n      rTensorPointer = 0;\n      gTensorPointer = stride;\n      bTensorPointer = stride * 2;\n      aTensorPointer = stride * 3;\n    } else if (inputformat === 'RGB') {\n      rTensorPointer = 0;\n      gTensorPointer = stride;\n      bTensorPointer = stride * 2;\n    } else if (inputformat === 'RBG') {\n      rTensorPointer = 0;\n      bTensorPointer = stride;\n      gTensorPointer = stride * 2;\n    }\n\n    for (let i = 0; i < height; i++) {\n      for (let j = 0; j < width; j++) {\n        const R = ((tensor.data[rTensorPointer++] as number) - normBias[0]) * normMean[0]; // R value\n        const G = ((tensor.data[gTensorPointer++] as number) - normBias[1]) * normMean[1]; // G value\n        const B = ((tensor.data[bTensorPointer++] as number) - normBias[2]) * normMean[2]; // B value\n        const A = aTensorPointer === -1 ? 255 : ((tensor.data[aTensorPointer++] as number) - normBias[3]) * normMean[3]; // A value\n\n        pixels2DContext.fillStyle = 'rgba(' + R + ',' + G + ',' + B + ',' + A + ')';\n        pixels2DContext.fillRect(j, i, 1, 1);\n      }\n    }\n    if ('toDataURL' in canvas) {\n      return canvas.toDataURL();\n    } else {\n      throw new Error('toDataURL is not supported');\n    }\n  } else {\n    throw new Error('Can not access image data');\n  }\n};\n\n/**\n * implementation of Tensor.toImageData()\n */\nexport const tensorToImageData = (tensor: Tensor, options?: TensorToImageDataOptions): ImageData => {\n  const pixels2DContext =\n    typeof document !== 'undefined'\n      ? document.createElement('canvas').getContext('2d')\n      : (new OffscreenCanvas(1, 1).getContext('2d') as OffscreenCanvasRenderingContext2D);\n  let image: ImageData;\n  if (pixels2DContext != null) {\n    // Default values for height and width & format\n    let width: number;\n    let height: number;\n    let channels: number;\n    if (options?.tensorLayout !== undefined && options.tensorLayout === 'NHWC') {\n      width = tensor.dims[2];\n      height = tensor.dims[1];\n      channels = tensor.dims[3];\n    } else {\n      // Default layout is NCWH\n      width = tensor.dims[3];\n      height = tensor.dims[2];\n      channels = tensor.dims[1];\n    }\n    const inputformat = options !== undefined ? (options.format !== undefined ? options.format : 'RGB') : 'RGB';\n\n    const norm = options?.norm;\n    let normMean: [number, number, number, number];\n    let normBias: [number, number, number, number];\n    if (norm === undefined || norm.mean === undefined) {\n      normMean = [255, 255, 255, 255];\n    } else {\n      if (typeof norm.mean === 'number') {\n        normMean = [norm.mean, norm.mean, norm.mean, norm.mean];\n      } else {\n        normMean = [norm.mean[0], norm.mean[1], norm.mean[2], 255];\n        if (norm.mean[3] !== undefined) {\n          normMean[3] = norm.mean[3];\n        }\n      }\n    }\n    if (norm === undefined || norm.bias === undefined) {\n      normBias = [0, 0, 0, 0];\n    } else {\n      if (typeof norm.bias === 'number') {\n        normBias = [norm.bias, norm.bias, norm.bias, norm.bias];\n      } else {\n        normBias = [norm.bias[0], norm.bias[1], norm.bias[2], 0];\n        if (norm.bias[3] !== undefined) {\n          normBias[3] = norm.bias[3];\n        }\n      }\n    }\n\n    const stride = height * width;\n    if (options !== undefined) {\n      if (\n        (options.format !== undefined && channels === 4 && options.format !== 'RGBA') ||\n        (channels === 3 && options.format !== 'RGB' && options.format !== 'BGR')\n      ) {\n        throw new Error(\"Tensor format doesn't match input tensor dims\");\n      }\n    }\n\n    // Default pointer assignments\n    const step = 4;\n    let rImagePointer = 0,\n      gImagePointer = 1,\n      bImagePointer = 2,\n      aImagePointer = 3;\n    let rTensorPointer = 0,\n      gTensorPointer = stride,\n      bTensorPointer = stride * 2,\n      aTensorPointer = -1;\n\n    // Updating the pointer assignments based on the input image format\n    if (inputformat === 'RGBA') {\n      rTensorPointer = 0;\n      gTensorPointer = stride;\n      bTensorPointer = stride * 2;\n      aTensorPointer = stride * 3;\n    } else if (inputformat === 'RGB') {\n      rTensorPointer = 0;\n      gTensorPointer = stride;\n      bTensorPointer = stride * 2;\n    } else if (inputformat === 'RBG') {\n      rTensorPointer = 0;\n      bTensorPointer = stride;\n      gTensorPointer = stride * 2;\n    }\n\n    image = pixels2DContext.createImageData(width, height);\n\n    for (\n      let i = 0;\n      i < height * width;\n      rImagePointer += step, gImagePointer += step, bImagePointer += step, aImagePointer += step, i++\n    ) {\n      image.data[rImagePointer] = ((tensor.data[rTensorPointer++] as number) - normBias[0]) * normMean[0]; // R value\n      image.data[gImagePointer] = ((tensor.data[gTensorPointer++] as number) - normBias[1]) * normMean[1]; // G value\n      image.data[bImagePointer] = ((tensor.data[bTensorPointer++] as number) - normBias[2]) * normMean[2]; // B value\n      image.data[aImagePointer] =\n        aTensorPointer === -1 ? 255 : ((tensor.data[aTensorPointer++] as number) - normBias[3]) * normMean[3]; // A value\n    }\n  } else {\n    throw new Error('Can not access image data');\n  }\n  return image;\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {\n  OptionsDimensions,\n  OptionsFormat,\n  OptionsNormalizationParameters,\n  OptionsTensorFormat,\n  OptionsTensorLayout,\n  TensorFromGpuBufferOptions,\n  TensorFromImageBitmapOptions,\n  TensorFromImageDataOptions,\n  TensorFromImageElementOptions,\n  TensorFromMLTensorOptions,\n  TensorFromTextureOptions,\n  TensorFromUrlOptions,\n} from './tensor-factory.js';\nimport { Tensor } from './tensor-impl.js';\nimport { Tensor as TensorInterface } from './tensor.js';\n\ninterface BufferToTensorOptions\n  extends OptionsDimensions,\n    OptionsTensorLayout,\n    OptionsNormalizationParameters,\n    OptionsFormat,\n    OptionsTensorFormat {}\n\n/**\n * Create a new tensor object from image object\n *\n * @param buffer - Extracted image buffer data - assuming RGBA format\n * @param imageFormat - input image configuration - required configurations height, width, format\n * @param tensorFormat - output tensor configuration - Default is RGB format\n */\nexport const bufferToTensor = (buffer: Uint8ClampedArray | undefined, options: BufferToTensorOptions): Tensor => {\n  if (buffer === undefined) {\n    throw new Error('Image buffer must be defined');\n  }\n  if (options.height === undefined || options.width === undefined) {\n    throw new Error('Image height and width must be defined');\n  }\n  if (options.tensorLayout === 'NHWC') {\n    throw new Error('NHWC Tensor layout is not supported yet');\n  }\n\n  const { height, width } = options;\n\n  const norm = options.norm ?? { mean: 255, bias: 0 };\n  let normMean: [number, number, number, number];\n  let normBias: [number, number, number, number];\n\n  if (typeof norm.mean === 'number') {\n    normMean = [norm.mean, norm.mean, norm.mean, norm.mean];\n  } else {\n    normMean = [norm.mean![0], norm.mean![1], norm.mean![2], norm.mean![3] ?? 255];\n  }\n\n  if (typeof norm.bias === 'number') {\n    normBias = [norm.bias, norm.bias, norm.bias, norm.bias];\n  } else {\n    normBias = [norm.bias![0], norm.bias![1], norm.bias![2], norm.bias![3] ?? 0];\n  }\n\n  const inputformat = options.format !== undefined ? options.format : 'RGBA';\n  // default value is RGBA since imagedata and HTMLImageElement uses it\n\n  const outputformat =\n    options.tensorFormat !== undefined ? (options.tensorFormat !== undefined ? options.tensorFormat : 'RGB') : 'RGB';\n  const stride = height * width;\n  const float32Data = outputformat === 'RGBA' ? new Float32Array(stride * 4) : new Float32Array(stride * 3);\n\n  // Default pointer assignments\n  let step = 4,\n    rImagePointer = 0,\n    gImagePointer = 1,\n    bImagePointer = 2,\n    aImagePointer = 3;\n  let rTensorPointer = 0,\n    gTensorPointer = stride,\n    bTensorPointer = stride * 2,\n    aTensorPointer = -1;\n\n  // Updating the pointer assignments based on the input image format\n  if (inputformat === 'RGB') {\n    step = 3;\n    rImagePointer = 0;\n    gImagePointer = 1;\n    bImagePointer = 2;\n    aImagePointer = -1;\n  }\n\n  // Updating the pointer assignments based on the output tensor format\n  if (outputformat === 'RGBA') {\n    aTensorPointer = stride * 3;\n  } else if (outputformat === 'RBG') {\n    rTensorPointer = 0;\n    bTensorPointer = stride;\n    gTensorPointer = stride * 2;\n  } else if (outputformat === 'BGR') {\n    bTensorPointer = 0;\n    gTensorPointer = stride;\n    rTensorPointer = stride * 2;\n  }\n\n  for (\n    let i = 0;\n    i < stride;\n    i++, rImagePointer += step, bImagePointer += step, gImagePointer += step, aImagePointer += step\n  ) {\n    float32Data[rTensorPointer++] = (buffer[rImagePointer] + normBias[0]) / normMean[0];\n    float32Data[gTensorPointer++] = (buffer[gImagePointer] + normBias[1]) / normMean[1];\n    float32Data[bTensorPointer++] = (buffer[bImagePointer] + normBias[2]) / normMean[2];\n    if (aTensorPointer !== -1 && aImagePointer !== -1) {\n      float32Data[aTensorPointer++] = (buffer[aImagePointer] + normBias[3]) / normMean[3];\n    }\n  }\n\n  // Float32Array -> ort.Tensor\n  const outputTensor =\n    outputformat === 'RGBA'\n      ? new Tensor('float32', float32Data, [1, 4, height, width])\n      : new Tensor('float32', float32Data, [1, 3, height, width]);\n  return outputTensor;\n};\n\n/**\n * implementation of Tensor.fromImage().\n */\nexport const tensorFromImage = async (\n  image: ImageData | HTMLImageElement | ImageBitmap | string,\n  options?:\n    | TensorFromImageDataOptions\n    | TensorFromImageElementOptions\n    | TensorFromImageBitmapOptions\n    | TensorFromUrlOptions,\n): Promise<Tensor> => {\n  // checking the type of image object\n  const isHTMLImageEle = typeof HTMLImageElement !== 'undefined' && image instanceof HTMLImageElement;\n  const isImageDataEle = typeof ImageData !== 'undefined' && image instanceof ImageData;\n  const isImageBitmap = typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap;\n  const isString = typeof image === 'string';\n\n  let data: Uint8ClampedArray | undefined;\n  let bufferToTensorOptions: BufferToTensorOptions = options ?? {};\n\n  const createCanvas = () => {\n    if (typeof document !== 'undefined') {\n      return document.createElement('canvas');\n    } else if (typeof OffscreenCanvas !== 'undefined') {\n      return new OffscreenCanvas(1, 1);\n    } else {\n      throw new Error('Canvas is not supported');\n    }\n  };\n  const createCanvasContext = (canvas: HTMLCanvasElement | OffscreenCanvas) => {\n    if (typeof HTMLCanvasElement !== 'undefined' && canvas instanceof HTMLCanvasElement) {\n      return canvas.getContext('2d');\n    } else if (canvas instanceof OffscreenCanvas) {\n      return canvas.getContext('2d') as OffscreenCanvasRenderingContext2D;\n    } else {\n      return null;\n    }\n  };\n  // filling and checking image configuration options\n  if (isHTMLImageEle) {\n    // HTMLImageElement - image object - format is RGBA by default\n    const canvas = createCanvas();\n    canvas.width = image.width;\n    canvas.height = image.height;\n    const pixels2DContext = createCanvasContext(canvas);\n\n    if (pixels2DContext != null) {\n      let height = image.height;\n      let width = image.width;\n      if (options !== undefined && options.resizedHeight !== undefined && options.resizedWidth !== undefined) {\n        height = options.resizedHeight;\n        width = options.resizedWidth;\n      }\n\n      if (options !== undefined) {\n        bufferToTensorOptions = options;\n        if (options.tensorFormat !== undefined) {\n          throw new Error('Image input config format must be RGBA for HTMLImageElement');\n        } else {\n          bufferToTensorOptions.tensorFormat = 'RGBA';\n        }\n        bufferToTensorOptions.height = height;\n        bufferToTensorOptions.width = width;\n      } else {\n        bufferToTensorOptions.tensorFormat = 'RGBA';\n        bufferToTensorOptions.height = height;\n        bufferToTensorOptions.width = width;\n      }\n\n      pixels2DContext.drawImage(image, 0, 0);\n      data = pixels2DContext.getImageData(0, 0, width, height).data;\n    } else {\n      throw new Error('Can not access image data');\n    }\n  } else if (isImageDataEle) {\n    let height: number;\n    let width: number;\n\n    if (options !== undefined && options.resizedWidth !== undefined && options.resizedHeight !== undefined) {\n      height = options.resizedHeight;\n      width = options.resizedWidth;\n    } else {\n      height = image.height;\n      width = image.width;\n    }\n\n    if (options !== undefined) {\n      bufferToTensorOptions = options;\n    }\n    bufferToTensorOptions.format = 'RGBA';\n    bufferToTensorOptions.height = height;\n    bufferToTensorOptions.width = width;\n\n    if (options !== undefined) {\n      const tempCanvas = createCanvas();\n\n      tempCanvas.width = width;\n      tempCanvas.height = height;\n\n      const pixels2DContext = createCanvasContext(tempCanvas);\n\n      if (pixels2DContext != null) {\n        pixels2DContext.putImageData(image, 0, 0);\n        data = pixels2DContext.getImageData(0, 0, width, height).data;\n      } else {\n        throw new Error('Can not access image data');\n      }\n    } else {\n      data = image.data;\n    }\n  } else if (isImageBitmap) {\n    // ImageBitmap - image object - format must be provided by user\n    if (options === undefined) {\n      throw new Error('Please provide image config with format for Imagebitmap');\n    }\n\n    const canvas = createCanvas();\n    canvas.width = image.width;\n    canvas.height = image.height;\n    const pixels2DContext = createCanvasContext(canvas);\n\n    if (pixels2DContext != null) {\n      const height = image.height;\n      const width = image.width;\n      pixels2DContext.drawImage(image, 0, 0, width, height);\n      data = pixels2DContext.getImageData(0, 0, width, height).data;\n      bufferToTensorOptions.height = height;\n      bufferToTensorOptions.width = width;\n      return bufferToTensor(data, bufferToTensorOptions);\n    } else {\n      throw new Error('Can not access image data');\n    }\n  } else if (isString) {\n    return new Promise((resolve, reject) => {\n      const canvas = createCanvas();\n      const context = createCanvasContext(canvas);\n      if (!image || !context) {\n        return reject();\n      }\n      const newImage = new Image();\n      newImage.crossOrigin = 'Anonymous';\n      newImage.src = image;\n      newImage.onload = () => {\n        canvas.width = newImage.width;\n        canvas.height = newImage.height;\n        context.drawImage(newImage, 0, 0, canvas.width, canvas.height);\n        const img = context.getImageData(0, 0, canvas.width, canvas.height);\n\n        bufferToTensorOptions.height = canvas.height;\n        bufferToTensorOptions.width = canvas.width;\n        resolve(bufferToTensor(img.data, bufferToTensorOptions));\n      };\n    });\n  } else {\n    throw new Error('Input data provided is not supported - aborted tensor creation');\n  }\n\n  if (data !== undefined) {\n    return bufferToTensor(data, bufferToTensorOptions);\n  } else {\n    throw new Error('Input data provided is not supported - aborted tensor creation');\n  }\n};\n\n/**\n * implementation of Tensor.fromTexture().\n */\nexport const tensorFromTexture = <T extends TensorInterface.TextureDataTypes>(\n  texture: TensorInterface.TextureType,\n  options: TensorFromTextureOptions<T>,\n): Tensor => {\n  const { width, height, download, dispose } = options;\n  // Always assume RGBAF32. TODO: support different texture format\n  const dims = [1, height, width, 4];\n  return new Tensor({ location: 'texture', type: 'float32', texture, dims, download, dispose });\n};\n\n/**\n * implementation of Tensor.fromGpuBuffer().\n */\nexport const tensorFromGpuBuffer = <T extends TensorInterface.GpuBufferDataTypes>(\n  gpuBuffer: TensorInterface.GpuBufferType,\n  options: TensorFromGpuBufferOptions<T>,\n): Tensor => {\n  const { dataType, dims, download, dispose } = options;\n  return new Tensor({ location: 'gpu-buffer', type: dataType ?? 'float32', gpuBuffer, dims, download, dispose });\n};\n\n/**\n * implementation of Tensor.fromMLTensor().\n */\nexport const tensorFromMLTensor = <T extends TensorInterface.MLTensorDataTypes>(\n  mlTensor: TensorInterface.MLTensorType,\n  options: TensorFromMLTensorOptions<T>,\n): Tensor => {\n  const { dataType, dims, download, dispose } = options;\n  return new Tensor({ location: 'ml-tensor', type: dataType ?? 'float32', mlTensor, dims, download, dispose });\n};\n\n/**\n * implementation of Tensor.fromPinnedBuffer().\n */\nexport const tensorFromPinnedBuffer = <T extends TensorInterface.CpuPinnedDataTypes>(\n  type: T,\n  buffer: TensorInterface.DataTypeMap[T],\n  dims?: readonly number[],\n): Tensor => new Tensor({ location: 'cpu-pinned', type, data: buffer, dims: dims ?? [buffer.length] });\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Tensor } from './tensor.js';\n\nexport type SupportedTypedArrayConstructors =\n  | Float32ArrayConstructor\n  | Uint8ArrayConstructor\n  | Int8ArrayConstructor\n  | Uint16ArrayConstructor\n  | Int16ArrayConstructor\n  | Int32ArrayConstructor\n  | BigInt64ArrayConstructor\n  | Uint8ArrayConstructor\n  | Float64ArrayConstructor\n  | Uint32ArrayConstructor\n  | BigUint64ArrayConstructor;\nexport type SupportedTypedArray = InstanceType<SupportedTypedArrayConstructors>;\n\n// a runtime map that maps type string to TypedArray constructor. Should match Tensor.DataTypeMap.\nexport const NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP = new Map<string, SupportedTypedArrayConstructors>([\n  ['float32', Float32Array],\n  ['uint8', Uint8Array],\n  ['int8', Int8Array],\n  ['uint16', Uint16Array],\n  ['int16', Int16Array],\n  ['int32', Int32Array],\n  ['bool', Uint8Array],\n  ['float64', Float64Array],\n  ['uint32', Uint32Array],\n  ['int4', Uint8Array],\n  ['uint4', Uint8Array],\n]);\n\n// a runtime map that maps type string to TypedArray constructor. Should match Tensor.DataTypeMap.\nexport const NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP = new Map<SupportedTypedArrayConstructors, Tensor.Type>([\n  [Float32Array, 'float32'],\n  [Uint8Array, 'uint8'],\n  [Int8Array, 'int8'],\n  [Uint16Array, 'uint16'],\n  [Int16Array, 'int16'],\n  [Int32Array, 'int32'],\n  [Float64Array, 'float64'],\n  [Uint32Array, 'uint32'],\n]);\n\n// the following code allows delaying execution of BigInt/Float16Array checking. This allows lazy initialization for\n// NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP and NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP, which allows BigInt/Float16Array\n// polyfill if available.\nlet isTypedArrayChecked = false;\nexport const checkTypedArray = () => {\n  if (!isTypedArrayChecked) {\n    isTypedArrayChecked = true;\n    const isBigInt64ArrayAvailable = typeof BigInt64Array !== 'undefined' && BigInt64Array.from;\n    const isBigUint64ArrayAvailable = typeof BigUint64Array !== 'undefined' && BigUint64Array.from;\n\n    // eslint-disable-next-line @typescript-eslint/naming-convention, @typescript-eslint/no-explicit-any\n    const Float16Array = (globalThis as any).Float16Array;\n    const isFloat16ArrayAvailable = typeof Float16Array !== 'undefined' && Float16Array.from;\n\n    if (isBigInt64ArrayAvailable) {\n      NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set('int64', BigInt64Array);\n      NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.set(BigInt64Array, 'int64');\n    }\n    if (isBigUint64ArrayAvailable) {\n      NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set('uint64', BigUint64Array);\n      NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.set(BigUint64Array, 'uint64');\n    }\n    if (isFloat16ArrayAvailable) {\n      NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set('float16', Float16Array);\n      NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.set(Float16Array, 'float16');\n    } else {\n      // if Float16Array is not available, use 'Uint16Array' to store the data.\n      NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set('float16', Uint16Array);\n    }\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {\n  CpuPinnedConstructorParameters,\n  GpuBufferConstructorParameters,\n  MLTensorConstructorParameters,\n  TextureConstructorParameters,\n} from './tensor-factory.js';\nimport { Tensor } from './tensor-impl.js';\n\n/**\n * calculate size from dims.\n *\n * @param dims the dims array. May be an illegal input.\n */\nexport const calculateSize = (dims: readonly unknown[]): number => {\n  let size = 1;\n  for (let i = 0; i < dims.length; i++) {\n    const dim = dims[i];\n    if (typeof dim !== 'number' || !Number.isSafeInteger(dim)) {\n      throw new TypeError(`dims[${i}] must be an integer, got: ${dim}`);\n    }\n    if (dim < 0) {\n      throw new RangeError(`dims[${i}] must be a non-negative integer, got: ${dim}`);\n    }\n    size *= dim;\n  }\n  return size;\n};\n\n/**\n * implementation of Tensor.reshape()\n */\nexport const tensorReshape = (tensor: Tensor, dims: readonly number[]): Tensor => {\n  switch (tensor.location) {\n    case 'cpu':\n      return new Tensor(tensor.type, tensor.data, dims);\n    case 'cpu-pinned':\n      return new Tensor({\n        location: 'cpu-pinned',\n        data: tensor.data as CpuPinnedConstructorParameters['data'],\n        type: tensor.type as CpuPinnedConstructorParameters['type'],\n        dims,\n      });\n    case 'texture':\n      return new Tensor({\n        location: 'texture',\n        texture: tensor.texture,\n        type: tensor.type as TextureConstructorParameters['type'],\n        dims,\n      });\n    case 'gpu-buffer':\n      return new Tensor({\n        location: 'gpu-buffer',\n        gpuBuffer: tensor.gpuBuffer,\n        type: tensor.type as GpuBufferConstructorParameters['type'],\n        dims,\n      });\n    case 'ml-tensor':\n      return new Tensor({\n        location: 'ml-tensor',\n        mlTensor: tensor.mlTensor,\n        type: tensor.type as MLTensorConstructorParameters['type'],\n        dims,\n      });\n    default:\n      throw new Error(`tensorReshape: tensor location ${tensor.location} is not supported`);\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { tensorToDataURL, tensorToImageData } from './tensor-conversion-impl.js';\nimport { TensorToDataUrlOptions, TensorToImageDataOptions } from './tensor-conversion.js';\nimport {\n  tensorFromGpuBuffer,\n  tensorFromImage,\n  tensorFromMLTensor,\n  tensorFromPinnedBuffer,\n  tensorFromTexture,\n} from './tensor-factory-impl.js';\nimport {\n  CpuPinnedConstructorParameters,\n  GpuBufferConstructorParameters,\n  MLTensorConstructorParameters,\n  TensorFromGpuBufferOptions,\n  TensorFromImageBitmapOptions,\n  TensorFromImageDataOptions,\n  TensorFromImageElementOptions,\n  TensorFromMLTensorOptions,\n  TensorFromTextureOptions,\n  TensorFromUrlOptions,\n  TextureConstructorParameters,\n} from './tensor-factory.js';\nimport {\n  checkTypedArray,\n  NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP,\n  NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP,\n  SupportedTypedArray,\n  SupportedTypedArrayConstructors,\n} from './tensor-impl-type-mapping.js';\nimport { calculateSize, tensorReshape } from './tensor-utils-impl.js';\nimport { Tensor as TensorInterface } from './tensor.js';\n\n// type aliases for those exported from Tensor interface\n\ntype TensorType = TensorInterface.Type;\ntype TensorDataType = TensorInterface.DataType;\ntype TensorDataLocation = TensorInterface.DataLocation;\ntype TensorTextureType = TensorInterface.TextureType;\ntype TensorGpuBufferType = TensorInterface.GpuBufferType;\ntype TensorMLTensorType = TensorInterface.MLTensorType;\n\n/**\n * the implementation of Tensor interface.\n *\n * @ignore\n */\nexport class Tensor implements TensorInterface {\n  // #region constructors\n\n  /**\n   * Construct a new CPU tensor object from the given type, data and dims.\n   */\n  constructor(\n    type: TensorType,\n    data: TensorDataType | Uint8ClampedArray | readonly string[] | readonly number[] | readonly boolean[],\n    dims?: readonly number[],\n  );\n  /**\n   * Construct a new CPU tensor object from the given data and dims. Type is inferred from data.\n   */\n  constructor(\n    data: TensorDataType | Uint8ClampedArray | readonly string[] | readonly boolean[],\n    dims?: readonly number[],\n  );\n  /**\n   * Construct a new tensor object from the pinned CPU data with the given type and dims.\n   *\n   * Tensor's location will be set to 'cpu-pinned'.\n   *\n   * @param params - Specify the parameters to construct the tensor.\n   */\n  constructor(params: CpuPinnedConstructorParameters);\n  /**\n   * Construct a new tensor object from the WebGL texture with the given type and dims.\n   *\n   * Tensor's location will be set to 'texture'.\n   *\n   * @param params - Specify the parameters to construct the tensor.\n   */\n  constructor(params: TextureConstructorParameters);\n  /**\n   * Construct a new tensor object from the WebGPU buffer with the given type and dims.\n   *\n   * Tensor's location will be set to 'gpu-buffer'.\n   *\n   * @param params - Specify the parameters to construct the tensor.\n   */\n  constructor(params: GpuBufferConstructorParameters);\n\n  /**\n   * Construct a new tensor object from the WebNN MLTensor with the given type and dims.\n   *\n   * Tensor's location will be set to 'ml-tensor'.\n   *\n   * @param params - Specify the parameters to construct the tensor.\n   */\n  constructor(params: MLTensorConstructorParameters);\n\n  /**\n   * implementation.\n   */\n  constructor(\n    arg0:\n      | TensorType\n      | TensorDataType\n      | Uint8ClampedArray\n      | readonly string[]\n      | readonly boolean[]\n      | CpuPinnedConstructorParameters\n      | TextureConstructorParameters\n      | GpuBufferConstructorParameters\n      | MLTensorConstructorParameters,\n    arg1?: TensorDataType | Uint8ClampedArray | readonly number[] | readonly string[] | readonly boolean[],\n    arg2?: readonly number[],\n  ) {\n    // perform one-time check for BigInt/Float16Array support\n    checkTypedArray();\n\n    let type: TensorType;\n    let dims: readonly number[];\n\n    if (typeof arg0 === 'object' && 'location' in arg0) {\n      //\n      // constructing tensor from specific location\n      //\n      this.dataLocation = arg0.location;\n      type = arg0.type;\n      dims = arg0.dims;\n      switch (arg0.location) {\n        case 'cpu-pinned': {\n          const expectedTypedArrayConstructor = NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.get(type);\n          if (!expectedTypedArrayConstructor) {\n            throw new TypeError(`unsupported type \"${type}\" to create tensor from pinned buffer`);\n          }\n          if (!(arg0.data instanceof expectedTypedArrayConstructor)) {\n            throw new TypeError(`buffer should be of type ${expectedTypedArrayConstructor.name}`);\n          }\n          this.cpuData = arg0.data;\n          break;\n        }\n        case 'texture': {\n          if (type !== 'float32') {\n            throw new TypeError(`unsupported type \"${type}\" to create tensor from texture`);\n          }\n          this.gpuTextureData = arg0.texture;\n          this.downloader = arg0.download;\n          this.disposer = arg0.dispose;\n          break;\n        }\n        case 'gpu-buffer': {\n          if (\n            type !== 'float32' &&\n            type !== 'float16' &&\n            type !== 'int32' &&\n            type !== 'int64' &&\n            type !== 'uint32' &&\n            type !== 'uint8' &&\n            type !== 'bool' &&\n            type !== 'uint4' &&\n            type !== 'int4'\n          ) {\n            throw new TypeError(`unsupported type \"${type}\" to create tensor from gpu buffer`);\n          }\n          this.gpuBufferData = arg0.gpuBuffer;\n          this.downloader = arg0.download;\n          this.disposer = arg0.dispose;\n          break;\n        }\n        case 'ml-tensor': {\n          if (\n            type !== 'float32' &&\n            type !== 'float16' &&\n            type !== 'int32' &&\n            type !== 'int64' &&\n            type !== 'uint32' &&\n            type !== 'uint64' &&\n            type !== 'int8' &&\n            type !== 'uint8' &&\n            type !== 'bool' &&\n            type !== 'uint4' &&\n            type !== 'int4'\n          ) {\n            throw new TypeError(`unsupported type \"${type}\" to create tensor from MLTensor`);\n          }\n          this.mlTensorData = arg0.mlTensor;\n          this.downloader = arg0.download;\n          this.disposer = arg0.dispose;\n          break;\n        }\n        default:\n          throw new Error(`Tensor constructor: unsupported location '${this.dataLocation}'`);\n      }\n    } else {\n      //\n      // constructing tensor of location 'cpu'\n      //\n      let data: TensorDataType;\n      let maybeDims: typeof arg1 | typeof arg2;\n      // check whether arg0 is type or data\n      if (typeof arg0 === 'string') {\n        //\n        // Override: constructor(type, data, ...)\n        //\n        type = arg0;\n        maybeDims = arg2;\n        if (arg0 === 'string') {\n          // string tensor\n          if (!Array.isArray(arg1)) {\n            throw new TypeError(\"A string tensor's data must be a string array.\");\n          }\n          // we don't check whether every element in the array is string; this is too slow. we assume it's correct and\n          // error will be populated at inference\n          data = arg1;\n        } else {\n          // numeric tensor\n          const typedArrayConstructor = NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.get(arg0);\n          if (typedArrayConstructor === undefined) {\n            throw new TypeError(`Unsupported tensor type: ${arg0}.`);\n          }\n          if (Array.isArray(arg1)) {\n            if ((arg0 === 'float16' && typedArrayConstructor === Uint16Array) || arg0 === 'uint4' || arg0 === 'int4') {\n              // - 'float16':\n              //   When no Float16Array polyfill is used, we cannot create 'float16' tensor from number array.\n              //\n              //   Throw error here because when user try to use number array as data,\n              //   e.g. new Tensor('float16', [1, 2, 3, 4], dims)), it will actually call\n              //   Uint16Array.from(arg1) which generates wrong data.\n              //\n              // - 'uint4' and 'int4':\n              //   Uint8Array.from(arg1) will generate wrong data for 'uint4' and 'int4' tensor.\n              //\n              throw new TypeError(\n                `Creating a ${arg0} tensor from number array is not supported. Please use ${typedArrayConstructor.name} as data.`,\n              );\n            } else if (arg0 === 'uint64' || arg0 === 'int64') {\n              // use 'as any' here because:\n              // 1. TypeScript's check on type of 'Array.isArray()' does not work with readonly arrays.\n              // see https://github.com/microsoft/TypeScript/issues/17002\n              // 2. TypeScript's check on union type of '(BigInt64ArrayConstructor|BigUint64ArrayConstructor).from()'\n              // does not accept parameter mapFn.\n              // 3. parameters of 'SupportedTypedArrayConstructors.from()' does not match the requirement of the union\n              // type.\n\n              // assume 'arg1' is of type \"readonly number[]|readonly bigint[]\" here.\n\n              // eslint-disable-next-line @typescript-eslint/no-explicit-any\n              data = (typedArrayConstructor as any).from(arg1, BigInt);\n            } else {\n              // assume 'arg1' is of type \"readonly number[]\" here.\n              // eslint-disable-next-line @typescript-eslint/no-explicit-any\n              data = (typedArrayConstructor as any).from(arg1);\n            }\n          } else if (arg1 instanceof typedArrayConstructor) {\n            data = arg1;\n          } else if (arg1 instanceof Uint8ClampedArray) {\n            if (arg0 === 'uint8') {\n              data = Uint8Array.from(arg1);\n            } else {\n              throw new TypeError(`A Uint8ClampedArray tensor's data must be type of uint8`);\n            }\n          } else if (arg0 === 'float16' && arg1 instanceof Uint16Array && typedArrayConstructor !== Uint16Array) {\n            // when Float16Array is available and data is of type Uint16Array.\n            // We allow Uint16Array to be passed in as data for 'float16' tensor until Float16Array is generally\n            // supported in JavaScript environment.\n\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            data = new (globalThis as any).Float16Array(arg1.buffer, arg1.byteOffset, arg1.length);\n          } else {\n            throw new TypeError(`A ${type} tensor's data must be type of ${typedArrayConstructor}`);\n          }\n        }\n      } else {\n        //\n        // Override: constructor(data, ...)\n        //\n        maybeDims = arg1;\n        if (Array.isArray(arg0)) {\n          // only boolean[] and string[] is supported\n          if (arg0.length === 0) {\n            throw new TypeError('Tensor type cannot be inferred from an empty array.');\n          }\n          const firstElementType = typeof arg0[0];\n          if (firstElementType === 'string') {\n            type = 'string';\n            data = arg0;\n          } else if (firstElementType === 'boolean') {\n            type = 'bool';\n            // 'arg0' is of type 'boolean[]'. Uint8Array.from(boolean[]) actually works, but typescript thinks this is\n            // wrong type. We use 'as any' to make it happy.\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            data = Uint8Array.from(arg0 as any[]);\n          } else {\n            throw new TypeError(`Invalid element type of data array: ${firstElementType}.`);\n          }\n        } else if (arg0 instanceof Uint8ClampedArray) {\n          type = 'uint8';\n          data = Uint8Array.from(arg0);\n        } else {\n          // get tensor type from TypedArray\n          const mappedType = NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.get(\n            arg0.constructor as SupportedTypedArrayConstructors,\n          );\n          if (mappedType === undefined) {\n            throw new TypeError(`Unsupported type for tensor data: ${arg0.constructor}.`);\n          }\n          type = mappedType;\n          data = arg0 as SupportedTypedArray;\n        }\n      }\n\n      // type and data is processed, now processing dims\n      if (maybeDims === undefined) {\n        // assume 1-D tensor if dims omitted\n        maybeDims = [data.length];\n      } else if (!Array.isArray(maybeDims)) {\n        throw new TypeError(\"A tensor's dims must be a number array\");\n      }\n      dims = maybeDims as readonly number[];\n\n      this.cpuData = data;\n      this.dataLocation = 'cpu';\n    }\n\n    // perform check on dims\n    const size = calculateSize(dims);\n    // if data is on CPU, check whether data length matches tensor size\n    if (this.cpuData && size !== this.cpuData.length) {\n      if ((type === 'uint4' || type === 'int4') && Math.ceil(size / 2) === this.cpuData.length) {\n        // for (u)int4, the data length is half of the tensor size. So we check this special case when size is odd.\n      } else {\n        throw new Error(`Tensor's size(${size}) does not match data length(${this.cpuData.length}).`);\n      }\n    }\n\n    this.type = type;\n    this.dims = dims;\n    this.size = size;\n  }\n  // #endregion\n\n  // #region factory\n  static async fromImage(\n    image: ImageData | HTMLImageElement | ImageBitmap | string,\n    options?:\n      | TensorFromImageDataOptions\n      | TensorFromImageElementOptions\n      | TensorFromImageBitmapOptions\n      | TensorFromUrlOptions,\n  ): Promise<TensorInterface> {\n    return tensorFromImage(image, options);\n  }\n\n  static fromTexture<T extends TensorInterface.TextureDataTypes>(\n    texture: TensorTextureType,\n    options: TensorFromTextureOptions<T>,\n  ): TensorInterface {\n    return tensorFromTexture(texture, options);\n  }\n\n  static fromGpuBuffer<T extends TensorInterface.GpuBufferDataTypes>(\n    gpuBuffer: TensorGpuBufferType,\n    options: TensorFromGpuBufferOptions<T>,\n  ): TensorInterface {\n    return tensorFromGpuBuffer(gpuBuffer, options);\n  }\n\n  static fromMLTensor<T extends TensorInterface.MLTensorDataTypes>(\n    mlTensor: TensorMLTensorType,\n    options: TensorFromMLTensorOptions<T>,\n  ): TensorInterface {\n    return tensorFromMLTensor(mlTensor, options);\n  }\n\n  static fromPinnedBuffer<T extends TensorInterface.CpuPinnedDataTypes>(\n    type: T,\n    buffer: TensorInterface.DataTypeMap[T],\n    dims?: readonly number[],\n  ): Tensor {\n    return tensorFromPinnedBuffer(type, buffer, dims);\n  }\n\n  // #endregion\n\n  // #region conversions\n  toDataURL(options?: TensorToDataUrlOptions): string {\n    return tensorToDataURL(this, options);\n  }\n\n  toImageData(options?: TensorToImageDataOptions): ImageData {\n    return tensorToImageData(this, options);\n  }\n  // #endregion\n\n  // #region public fields\n  readonly dims: readonly number[];\n  readonly type: TensorType;\n  readonly size: number;\n  // #endregion\n\n  // #region private fields\n\n  /**\n   * stores the location of the data.\n   */\n  private dataLocation: TensorDataLocation;\n\n  /**\n   * stores the data on CPU, if location is 'cpu' or 'cpu-pinned'. otherwise empty.\n   */\n  private cpuData?: TensorDataType;\n\n  /**\n   * stores the underlying texture when location is 'texture'. otherwise empty.\n   */\n  private gpuTextureData?: TensorTextureType;\n\n  /**\n   * stores the underlying GPU buffer when location is 'gpu-buffer'. otherwise empty.\n   */\n  private gpuBufferData?: TensorGpuBufferType;\n\n  /**\n   * stores the underlying WebNN MLTensor when location is 'ml-tensor'. otherwise empty.\n   */\n  private mlTensorData?: TensorMLTensorType;\n\n  /**\n   * stores an optional downloader function to download data from GPU to CPU.\n   */\n  private downloader?(): Promise<TensorDataType>;\n\n  /**\n   * a flag indicating whether the data is being downloaded from GPU to CPU.\n   */\n  private isDownloading?: boolean;\n\n  /**\n   * stores an optional disposer function to dispose the underlying data.\n   */\n  private disposer?(): void;\n  // #endregion\n\n  // #region properties\n  get data(): TensorDataType {\n    this.ensureValid();\n    if (!this.cpuData) {\n      throw new Error(\n        'The data is not on CPU. Use `getData()` to download GPU data to CPU, ' +\n          'or use `texture` or `gpuBuffer` property to access the GPU data directly.',\n      );\n    }\n    return this.cpuData;\n  }\n\n  get location(): TensorDataLocation {\n    return this.dataLocation;\n  }\n\n  get texture(): TensorTextureType {\n    this.ensureValid();\n    if (!this.gpuTextureData) {\n      throw new Error('The data is not stored as a WebGL texture.');\n    }\n    return this.gpuTextureData;\n  }\n\n  get gpuBuffer(): TensorGpuBufferType {\n    this.ensureValid();\n    if (!this.gpuBufferData) {\n      throw new Error('The data is not stored as a WebGPU buffer.');\n    }\n    return this.gpuBufferData;\n  }\n\n  get mlTensor(): TensorMLTensorType {\n    this.ensureValid();\n    if (!this.mlTensorData) {\n      throw new Error('The data is not stored as a WebNN MLTensor.');\n    }\n    return this.mlTensorData;\n  }\n  // #endregion\n\n  // #region methods\n\n  async getData(releaseData?: boolean): Promise<TensorDataType> {\n    this.ensureValid();\n    switch (this.dataLocation) {\n      case 'cpu':\n      case 'cpu-pinned':\n        return this.data;\n      case 'texture':\n      case 'gpu-buffer':\n      case 'ml-tensor': {\n        if (!this.downloader) {\n          throw new Error('The current tensor is not created with a specified data downloader.');\n        }\n        if (this.isDownloading) {\n          throw new Error('The current tensor is being downloaded.');\n        }\n        try {\n          this.isDownloading = true;\n          const data = await this.downloader();\n          this.downloader = undefined;\n          this.dataLocation = 'cpu';\n          this.cpuData = data;\n\n          if (releaseData && this.disposer) {\n            this.disposer();\n            this.disposer = undefined;\n          }\n\n          return data;\n        } finally {\n          this.isDownloading = false;\n        }\n      }\n      default:\n        throw new Error(`cannot get data from location: ${this.dataLocation}`);\n    }\n  }\n\n  dispose(): void {\n    if (this.isDownloading) {\n      throw new Error('The current tensor is being downloaded.');\n    }\n\n    if (this.disposer) {\n      this.disposer();\n      this.disposer = undefined;\n    }\n    this.cpuData = undefined;\n    this.gpuTextureData = undefined;\n    this.gpuBufferData = undefined;\n    this.mlTensorData = undefined;\n    this.downloader = undefined;\n    this.isDownloading = undefined;\n\n    this.dataLocation = 'none';\n  }\n\n  // #endregion\n\n  // #region tensor utilities\n  private ensureValid(): void {\n    if (this.dataLocation === 'none') {\n      throw new Error('The tensor is disposed.');\n    }\n  }\n\n  reshape(dims: readonly number[]): TensorInterface {\n    this.ensureValid();\n    if (this.downloader || this.disposer) {\n      throw new Error('Cannot reshape a tensor that owns GPU resource.');\n    }\n    return tensorReshape(this, dims);\n  }\n  // #endregion\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { TensorFactory } from './tensor-factory.js';\nimport { Tensor as TensorImpl } from './tensor-impl.js';\nimport { TypedTensorUtils } from './tensor-utils.js';\nimport { TryGetGlobalType } from './type-helper.js';\n\n/* eslint-disable @typescript-eslint/no-redeclare */\n\n/**\n * represent a basic tensor with specified dimensions and data type.\n */\ninterface TypedTensorBase<T extends Tensor.Type> {\n  /**\n   * Get the dimensions of the tensor.\n   */\n  readonly dims: readonly number[];\n  /**\n   * Get the data type of the tensor.\n   */\n  readonly type: T;\n  /**\n   * Get the buffer data of the tensor.\n   *\n   * If the data is not on CPU (eg. it's in the form of WebGL texture or WebGPU buffer), throw error.\n   */\n  readonly data: Tensor.DataTypeMap[T];\n  /**\n   * Get the location of the data.\n   */\n  readonly location: Tensor.DataLocation;\n  /**\n   * Get the WebGL texture that holds the tensor data.\n   *\n   * If the data is not on GPU as WebGL texture, throw error.\n   */\n  readonly texture: Tensor.TextureType;\n  /**\n   * Get the WebGPU buffer that holds the tensor data.\n   *\n   * If the data is not on GPU as WebGPU buffer, throw error.\n   */\n  readonly gpuBuffer: Tensor.GpuBufferType;\n\n  /**\n   * Get the WebNN MLTensor that holds the tensor data.\n   *\n   * If the data is not in a WebNN MLTensor, throw error.\n   */\n  readonly mlTensor: Tensor.MLTensorType;\n\n  /**\n   * Get the buffer data of the tensor.\n   *\n   * If the data is on CPU, returns the data immediately.\n   * If the data is on GPU, downloads the data and returns the promise.\n   *\n   * @param releaseData - whether release the data on GPU. Ignore if data is already on CPU.\n   */\n  getData(releaseData?: boolean): Promise<Tensor.DataTypeMap[T]>;\n\n  /**\n   * Dispose the tensor data.\n   *\n   * If the data is on CPU, remove its internal reference to the underlying data.\n   * If the data is on GPU, release the data on GPU.\n   *\n   * After calling this function, the tensor is considered no longer valid. Its location will be set to 'none'.\n   */\n  dispose(): void;\n}\n\nexport declare namespace Tensor {\n  interface DataTypeMap {\n    float32: Float32Array;\n    uint8: Uint8Array;\n    int8: Int8Array;\n    uint16: Uint16Array;\n    int16: Int16Array;\n    int32: Int32Array;\n    int64: BigInt64Array;\n    string: string[];\n    bool: Uint8Array;\n    float16: Uint16Array; // Keep using Uint16Array until we have a concrete solution for float 16.\n    float64: Float64Array;\n    uint32: Uint32Array;\n    uint64: BigUint64Array;\n    // complex64: never;\n    // complex128: never;\n    // bfloat16: never;\n    uint4: Uint8Array;\n    int4: Int8Array;\n  }\n\n  interface ElementTypeMap {\n    float32: number;\n    uint8: number;\n    int8: number;\n    uint16: number;\n    int16: number;\n    int32: number;\n    int64: bigint;\n    string: string;\n    bool: boolean;\n    float16: number; // Keep using Uint16Array until we have a concrete solution for float 16.\n    float64: number;\n    uint32: number;\n    uint64: bigint;\n    // complex64: never;\n    // complex128: never;\n    // bfloat16: never;\n    uint4: number;\n    int4: number;\n  }\n\n  type DataType = DataTypeMap[Type];\n  type ElementType = ElementTypeMap[Type];\n\n  /**\n   * supported data types for constructing a tensor from a pinned CPU buffer\n   */\n  export type CpuPinnedDataTypes = Exclude<Tensor.Type, 'string'>;\n\n  /**\n   * type alias for WebGL texture\n   */\n  export type TextureType = WebGLTexture;\n\n  /**\n   * supported data types for constructing a tensor from a WebGL texture\n   */\n  export type TextureDataTypes = 'float32';\n\n  type GpuBufferTypeFallback = { size: number; mapState: 'unmapped' | 'pending' | 'mapped' };\n  /**\n   * type alias for WebGPU buffer\n   */\n  export type GpuBufferType = TryGetGlobalType<'GPUBuffer', GpuBufferTypeFallback>;\n\n  type MLTensorTypeFallback = { destroy(): void };\n  /**\n   * type alias for WebNN MLTensor\n   *\n   * The specification for WebNN's MLTensor is currently in flux.\n   */\n  export type MLTensorType = TryGetGlobalType<'MLTensor', MLTensorTypeFallback>;\n\n  /**\n   * supported data types for constructing a tensor from a WebGPU buffer\n   */\n  export type GpuBufferDataTypes = 'float32' | 'float16' | 'int32' | 'int64' | 'uint32' | 'uint8' | 'bool';\n\n  /**\n   * supported data types for constructing a tensor from a WebNN MLTensor\n   */\n  export type MLTensorDataTypes =\n    | 'float32'\n    | 'float16'\n    | 'int8'\n    | 'uint8'\n    | 'int32'\n    | 'uint32'\n    | 'int64'\n    | 'uint64'\n    | 'bool'\n    | 'uint4'\n    | 'int4';\n\n  /**\n   * represent where the tensor data is stored\n   */\n  export type DataLocation = 'none' | 'cpu' | 'cpu-pinned' | 'texture' | 'gpu-buffer' | 'ml-tensor';\n\n  /**\n   * represent the data type of a tensor\n   */\n  export type Type = keyof DataTypeMap;\n}\n\n/**\n * Represent multi-dimensional arrays to feed to or fetch from model inferencing.\n */\nexport interface TypedTensor<T extends Tensor.Type> extends TypedTensorBase<T>, TypedTensorUtils<T> {}\n/**\n * Represent multi-dimensional arrays to feed to or fetch from model inferencing.\n */\nexport interface Tensor extends TypedTensorBase<Tensor.Type>, TypedTensorUtils<Tensor.Type> {}\n\n/**\n * type TensorConstructor defines the constructors of 'Tensor' to create CPU tensor instances.\n */\nexport interface TensorConstructor extends TensorFactory {\n  // #region CPU tensor - specify element type\n  /**\n   * Construct a new string tensor object from the given type, data and dims.\n   *\n   * @param type - Specify the element type.\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (\n    type: 'string',\n    data: Tensor.DataTypeMap['string'] | readonly string[],\n    dims?: readonly number[],\n  ): TypedTensor<'string'>;\n\n  /**\n   * Construct a new bool tensor object from the given type, data and dims.\n   *\n   * @param type - Specify the element type.\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (\n    type: 'bool',\n    data: Tensor.DataTypeMap['bool'] | readonly boolean[],\n    dims?: readonly number[],\n  ): TypedTensor<'bool'>;\n\n  /**\n   * Construct a new uint8 tensor object from a Uint8ClampedArray, data and dims.\n   *\n   * @param type - Specify the element type.\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (type: 'uint8', data: Uint8ClampedArray, dims?: readonly number[]): TypedTensor<'uint8'>;\n\n  /**\n   * Construct a new 64-bit integer typed tensor object from the given type, data and dims.\n   *\n   * @param type - Specify the element type.\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new <T extends 'uint64' | 'int64'>(\n    type: T,\n    data: Tensor.DataTypeMap[T] | readonly bigint[] | readonly number[],\n    dims?: readonly number[],\n  ): TypedTensor<T>;\n\n  /**\n   * Construct a new numeric tensor object from the given type, data and dims.\n   *\n   * @param type - Specify the element type.\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new <T extends Exclude<Tensor.Type, 'string' | 'bool' | 'uint64' | 'int64'>>(\n    type: T,\n    data: Tensor.DataTypeMap[T] | readonly number[],\n    dims?: readonly number[],\n  ): TypedTensor<T>;\n  // #endregion\n\n  // #region CPU tensor - infer element types\n\n  /**\n   * Construct a new float32 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (data: Float32Array, dims?: readonly number[]): TypedTensor<'float32'>;\n\n  /**\n   * Construct a new int8 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (data: Int8Array, dims?: readonly number[]): TypedTensor<'int8'>;\n\n  /**\n   * Construct a new uint8 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (data: Uint8Array, dims?: readonly number[]): TypedTensor<'uint8'>;\n\n  /**\n   * Construct a new uint8 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (data: Uint8ClampedArray, dims?: readonly number[]): TypedTensor<'uint8'>;\n\n  /**\n   * Construct a new uint16 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (data: Uint16Array, dims?: readonly number[]): TypedTensor<'uint16'>;\n\n  /**\n   * Construct a new int16 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (data: Int16Array, dims?: readonly number[]): TypedTensor<'int16'>;\n\n  /**\n   * Construct a new int32 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (data: Int32Array, dims?: readonly number[]): TypedTensor<'int32'>;\n\n  /**\n   * Construct a new int64 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (data: BigInt64Array, dims?: readonly number[]): TypedTensor<'int64'>;\n\n  /**\n   * Construct a new string tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (data: readonly string[], dims?: readonly number[]): TypedTensor<'string'>;\n\n  /**\n   * Construct a new bool tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (data: readonly boolean[], dims?: readonly number[]): TypedTensor<'bool'>;\n\n  /**\n   * Construct a new float64 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (data: Float64Array, dims?: readonly number[]): TypedTensor<'float64'>;\n\n  /**\n   * Construct a new uint32 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (data: Uint32Array, dims?: readonly number[]): TypedTensor<'uint32'>;\n\n  /**\n   * Construct a new uint64 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (data: BigUint64Array, dims?: readonly number[]): TypedTensor<'uint64'>;\n\n  // #endregion\n\n  // #region CPU tensor - fall back to non-generic tensor type declaration\n\n  /**\n   * Construct a new tensor object from the given type, data and dims.\n   *\n   * @param type - Specify the element type.\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (\n    type: Tensor.Type,\n    data: Tensor.DataType | readonly number[] | readonly string[] | readonly bigint[] | readonly boolean[],\n    dims?: readonly number[],\n  ): Tensor;\n\n  /**\n   * Construct a new tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (data: Tensor.DataType, dims?: readonly number[]): Tensor;\n  // #endregion\n}\n\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const Tensor = TensorImpl as TensorConstructor;\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { env } from './env-impl.js';\n\n/**\n * @ignore\n */\nexport const TRACE = (deviceType: string, label: string) => {\n  if (typeof env.trace === 'undefined' ? !env.wasm.trace : !env.trace) {\n    return;\n  }\n  // eslint-disable-next-line no-console\n  console.timeStamp(`${deviceType}::ORT::${label}`);\n};\n\nconst TRACE_FUNC = (msg: string, extraMsg?: string) => {\n  const stack = new Error().stack?.split(/\\r\\n|\\r|\\n/g) || [];\n  let hasTraceFunc = false;\n  for (let i = 0; i < stack.length; i++) {\n    if (hasTraceFunc && !stack[i].includes('TRACE_FUNC')) {\n      let label = `FUNC_${msg}::${stack[i].trim().split(' ')[1]}`;\n      if (extraMsg) {\n        label += `::${extraMsg}`;\n      }\n      TRACE('CPU', label);\n      return;\n    }\n    if (stack[i].includes('TRACE_FUNC')) {\n      hasTraceFunc = true;\n    }\n  }\n};\n\n/**\n * @ignore\n */\nexport const TRACE_FUNC_BEGIN = (extraMsg?: string) => {\n  if (typeof env.trace === 'undefined' ? !env.wasm.trace : !env.trace) {\n    return;\n  }\n  TRACE_FUNC('BEGIN', extraMsg);\n};\n\n/**\n * @ignore\n */\nexport const TRACE_FUNC_END = (extraMsg?: string) => {\n  if (typeof env.trace === 'undefined' ? !env.wasm.trace : !env.trace) {\n    return;\n  }\n  TRACE_FUNC('END', extraMsg);\n};\n\n/**\n * @ignore\n */\nexport const TRACE_EVENT_BEGIN = (extraMsg?: string) => {\n  if (typeof env.trace === 'undefined' ? !env.wasm.trace : !env.trace) {\n    return;\n  }\n  // eslint-disable-next-line no-console\n  console.time(`ORT::${extraMsg}`);\n};\n\n/**\n * @ignore\n */\nexport const TRACE_EVENT_END = (extraMsg?: string) => {\n  if (typeof env.trace === 'undefined' ? !env.wasm.trace : !env.trace) {\n    return;\n  }\n  // eslint-disable-next-line no-console\n  console.timeEnd(`ORT::${extraMsg}`);\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { resolveBackendAndExecutionProviders } from './backend-impl.js';\nimport { InferenceSessionHandler } from './backend.js';\nimport { InferenceSession as InferenceSessionInterface } from './inference-session.js';\nimport { OnnxValue } from './onnx-value.js';\nimport { Tensor } from './tensor.js';\nimport { TRACE_FUNC_BEGIN, TRACE_FUNC_END, TRACE_EVENT_BEGIN, TRACE_EVENT_END } from './trace.js';\n\ntype SessionOptions = InferenceSessionInterface.SessionOptions;\ntype RunOptions = InferenceSessionInterface.RunOptions;\ntype FeedsType = InferenceSessionInterface.FeedsType;\ntype FetchesType = InferenceSessionInterface.FetchesType;\ntype ReturnType = InferenceSessionInterface.ReturnType;\n\nexport class InferenceSession implements InferenceSessionInterface {\n  private constructor(handler: InferenceSessionHandler) {\n    this.handler = handler;\n  }\n  run(feeds: FeedsType, options?: RunOptions): Promise<ReturnType>;\n  run(feeds: FeedsType, fetches: FetchesType, options?: RunOptions): Promise<ReturnType>;\n  async run(feeds: FeedsType, arg1?: FetchesType | RunOptions, arg2?: RunOptions): Promise<ReturnType> {\n    TRACE_FUNC_BEGIN();\n    TRACE_EVENT_BEGIN('InferenceSession.run');\n    const fetches: { [name: string]: OnnxValue | null } = {};\n    let options: RunOptions = {};\n    // check inputs\n    if (typeof feeds !== 'object' || feeds === null || feeds instanceof Tensor || Array.isArray(feeds)) {\n      throw new TypeError(\n        \"'feeds' must be an object that use input names as keys and OnnxValue as corresponding values.\",\n      );\n    }\n\n    let isFetchesEmpty = true;\n    // determine which override is being used\n    if (typeof arg1 === 'object') {\n      if (arg1 === null) {\n        throw new TypeError('Unexpected argument[1]: cannot be null.');\n      }\n      if (arg1 instanceof Tensor) {\n        throw new TypeError(\"'fetches' cannot be a Tensor\");\n      }\n\n      if (Array.isArray(arg1)) {\n        if (arg1.length === 0) {\n          throw new TypeError(\"'fetches' cannot be an empty array.\");\n        }\n        isFetchesEmpty = false;\n        // output names\n        for (const name of arg1) {\n          if (typeof name !== 'string') {\n            throw new TypeError(\"'fetches' must be a string array or an object.\");\n          }\n          if (this.outputNames.indexOf(name) === -1) {\n            throw new RangeError(`'fetches' contains invalid output name: ${name}.`);\n          }\n          fetches[name] = null;\n        }\n\n        if (typeof arg2 === 'object' && arg2 !== null) {\n          options = arg2;\n        } else if (typeof arg2 !== 'undefined') {\n          throw new TypeError(\"'options' must be an object.\");\n        }\n      } else {\n        // decide whether arg1 is fetches or options\n        // if any output name is present and its value is valid OnnxValue, we consider it fetches\n        let isFetches = false;\n        const arg1Keys = Object.getOwnPropertyNames(arg1);\n        for (const name of this.outputNames) {\n          if (arg1Keys.indexOf(name) !== -1) {\n            const v = (arg1 as InferenceSessionInterface.NullableOnnxValueMapType)[name];\n            if (v === null || v instanceof Tensor) {\n              isFetches = true;\n              isFetchesEmpty = false;\n              fetches[name] = v;\n            }\n          }\n        }\n\n        if (isFetches) {\n          if (typeof arg2 === 'object' && arg2 !== null) {\n            options = arg2;\n          } else if (typeof arg2 !== 'undefined') {\n            throw new TypeError(\"'options' must be an object.\");\n          }\n        } else {\n          options = arg1 as RunOptions;\n        }\n      }\n    } else if (typeof arg1 !== 'undefined') {\n      throw new TypeError(\"Unexpected argument[1]: must be 'fetches' or 'options'.\");\n    }\n\n    // check if all inputs are in feed\n    for (const name of this.inputNames) {\n      if (typeof feeds[name] === 'undefined') {\n        throw new Error(`input '${name}' is missing in 'feeds'.`);\n      }\n    }\n\n    // if no fetches is specified, we use the full output names list\n    if (isFetchesEmpty) {\n      for (const name of this.outputNames) {\n        fetches[name] = null;\n      }\n    }\n\n    // feeds, fetches and options are prepared\n\n    const results = await this.handler.run(feeds, fetches, options);\n    const returnValue: { [name: string]: OnnxValue } = {};\n    for (const key in results) {\n      if (Object.hasOwnProperty.call(results, key)) {\n        const result = results[key];\n        if (result instanceof Tensor) {\n          returnValue[key] = result;\n        } else {\n          returnValue[key] = new Tensor(result.type, result.data, result.dims);\n        }\n      }\n    }\n    TRACE_EVENT_END('InferenceSession.run');\n    TRACE_FUNC_END();\n    return returnValue;\n  }\n\n  async release(): Promise<void> {\n    return this.handler.dispose();\n  }\n\n  static create(path: string, options?: SessionOptions): Promise<InferenceSessionInterface>;\n  static create(buffer: ArrayBufferLike, options?: SessionOptions): Promise<InferenceSessionInterface>;\n  static create(\n    buffer: ArrayBufferLike,\n    byteOffset: number,\n    byteLength?: number,\n    options?: SessionOptions,\n  ): Promise<InferenceSessionInterface>;\n  static create(buffer: Uint8Array, options?: SessionOptions): Promise<InferenceSessionInterface>;\n  static async create(\n    arg0: string | ArrayBufferLike | Uint8Array,\n    arg1?: SessionOptions | number,\n    arg2?: number,\n    arg3?: SessionOptions,\n  ): Promise<InferenceSessionInterface> {\n    TRACE_FUNC_BEGIN();\n    TRACE_EVENT_BEGIN('InferenceSession.create');\n    // either load from a file or buffer\n    let filePathOrUint8Array: string | Uint8Array;\n    let options: SessionOptions = {};\n\n    if (typeof arg0 === 'string') {\n      filePathOrUint8Array = arg0;\n      if (typeof arg1 === 'object' && arg1 !== null) {\n        options = arg1;\n      } else if (typeof arg1 !== 'undefined') {\n        throw new TypeError(\"'options' must be an object.\");\n      }\n    } else if (arg0 instanceof Uint8Array) {\n      filePathOrUint8Array = arg0;\n      if (typeof arg1 === 'object' && arg1 !== null) {\n        options = arg1;\n      } else if (typeof arg1 !== 'undefined') {\n        throw new TypeError(\"'options' must be an object.\");\n      }\n    } else if (\n      arg0 instanceof ArrayBuffer ||\n      (typeof SharedArrayBuffer !== 'undefined' && arg0 instanceof SharedArrayBuffer)\n    ) {\n      const buffer = arg0;\n      let byteOffset = 0;\n      let byteLength = arg0.byteLength;\n      if (typeof arg1 === 'object' && arg1 !== null) {\n        options = arg1;\n      } else if (typeof arg1 === 'number') {\n        byteOffset = arg1;\n        if (!Number.isSafeInteger(byteOffset)) {\n          throw new RangeError(\"'byteOffset' must be an integer.\");\n        }\n        if (byteOffset < 0 || byteOffset >= buffer.byteLength) {\n          throw new RangeError(`'byteOffset' is out of range [0, ${buffer.byteLength}).`);\n        }\n        byteLength = arg0.byteLength - byteOffset;\n        if (typeof arg2 === 'number') {\n          byteLength = arg2;\n          if (!Number.isSafeInteger(byteLength)) {\n            throw new RangeError(\"'byteLength' must be an integer.\");\n          }\n          if (byteLength <= 0 || byteOffset + byteLength > buffer.byteLength) {\n            throw new RangeError(`'byteLength' is out of range (0, ${buffer.byteLength - byteOffset}].`);\n          }\n          if (typeof arg3 === 'object' && arg3 !== null) {\n            options = arg3;\n          } else if (typeof arg3 !== 'undefined') {\n            throw new TypeError(\"'options' must be an object.\");\n          }\n        } else if (typeof arg2 !== 'undefined') {\n          throw new TypeError(\"'byteLength' must be a number.\");\n        }\n      } else if (typeof arg1 !== 'undefined') {\n        throw new TypeError(\"'options' must be an object.\");\n      }\n      filePathOrUint8Array = new Uint8Array(buffer, byteOffset, byteLength);\n    } else {\n      throw new TypeError(\"Unexpected argument[0]: must be 'path' or 'buffer'.\");\n    }\n\n    // resolve backend, update session options with validated EPs, and create session handler\n    const [backend, optionsWithValidatedEPs] = await resolveBackendAndExecutionProviders(options);\n    const handler = await backend.createInferenceSessionHandler(filePathOrUint8Array, optionsWithValidatedEPs);\n    TRACE_EVENT_END('InferenceSession.create');\n    TRACE_FUNC_END();\n    return new InferenceSession(handler);\n  }\n\n  startProfiling(): void {\n    this.handler.startProfiling();\n  }\n  endProfiling(): void {\n    this.handler.endProfiling();\n  }\n\n  get inputNames(): readonly string[] {\n    return this.handler.inputNames;\n  }\n  get outputNames(): readonly string[] {\n    return this.handler.outputNames;\n  }\n\n  get inputMetadata(): readonly InferenceSessionInterface.ValueMetadata[] {\n    return this.handler.inputMetadata;\n  }\n\n  get outputMetadata(): readonly InferenceSessionInterface.ValueMetadata[] {\n    return this.handler.outputMetadata;\n  }\n\n  private handler: InferenceSessionHandler;\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { InferenceSession as InferenceSessionImpl } from './inference-session-impl.js';\nimport { OnnxModelOptions } from './onnx-model.js';\nimport { OnnxValue, OnnxValueDataLocation } from './onnx-value.js';\nimport type { Tensor } from './tensor.js';\nimport { TryGetGlobalType } from './type-helper.js';\n\n/* eslint-disable @typescript-eslint/no-redeclare */\n\nexport declare namespace InferenceSession {\n  // #region input/output types\n\n  type OnnxValueMapType = { readonly [name: string]: OnnxValue };\n  type NullableOnnxValueMapType = { readonly [name: string]: OnnxValue | null };\n\n  /**\n   * A feeds (model inputs) is an object that uses input names as keys and OnnxValue as corresponding values.\n   */\n  type FeedsType = OnnxValueMapType;\n\n  /**\n   * A fetches (model outputs) could be one of the following:\n   *\n   * - Omitted. Use model's output names definition.\n   * - An array of string indicating the output names.\n   * - An object that use output names as keys and OnnxValue or null as corresponding values.\n   *\n   * @remark\n   * different from input argument, in output, OnnxValue is optional. If an OnnxValue is present it will be\n   * used as a pre-allocated value by the inference engine; if omitted, inference engine will allocate buffer\n   * internally.\n   */\n  type FetchesType = readonly string[] | NullableOnnxValueMapType;\n\n  /**\n   * A inferencing return type is an object that uses output names as keys and OnnxValue as corresponding values.\n   */\n  type ReturnType = OnnxValueMapType;\n\n  // #endregion\n\n  // #region session options\n\n  /**\n   * A set of configurations for session behavior.\n   */\n  export interface SessionOptions extends OnnxModelOptions {\n    /**\n     * An array of execution provider options.\n     *\n     * An execution provider option can be a string indicating the name of the execution provider,\n     * or an object of corresponding type.\n     */\n    executionProviders?: readonly ExecutionProviderConfig[];\n\n    /**\n     * The intra OP threads number.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native).\n     */\n    intraOpNumThreads?: number;\n\n    /**\n     * The inter OP threads number.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native).\n     */\n    interOpNumThreads?: number;\n\n    /**\n     * The free dimension override.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    freeDimensionOverrides?: { readonly [dimensionName: string]: number };\n\n    /**\n     * The optimization level.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    graphOptimizationLevel?: 'disabled' | 'basic' | 'extended' | 'layout' | 'all';\n\n    /**\n     * Whether enable CPU memory arena.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    enableCpuMemArena?: boolean;\n\n    /**\n     * Whether enable memory pattern.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    enableMemPattern?: boolean;\n\n    /**\n     * Execution mode.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    executionMode?: 'sequential' | 'parallel';\n\n    /**\n     * Optimized model file path.\n     *\n     * If this setting is specified, the optimized model will be dumped. In browser, a blob will be created\n     * with a pop-up window.\n     */\n    optimizedModelFilePath?: string;\n\n    /**\n     * Whether enable profiling.\n     *\n     * This setting is a placeholder for a future use.\n     */\n    enableProfiling?: boolean;\n\n    /**\n     * File prefix for profiling.\n     *\n     * This setting is a placeholder for a future use.\n     */\n    profileFilePrefix?: string;\n\n    /**\n     * Log ID.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    logId?: string;\n\n    /**\n     * Log severity level. See\n     * https://github.com/microsoft/onnxruntime/blob/main/include/onnxruntime/core/common/logging/severity.h\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    logSeverityLevel?: 0 | 1 | 2 | 3 | 4;\n\n    /**\n     * Log verbosity level.\n     *\n     * This setting is available only in WebAssembly backend. Will support Node.js binding and react-native later\n     */\n    logVerbosityLevel?: number;\n\n    /**\n     * Specify string as a preferred data location for all outputs, or an object that use output names as keys and a\n     * preferred data location as corresponding values.\n     *\n     * This setting is available only in ONNXRuntime Web for WebGL and WebGPU EP.\n     */\n    preferredOutputLocation?: OnnxValueDataLocation | { readonly [outputName: string]: OnnxValueDataLocation };\n\n    /**\n     * Whether enable graph capture.\n     * This setting is available only in ONNXRuntime Web for WebGPU EP.\n     */\n    enableGraphCapture?: boolean;\n\n    /**\n     * Store configurations for a session. See\n     * https://github.com/microsoft/onnxruntime/blob/main/include/onnxruntime/core/session/\n     * onnxruntime_session_options_config_keys.h\n     *\n     * This setting is available only in WebAssembly backend. Will support Node.js binding and react-native later\n     *\n     * @example\n     * ```js\n     * extra: {\n     *   session: {\n     *     set_denormal_as_zero: \"1\",\n     *     disable_prepacking: \"1\"\n     *   },\n     *   optimization: {\n     *     enable_gelu_approximation: \"1\"\n     *   }\n     * }\n     * ```\n     */\n    extra?: Record<string, unknown>;\n  }\n\n  // #region execution providers\n\n  // Currently, we have the following backends to support execution providers:\n  // Backend Node.js binding: supports 'cpu', 'dml' (win32), 'coreml' (macOS) and 'cuda' (linux).\n  // Backend WebAssembly: supports 'cpu', 'wasm', 'webgpu' and 'webnn'.\n  // Backend ONNX.js: supports 'webgl'.\n  // Backend React Native: supports 'cpu', 'xnnpack', 'coreml' (iOS), 'nnapi' (Android).\n  interface ExecutionProviderOptionMap {\n    coreml: CoreMLExecutionProviderOption;\n    cpu: CpuExecutionProviderOption;\n    cuda: CudaExecutionProviderOption;\n    dml: DmlExecutionProviderOption;\n    nnapi: NnapiExecutionProviderOption;\n    tensorrt: TensorRtExecutionProviderOption;\n    wasm: WebAssemblyExecutionProviderOption;\n    webgl: WebGLExecutionProviderOption;\n    webgpu: WebGpuExecutionProviderOption;\n    webnn: WebNNExecutionProviderOption;\n    qnn: QnnExecutionProviderOption;\n    xnnpack: XnnpackExecutionProviderOption;\n  }\n\n  type ExecutionProviderName = keyof ExecutionProviderOptionMap;\n  type ExecutionProviderConfig =\n    | ExecutionProviderOptionMap[ExecutionProviderName]\n    | ExecutionProviderOption\n    | ExecutionProviderName\n    | string;\n\n  export interface ExecutionProviderOption {\n    readonly name: string;\n  }\n  export interface CpuExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'cpu';\n    useArena?: boolean;\n  }\n  export interface CudaExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'cuda';\n    deviceId?: number;\n  }\n  export interface DmlExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'dml';\n    deviceId?: number;\n  }\n  export interface TensorRtExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'tensorrt';\n    deviceId?: number;\n  }\n  export interface WebAssemblyExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'wasm';\n  }\n  export interface WebGLExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'webgl';\n    // TODO: add flags\n  }\n  export interface XnnpackExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'xnnpack';\n  }\n  export interface WebGpuExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'webgpu';\n\n    /**\n     * Specify the preferred layout when running layout sensitive operators.\n     *\n     * @default 'NCHW'\n     */\n    preferredLayout?: 'NCHW' | 'NHWC';\n\n    /**\n     * Specify a list of node names that should be executed on CPU even when WebGPU EP is used.\n     */\n    forceCpuNodeNames?: readonly string[];\n\n    /**\n     * Specify the validation mode for WebGPU execution provider.\n     * - 'disabled': Disable all validation.\n     * When used in Node.js, disable validation may cause process crash if WebGPU errors occur. Be cautious when using\n     * this mode.\n     * When used in web, this mode is equivalent to 'wgpuOnly'.\n     * - 'wgpuOnly': Perform WebGPU internal validation only.\n     * - 'basic': Perform basic validation including WebGPU internal validation. This is the default mode.\n     * - 'full': Perform full validation. This mode may have performance impact. Use it for debugging purpose.\n     *\n     * @default 'basic'\n     */\n    validationMode?: 'disabled' | 'wgpuOnly' | 'basic' | 'full';\n\n    /**\n     * Specify an optional WebGPU device to be used by the WebGPU execution provider.\n     */\n    device?: TryGetGlobalType<'GPUDevice'>;\n  }\n\n  // #region WebNN options\n\n  interface WebNNExecutionProviderName extends ExecutionProviderOption {\n    readonly name: 'webnn';\n  }\n\n  /**\n   * Represents a set of options for creating a WebNN MLContext.\n   *\n   * @see https://www.w3.org/TR/webnn/#dictdef-mlcontextoptions\n   */\n  export interface WebNNContextOptions {\n    deviceType?: 'cpu' | 'gpu' | 'npu';\n    numThreads?: number;\n    powerPreference?: 'default' | 'low-power' | 'high-performance';\n  }\n\n  /**\n   * Represents a set of options for WebNN execution provider without MLContext.\n   */\n  export interface WebNNOptionsWithoutMLContext extends WebNNExecutionProviderName, WebNNContextOptions {\n    context?: never;\n  }\n\n  /**\n   * Represents a set of options for WebNN execution provider with MLContext.\n   *\n   * When MLContext is provided, the deviceType is also required so that the WebNN EP can determine the preferred\n   * channel layout.\n   *\n   * @see https://www.w3.org/TR/webnn/#dom-ml-createcontext\n   */\n  export interface WebNNOptionsWithMLContext\n    extends WebNNExecutionProviderName,\n      Omit<WebNNContextOptions, 'deviceType'>,\n      Required<Pick<WebNNContextOptions, 'deviceType'>> {\n    context: TryGetGlobalType<'MLContext'>;\n  }\n\n  /**\n   * Represents a set of options for WebNN execution provider with MLContext which is created from GPUDevice.\n   *\n   * @see https://www.w3.org/TR/webnn/#dom-ml-createcontext-gpudevice\n   */\n  export interface WebNNOptionsWebGpu extends WebNNExecutionProviderName {\n    context: TryGetGlobalType<'MLContext'>;\n    gpuDevice: TryGetGlobalType<'GPUDevice'>;\n  }\n\n  /**\n   * Options for WebNN execution provider.\n   */\n  export type WebNNExecutionProviderOption =\n    | WebNNOptionsWithoutMLContext\n    | WebNNOptionsWithMLContext\n    | WebNNOptionsWebGpu;\n\n  // #endregion\n\n  export interface QnnExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'qnn';\n    /**\n     * Specify the QNN backend type. E.g., 'cpu' or 'htp'.\n     * Mutually exclusive with `backendPath`.\n     *\n     * @default 'htp'\n     */\n    backendType?: string;\n    /**\n     * Specify a path to the QNN backend library.\n     * Mutually exclusive with `backendType`.\n     */\n    backendPath?: string;\n    /**\n     * Specify whether to enable HTP FP16 precision.\n     *\n     * @default true\n     */\n    enableFp16Precision?: boolean;\n  }\n  export interface CoreMLExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'coreml';\n    /**\n     * The bit flags for CoreML execution provider.\n     *\n     * ```\n     * COREML_FLAG_USE_CPU_ONLY = 0x001\n     * COREML_FLAG_ENABLE_ON_SUBGRAPH = 0x002\n     * COREML_FLAG_ONLY_ENABLE_DEVICE_WITH_ANE = 0x004\n     * COREML_FLAG_ONLY_ALLOW_STATIC_INPUT_SHAPES = 0x008\n     * COREML_FLAG_CREATE_MLPROGRAM = 0x010\n     * COREML_FLAG_USE_CPU_AND_GPU = 0x020\n     * ```\n     *\n     * See include/onnxruntime/core/providers/coreml/coreml_provider_factory.h for more details.\n     *\n     * This flag is available only in ONNXRuntime (Node.js binding).\n     */\n    coreMlFlags?: number;\n    /**\n     * Specify whether to use CPU only in CoreML EP.\n     *\n     * This setting is available only in ONNXRuntime (react-native).\n     */\n    useCPUOnly?: boolean;\n    useCPUAndGPU?: boolean;\n    /**\n     * Specify whether to enable CoreML EP on subgraph.\n     *\n     * This setting is available only in ONNXRuntime (react-native).\n     */\n    enableOnSubgraph?: boolean;\n    /**\n     * Specify whether to only enable CoreML EP for Apple devices with ANE (Apple Neural Engine).\n     *\n     * This setting is available only in ONNXRuntime (react-native).\n     */\n    onlyEnableDeviceWithANE?: boolean;\n  }\n  export interface NnapiExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'nnapi';\n    useFP16?: boolean;\n    useNCHW?: boolean;\n    cpuDisabled?: boolean;\n    cpuOnly?: boolean;\n  }\n  // #endregion\n\n  // #endregion\n\n  // #region run options\n\n  /**\n   * A set of configurations for inference run behavior\n   */\n  export interface RunOptions {\n    /**\n     * Log severity level. See\n     * https://github.com/microsoft/onnxruntime/blob/main/include/onnxruntime/core/common/logging/severity.h\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    logSeverityLevel?: 0 | 1 | 2 | 3 | 4;\n\n    /**\n     * Log verbosity level.\n     *\n     * This setting is available only in WebAssembly backend. Will support Node.js binding and react-native later\n     */\n    logVerbosityLevel?: number;\n\n    /**\n     * Terminate all incomplete OrtRun calls as soon as possible if true\n     *\n     * This setting is available only in WebAssembly backend. Will support Node.js binding and react-native later\n     */\n    terminate?: boolean;\n\n    /**\n     * A tag for the Run() calls using this\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    tag?: string;\n\n    /**\n     * Set a single run configuration entry. See\n     * https://github.com/microsoft/onnxruntime/blob/main/include/onnxruntime/core/session/\n     * onnxruntime_run_options_config_keys.h\n     *\n     * This setting is available only in WebAssembly backend. Will support Node.js binding and react-native later\n     *\n     * @example\n     *\n     * ```js\n     * extra: {\n     *   memory: {\n     *     enable_memory_arena_shrinkage: \"1\",\n     *   }\n     * }\n     * ```\n     */\n    extra?: Record<string, unknown>;\n  }\n\n  // #endregion\n\n  // #region value metadata\n\n  /**\n   * The common part of the value metadata type for both tensor and non-tensor values.\n   */\n  export interface ValueMetadataBase {\n    /**\n     * The name of the specified input or output.\n     */\n    readonly name: string;\n  }\n\n  /**\n   * Represents the metadata of a non-tensor value.\n   */\n  export interface NonTensorValueMetadata extends ValueMetadataBase {\n    /**\n     * Get a value indicating whether the value is a tensor.\n     */\n    readonly isTensor: false;\n  }\n\n  /**\n   * Represents the metadata of a tensor value.\n   */\n  export interface TensorValueMetadata extends ValueMetadataBase {\n    /**\n     * Get a value indicating whether the value is a tensor.\n     */\n    readonly isTensor: true;\n    /**\n     * Get the data type of the tensor.\n     */\n    readonly type: Tensor.Type;\n    /**\n     * Get the shape of the tensor.\n     *\n     * If the shape is not defined, the value will an empty array. Otherwise, it will be an array representing the shape\n     * of the tensor. Each element in the array can be a number or a string. If the element is a number, it represents\n     * the corresponding dimension size. If the element is a string, it represents a symbolic dimension.\n     */\n    readonly shape: ReadonlyArray<number | string>;\n  }\n\n  /**\n   * Represents the metadata of a value.\n   */\n  export type ValueMetadata = NonTensorValueMetadata | TensorValueMetadata;\n\n  // #endregion\n}\n\n/**\n * Represent a runtime instance of an ONNX model.\n */\nexport interface InferenceSession {\n  // #region run()\n\n  /**\n   * Execute the model asynchronously with the given feeds and options.\n   *\n   * @param feeds - Representation of the model input. See type description of `InferenceSession.InputType` for detail.\n   * @param options - Optional. A set of options that controls the behavior of model inference.\n   * @returns A promise that resolves to a map, which uses output names as keys and OnnxValue as corresponding values.\n   */\n  run(feeds: InferenceSession.FeedsType, options?: InferenceSession.RunOptions): Promise<InferenceSession.ReturnType>;\n\n  /**\n   * Execute the model asynchronously with the given feeds, fetches and options.\n   *\n   * @param feeds - Representation of the model input. See type description of `InferenceSession.InputType` for detail.\n   * @param fetches - Representation of the model output. See type description of `InferenceSession.OutputType` for\n   * detail.\n   * @param options - Optional. A set of options that controls the behavior of model inference.\n   * @returns A promise that resolves to a map, which uses output names as keys and OnnxValue as corresponding values.\n   */\n  run(\n    feeds: InferenceSession.FeedsType,\n    fetches: InferenceSession.FetchesType,\n    options?: InferenceSession.RunOptions,\n  ): Promise<InferenceSession.ReturnType>;\n\n  // #endregion\n\n  // #region release()\n\n  /**\n   * Release the inference session and the underlying resources.\n   */\n  release(): Promise<void>;\n\n  // #endregion\n\n  // #region profiling\n\n  /**\n   * Start profiling.\n   */\n  startProfiling(): void;\n\n  /**\n   * End profiling.\n   */\n  endProfiling(): void;\n\n  // #endregion\n\n  // #region metadata\n\n  /**\n   * Get input names of the loaded model.\n   */\n  readonly inputNames: readonly string[];\n\n  /**\n   * Get output names of the loaded model.\n   */\n  readonly outputNames: readonly string[];\n\n  /**\n   * Get input metadata of the loaded model.\n   */\n  readonly inputMetadata: readonly InferenceSession.ValueMetadata[];\n\n  /**\n   * Get output metadata of the loaded model.\n   */\n  readonly outputMetadata: readonly InferenceSession.ValueMetadata[];\n\n  // #endregion\n}\n\nexport interface InferenceSessionFactory {\n  // #region create()\n\n  /**\n   * Create a new inference session and load model asynchronously from an ONNX model file.\n   *\n   * @param uri - The URI or file path of the model to load.\n   * @param options - specify configuration for creating a new inference session.\n   * @returns A promise that resolves to an InferenceSession object.\n   */\n  create(uri: string, options?: InferenceSession.SessionOptions): Promise<InferenceSession>;\n\n  /**\n   * Create a new inference session and load model asynchronously from an array bufer.\n   *\n   * @param buffer - An ArrayBuffer representation of an ONNX model.\n   * @param options - specify configuration for creating a new inference session.\n   * @returns A promise that resolves to an InferenceSession object.\n   */\n  create(buffer: ArrayBufferLike, options?: InferenceSession.SessionOptions): Promise<InferenceSession>;\n\n  /**\n   * Create a new inference session and load model asynchronously from segment of an array bufer.\n   *\n   * @param buffer - An ArrayBuffer representation of an ONNX model.\n   * @param byteOffset - The beginning of the specified portion of the array buffer.\n   * @param byteLength - The length in bytes of the array buffer.\n   * @param options - specify configuration for creating a new inference session.\n   * @returns A promise that resolves to an InferenceSession object.\n   */\n  create(\n    buffer: ArrayBufferLike,\n    byteOffset: number,\n    byteLength?: number,\n    options?: InferenceSession.SessionOptions,\n  ): Promise<InferenceSession>;\n\n  /**\n   * Create a new inference session and load model asynchronously from a Uint8Array.\n   *\n   * @param buffer - A Uint8Array representation of an ONNX model.\n   * @param options - specify configuration for creating a new inference session.\n   * @returns A promise that resolves to an InferenceSession object.\n   */\n  create(buffer: Uint8Array, options?: InferenceSession.SessionOptions): Promise<InferenceSession>;\n\n  // #endregion\n}\n\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const InferenceSession: InferenceSessionFactory = InferenceSessionImpl;\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { OptionsFormat, OptionsNormalizationParameters, OptionsTensorLayout } from './tensor-factory.js';\n\nexport interface TensorToDataUrlOptions extends OptionsTensorLayout, OptionsFormat, OptionsNormalizationParameters {}\n\nexport interface TensorToImageDataOptions extends OptionsTensorLayout, OptionsFormat, OptionsNormalizationParameters {}\n\nexport interface ConversionUtils {\n  /**\n   * creates a DataURL instance from tensor\n   *\n   * @param options - An optional object representing options for creating a DataURL instance from the tensor.\n   *\n   * The following default settings will be applied:\n   * - `format`: `'RGB'`\n   * - `tensorLayout`: `'NCHW'`\n   * @returns a DataURL string representing the image converted from tensor data\n   */\n  toDataURL(options?: TensorToDataUrlOptions): string;\n\n  /**\n   * creates an ImageData instance from tensor\n   *\n   * @param options - An optional object representing options for creating an ImageData instance from the tensor.\n   *\n   * The following default settings will be applied:\n   * - `format`: `'RGB'`\n   * - `tensorLayout`: `'NCHW'`\n   * @returns an ImageData instance representing the image converted from tensor data\n   */\n  toImageData(options?: TensorToImageDataOptions): ImageData;\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Tensor, TypedTensor } from './tensor.js';\n\nexport type ImageFormat = 'RGB' | 'RGBA' | 'BGR' | 'RBG';\nexport type ImageTensorLayout = 'NHWC' | 'NCHW';\n\n// the following region contains type definitions for constructing tensor from a specific location.\n\n// #region types for constructing a tensor from a specific location\n\n/**\n * represent common properties of the parameter for constructing a tensor from a specific location.\n */\ninterface CommonConstructorParameters<T> extends Pick<Tensor, 'dims'> {\n  /**\n   * Specify the data type of the tensor.\n   */\n  readonly type: T;\n}\n\n/**\n * represent the parameter for constructing a tensor from a GPU resource.\n */\ninterface GpuResourceConstructorParameters<T extends Tensor.Type> {\n  /**\n   * an optional callback function to download data from GPU to CPU.\n   *\n   * If not provided, the tensor treat the GPU data as external resource.\n   */\n  download?(): Promise<Tensor.DataTypeMap[T]>;\n\n  /**\n   * an optional callback function that will be called when the tensor is disposed.\n   *\n   * If not provided, the tensor treat the GPU data as external resource.\n   */\n  dispose?(): void;\n}\n\n/**\n * represent the parameter for constructing a tensor from a pinned CPU buffer\n */\nexport interface CpuPinnedConstructorParameters<T extends Tensor.CpuPinnedDataTypes = Tensor.CpuPinnedDataTypes>\n  extends CommonConstructorParameters<T> {\n  /**\n   * Specify the location of the data to be 'cpu-pinned'.\n   */\n  readonly location: 'cpu-pinned';\n  /**\n   * Specify the CPU pinned buffer that holds the tensor data.\n   */\n  readonly data: Tensor.DataTypeMap[T];\n}\n\n/**\n * represent the parameter for constructing a tensor from a WebGL texture\n */\nexport interface TextureConstructorParameters<T extends Tensor.TextureDataTypes = Tensor.TextureDataTypes>\n  extends CommonConstructorParameters<T>,\n    GpuResourceConstructorParameters<T> {\n  /**\n   * Specify the location of the data to be 'texture'.\n   */\n  readonly location: 'texture';\n  /**\n   * Specify the WebGL texture that holds the tensor data.\n   */\n  readonly texture: Tensor.TextureType;\n}\n\n/**\n * represent the parameter for constructing a tensor from a WebGPU buffer\n */\nexport interface GpuBufferConstructorParameters<T extends Tensor.GpuBufferDataTypes = Tensor.GpuBufferDataTypes>\n  extends CommonConstructorParameters<T>,\n    GpuResourceConstructorParameters<T> {\n  /**\n   * Specify the location of the data to be 'gpu-buffer'.\n   */\n  readonly location: 'gpu-buffer';\n  /**\n   * Specify the WebGPU buffer that holds the tensor data.\n   */\n  readonly gpuBuffer: Tensor.GpuBufferType;\n}\n\nexport interface MLTensorConstructorParameters<T extends Tensor.MLTensorDataTypes = Tensor.MLTensorDataTypes>\n  extends CommonConstructorParameters<T>,\n    GpuResourceConstructorParameters<T> {\n  /**\n   * Specify the location of the data to be 'ml-tensor'.\n   */\n  readonly location: 'ml-tensor';\n\n  /**\n   * Specify the WebNN MLTensor that holds the tensor data.\n   */\n  readonly mlTensor: Tensor.MLTensorType;\n}\n\n// #endregion\n\n// the following region contains type definitions of each individual options.\n// the tensor factory functions use a composition of those options as the parameter type.\n\n// #region Options fields\n\nexport interface OptionsFormat {\n  /**\n   * Describes the image format represented in RGBA color space.\n   */\n  format?: ImageFormat;\n}\n\nexport interface OptionsTensorFormat {\n  /**\n   * Describes the image format of the tensor.\n   *\n   * NOTE: this is different from option 'format'. While option 'format' represents the original image, 'tensorFormat'\n   * represents the target format of the tensor. A transpose will be performed if they are different.\n   */\n  tensorFormat?: ImageFormat;\n}\n\nexport interface OptionsTensorDataType {\n  /**\n   * Describes the data type of the tensor.\n   */\n  dataType?: 'float32' | 'uint8';\n}\n\nexport interface OptionsTensorLayout {\n  /**\n   * Describes the tensor layout when representing data of one or more image(s).\n   */\n  tensorLayout?: ImageTensorLayout;\n}\n\nexport interface OptionsDimensions {\n  /**\n   * Describes the image height in pixel\n   */\n  height?: number;\n  /**\n   * Describes the image width in pixel\n   */\n  width?: number;\n}\n\nexport interface OptionResizedDimensions {\n  /**\n   * Describes the resized height. If omitted, original height will be used.\n   */\n  resizedHeight?: number;\n  /**\n   * Describes resized width - can be accessed via tensor dimensions as well\n   */\n  resizedWidth?: number;\n}\n\nexport interface OptionsNormalizationParameters {\n  /**\n   * Describes normalization parameters when preprocessing the image as model input.\n   *\n   * Data element are ranged from 0 to 255.\n   */\n  norm?: {\n    /**\n     * The 'bias' value for image normalization.\n     * - If omitted, use default value 0.\n     * - If it's a single number, apply to each channel\n     * - If it's an array of 3 or 4 numbers, apply element-wise. Number of elements need to match the number of channels\n     * for the corresponding image format\n     */\n    bias?: number | [number, number, number] | [number, number, number, number];\n    /**\n     * The 'mean' value for image normalization.\n     * - If omitted, use default value 255.\n     * - If it's a single number, apply to each channel\n     * - If it's an array of 3 or 4 numbers, apply element-wise. Number of elements need to match the number of channels\n     * for the corresponding image format\n     */\n    mean?: number | [number, number, number] | [number, number, number, number];\n  };\n}\n\n// #endregion\n\n// #region Options composition\n\nexport interface TensorFromImageDataOptions\n  extends OptionResizedDimensions,\n    OptionsTensorFormat,\n    OptionsTensorLayout,\n    OptionsTensorDataType,\n    OptionsNormalizationParameters {}\n\nexport interface TensorFromImageElementOptions\n  extends OptionResizedDimensions,\n    OptionsTensorFormat,\n    OptionsTensorLayout,\n    OptionsTensorDataType,\n    OptionsNormalizationParameters {}\n\nexport interface TensorFromUrlOptions\n  extends OptionsDimensions,\n    OptionResizedDimensions,\n    OptionsTensorFormat,\n    OptionsTensorLayout,\n    OptionsTensorDataType,\n    OptionsNormalizationParameters {}\n\nexport interface TensorFromImageBitmapOptions\n  extends OptionResizedDimensions,\n    OptionsTensorFormat,\n    OptionsTensorLayout,\n    OptionsTensorDataType,\n    OptionsNormalizationParameters {}\n\nexport interface TensorFromTextureOptions<T extends Tensor.TextureDataTypes>\n  extends Required<OptionsDimensions>,\n    OptionsFormat,\n    GpuResourceConstructorParameters<T> /* TODO: add more */ {}\n\nexport interface TensorFromGpuBufferOptions<T extends Tensor.GpuBufferDataTypes>\n  extends Pick<Tensor, 'dims'>,\n    GpuResourceConstructorParameters<T> {\n  /**\n   * Describes the data type of the tensor.\n   */\n  dataType?: T;\n}\n\nexport interface TensorFromMLTensorOptions<T extends Tensor.MLTensorDataTypes>\n  extends Pick<Tensor, 'dims'>,\n    GpuResourceConstructorParameters<T> {\n  /**\n   * Describes the data type of the tensor.\n   */\n  dataType?: T;\n}\n\n// #endregion\n\n/**\n * type TensorFactory defines the factory functions of 'Tensor' to create tensor instances from existing data or\n * resources.\n */\nexport interface TensorFactory {\n  /**\n   * create a tensor from an ImageData object\n   *\n   * @param imageData - the ImageData object to create tensor from\n   * @param options - An optional object representing options for creating tensor from ImageData.\n   *\n   * The following default settings will be applied:\n   * - `tensorFormat`: `'RGB'`\n   * - `tensorLayout`: `'NCHW'`\n   * - `dataType`: `'float32'`\n   * @returns A promise that resolves to a tensor object\n   */\n  fromImage(\n    imageData: ImageData,\n    options?: TensorFromImageDataOptions,\n  ): Promise<TypedTensor<'float32'> | TypedTensor<'uint8'>>;\n\n  /**\n   * create a tensor from a HTMLImageElement object\n   *\n   * @param imageElement - the HTMLImageElement object to create tensor from\n   * @param options - An optional object representing options for creating tensor from HTMLImageElement.\n   *\n   * The following default settings will be applied:\n   * - `tensorFormat`: `'RGB'`\n   * - `tensorLayout`: `'NCHW'`\n   * - `dataType`: `'float32'`\n   * @returns A promise that resolves to a tensor object\n   */\n  fromImage(\n    imageElement: HTMLImageElement,\n    options?: TensorFromImageElementOptions,\n  ): Promise<TypedTensor<'float32'> | TypedTensor<'uint8'>>;\n\n  /**\n   * create a tensor from URL\n   *\n   * @param urlSource - a string as a URL to the image or a data URL containing the image data.\n   * @param options - An optional object representing options for creating tensor from URL.\n   *\n   * The following default settings will be applied:\n   * - `tensorFormat`: `'RGB'`\n   * - `tensorLayout`: `'NCHW'`\n   * - `dataType`: `'float32'`\n   * @returns A promise that resolves to a tensor object\n   */\n  fromImage(urlSource: string, options?: TensorFromUrlOptions): Promise<TypedTensor<'float32'> | TypedTensor<'uint8'>>;\n\n  /**\n   * create a tensor from an ImageBitmap object\n   *\n   * @param bitmap - the ImageBitmap object to create tensor from\n   * @param options - An optional object representing options for creating tensor from URL.\n   *\n   * The following default settings will be applied:\n   * - `tensorFormat`: `'RGB'`\n   * - `tensorLayout`: `'NCHW'`\n   * - `dataType`: `'float32'`\n   * @returns A promise that resolves to a tensor object\n   */\n  fromImage(\n    bitmap: ImageBitmap,\n    options: TensorFromImageBitmapOptions,\n  ): Promise<TypedTensor<'float32'> | TypedTensor<'uint8'>>;\n\n  /**\n   * create a tensor from a WebGL texture\n   *\n   * @param texture - the WebGLTexture object to create tensor from\n   * @param options - An optional object representing options for creating tensor from WebGL texture.\n   *\n   * The options include following properties:\n   * - `width`: the width of the texture. Required.\n   * - `height`: the height of the texture. Required.\n   * - `format`: the format of the texture. If omitted, assume 'RGBA'.\n   * - `download`: an optional function to download the tensor data from GPU to CPU. If omitted, the GPU data\n   * will not be able to download. Usually, this is provided by a GPU backend for the inference outputs. Users don't\n   * need to provide this function.\n   * - `dispose`: an optional function to dispose the tensor data on GPU. If omitted, the GPU data will not be disposed.\n   * Usually, this is provided by a GPU backend for the inference outputs. Users don't need to provide this function.\n   *\n   * @returns a tensor object\n   */\n  fromTexture<T extends Tensor.TextureDataTypes = 'float32'>(\n    texture: Tensor.TextureType,\n    options: TensorFromTextureOptions<T>,\n  ): TypedTensor<'float32'>;\n\n  /**\n   * create a tensor from a WebGPU buffer\n   *\n   * @param buffer - the GPUBuffer object to create tensor from\n   * @param options - An optional object representing options for creating tensor from WebGPU buffer.\n   *\n   * The options include following properties:\n   * - `dataType`: the data type of the tensor. If omitted, assume 'float32'.\n   * - `dims`: the dimension of the tensor. Required.\n   * - `download`: an optional function to download the tensor data from GPU to CPU. If omitted, the GPU data\n   * will not be able to download. Usually, this is provided by a GPU backend for the inference outputs. Users don't\n   * need to provide this function.\n   * - `dispose`: an optional function to dispose the tensor data on GPU. If omitted, the GPU data will not be disposed.\n   * Usually, this is provided by a GPU backend for the inference outputs. Users don't need to provide this function.\n   *\n   * @returns a tensor object\n   */\n  fromGpuBuffer<T extends Tensor.GpuBufferDataTypes>(\n    buffer: Tensor.GpuBufferType,\n    options: TensorFromGpuBufferOptions<T>,\n  ): TypedTensor<T>;\n\n  /**\n   * create a tensor from a WebNN MLTensor\n   *\n   * @param tensor - the MLTensor object to create tensor from\n   * @param options - An optional object representing options for creating tensor from a WebNN MLTensor.\n   *\n   * The options include following properties:\n   * - `dataType`: the data type of the tensor. If omitted, assume 'float32'.\n   * - `dims`: the dimension of the tensor. Required.\n   * - `download`: an optional function to download the tensor data from the MLTensor to CPU. If omitted, the MLTensor\n   * data will not be able to download. Usually, this is provided by the WebNN backend for the inference outputs.\n   * Users don't need to provide this function.\n   * - `dispose`: an optional function to dispose the tensor data on the WebNN MLTensor. If omitted, the MLTensor will\n   * not be disposed. Usually, this is provided by the WebNN backend for the inference outputs. Users don't need to\n   * provide this function.\n   *\n   * @returns a tensor object\n   */\n  fromMLTensor<T extends Tensor.MLTensorDataTypes>(\n    tensor: Tensor.MLTensorType,\n    options: TensorFromMLTensorOptions<T>,\n  ): TypedTensor<T>;\n\n  /**\n   * create a tensor from a pre-allocated buffer. The buffer will be used as a pinned buffer.\n   *\n   * @param type - the tensor element type.\n   * @param buffer - a TypedArray corresponding to the type.\n   * @param dims - specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   *\n   * @returns a tensor object\n   */\n  fromPinnedBuffer<T extends Exclude<Tensor.Type, 'string'>>(\n    type: T,\n    buffer: Tensor.DataTypeMap[T],\n    dims?: readonly number[],\n  ): TypedTensor<T>;\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n/**\n * A string that represents a file's URL or path.\n *\n * Path is vailable only in onnxruntime-node or onnxruntime-web running in Node.js.\n */\nexport type FileUrlOrPath = string;\n\n/**\n * A Blob object that represents a file.\n */\nexport type FileBlob = Blob;\n\n/**\n * A Uint8Array, ArrayBuffer or SharedArrayBuffer object that represents a file content.\n *\n * When it is an ArrayBuffer or SharedArrayBuffer, the whole buffer is assumed to be the file content.\n */\nexport type FileData = Uint8Array | ArrayBufferLike;\n\n/**\n * Represents a file that can be loaded by the ONNX Runtime JavaScript API.\n */\nexport type FileType = FileUrlOrPath | FileBlob | FileData;\n\n/**\n * Represents an external data file.\n */\nexport interface ExternalDataFileDescription {\n  /**\n   * Specify the external data file.\n   */\n  data: FileType;\n  /**\n   * Specify the file path.\n   */\n  path: string;\n}\n\n/**\n * Represents an external data file.\n *\n * When using a string, it should be a file URL or path that in the same directory as the model file.\n */\nexport type ExternalDataFileType = ExternalDataFileDescription | FileUrlOrPath;\n\n/**\n * Options for model loading.\n */\nexport interface OnnxModelOptions {\n  /**\n   * Specifying a list of files that represents the external data.\n   */\n  externalData?: readonly ExternalDataFileType[];\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Tensor } from './tensor.js';\n\nexport type NonTensorType = never;\n\n/**\n * Type OnnxValue Represents both tensors and non-tensors value for model's inputs/outputs.\n *\n * NOTE: currently not support non-tensor\n */\nexport type OnnxValue = Tensor | NonTensorType;\n\n/**\n * Type OnnxValueDataLocation represents the location of the data of an OnnxValue.\n */\nexport type OnnxValueDataLocation = Tensor.DataLocation;\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n/**\n * # ONNX Runtime JavaScript API\n *\n * ONNX Runtime JavaScript API is a unified API for all JavaScript usages, including the following NPM packages:\n *\n * - [onnxruntime-node](https://www.npmjs.com/package/onnxruntime-node)\n * - [onnxruntime-web](https://www.npmjs.com/package/onnxruntime-web)\n * - [onnxruntime-react-native](https://www.npmjs.com/package/onnxruntime-react-native)\n *\n * See also:\n * - [Get Started](https://onnxruntime.ai/docs/get-started/with-javascript/)\n * - [Inference examples](https://github.com/microsoft/onnxruntime-inference-examples/tree/main/js)\n *\n * @packageDocumentation\n */\n\nexport * from './backend.js';\nexport * from './env.js';\nexport * from './inference-session.js';\nexport * from './tensor.js';\nexport * from './tensor-conversion.js';\nexport * from './tensor-factory.js';\nexport * from './trace.js';\nexport * from './onnx-model.js';\nexport * from './onnx-value.js';\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nexport const isNode = !!(typeof process !== 'undefined' && process.versions && process.versions.node);\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n/// <reference lib=\"webworker\" />\n\n//\n// * type hack for \"HTMLImageElement\"\n//\n// in typescript, the type of \"HTMLImageElement\" is defined in lib.dom.d.ts, which is conflict with lib.webworker.d.ts.\n// when we use webworker, the lib.webworker.d.ts will be used, which does not have HTMLImageElement defined.\n//\n// we will get the following errors complaining that HTMLImageElement is not defined:\n//\n// ====================================================================================================================\n//\n// ../common/dist/cjs/tensor-factory.d.ts:187:29 - error TS2552: Cannot find name 'HTMLImageElement'. Did you mean\n// 'HTMLLIElement'?\n//\n// 187     fromImage(imageElement: HTMLImageElement, options?: TensorFromImageElementOptions):\n// Promise<TypedTensor<'float32'> | TypedTensor<'uint8'>>;\n//                                 ~~~~~~~~~~~~~~~~\n//\n// node_modules/@webgpu/types/dist/index.d.ts:83:7 - error TS2552: Cannot find name 'HTMLImageElement'. Did you mean\n// 'HTMLLIElement'?\n//\n// 83     | HTMLImageElement\n//          ~~~~~~~~~~~~~~~~\n//\n// ====================================================================================================================\n//\n// `HTMLImageElement` is only used in type declaration and not in real code. So we define it as `unknown` here to\n// bypass the type check.\n\n//\n// * type hack for \"document\"\n//\n// in typescript, the type of \"document\" is defined in lib.dom.d.ts, so it's not available in webworker.\n//\n// we will get the following errors complaining that document is not defined:\n//\n// ====================================================================================================================\n//\n// lib/wasm/wasm-utils-import.ts:7:33 - error TS2584: Cannot find name 'document'. Do you need to change your target\n// library? Try changing the 'lib' compiler option to include 'dom'.\n//\n// 7 export const scriptSrc = typeof document !== 'undefined' ? (document?.currentScript as HTMLScriptElement)?.src :\n//                                   ~~~~~~~~\n//\n// lib/wasm/wasm-utils-import.ts:7:61 - error TS2584: Cannot find name 'document'. Do you need to change your target\n// library? Try changing the 'lib' compiler option to include 'dom'.\n//\n// 7 export const scriptSrc = typeof document !== 'undefined' ? (document?.currentScript as HTMLScriptElement)?.src :\n//                                                               ~~~~~~~~\n//\n// lib/wasm/wasm-utils-import.ts:7:88 - error TS2552: Cannot find name 'HTMLScriptElement'. Did you mean\n// 'HTMLLIElement'?\n//\n// 7 export const scriptSrc = typeof document !== 'undefined' ? (document?.currentScript as HTMLScriptElement)?.src :\n//                                                                                          ~~~~~~~~~~~~~~~~~\n// ====================================================================================================================\n//\n// `document` is used to get the current script URL, which is not available in webworker. This file is served as a\n// \"dual\" file for entries of both webworker and the esm module.\n//\ndeclare global {\n  type HTMLImageElement = unknown;\n  type HTMLScriptElement = { src?: string };\n  const document: undefined | { currentScript?: HTMLScriptElement };\n}\n\n/**\n * @summary\n *\n * This file is served as a \"dual\" file for both entries of the following:\n * - The proxy worker itself.\n *   - When used as a worker, it listens to the messages from the main thread and performs the corresponding operations.\n *   - Should be imported directly using `new Worker()` in the main thread.\n *\n * - The ESM module that creates the proxy worker (as a worker launcher).\n *   - When used as a worker launcher, it creates the proxy worker and returns it.\n *   - Should be imported using `import()` in the main thread, with the query parameter `import=1`.\n *\n * This file will be always compiling into ESM format.\n */\n\nimport type { OrtWasmMessage, SerializableTensorMetadata } from '../proxy-messages.js';\nimport {\n  createSession,\n  copyFromExternalBuffer,\n  endProfiling,\n  extractTransferableBuffers,\n  initEp,\n  initRuntime,\n  releaseSession,\n  run,\n} from '../wasm-core-impl.js';\nimport { initializeWebAssembly } from '../wasm-factory.js';\nimport { scriptSrc } from '../wasm-utils-import.js';\n\nconst WORKER_NAME = 'ort-wasm-proxy-worker';\nconst isProxyWorker = globalThis.self?.name === WORKER_NAME;\n\nif (isProxyWorker) {\n  // Worker thread\n  self.onmessage = (ev: MessageEvent<OrtWasmMessage>): void => {\n    const { type, in: message } = ev.data;\n    try {\n      switch (type) {\n        case 'init-wasm':\n          initializeWebAssembly(message!.wasm).then(\n            () => {\n              initRuntime(message!).then(\n                () => {\n                  postMessage({ type });\n                },\n                (err) => {\n                  postMessage({ type, err });\n                },\n              );\n            },\n            (err) => {\n              postMessage({ type, err });\n            },\n          );\n          break;\n        case 'init-ep': {\n          const { epName, env } = message!;\n          initEp(env, epName).then(\n            () => {\n              postMessage({ type });\n            },\n            (err) => {\n              postMessage({ type, err });\n            },\n          );\n          break;\n        }\n        case 'copy-from': {\n          const { buffer } = message!;\n          const bufferData = copyFromExternalBuffer(buffer);\n          postMessage({ type, out: bufferData } as OrtWasmMessage);\n          break;\n        }\n        case 'create': {\n          const { model, options } = message!;\n          createSession(model, options).then(\n            (sessionMetadata) => {\n              postMessage({ type, out: sessionMetadata } as OrtWasmMessage);\n            },\n            (err) => {\n              postMessage({ type, err });\n            },\n          );\n          break;\n        }\n        case 'release':\n          releaseSession(message!);\n          postMessage({ type });\n          break;\n        case 'run': {\n          const { sessionId, inputIndices, inputs, outputIndices, options } = message!;\n          run(sessionId, inputIndices, inputs, outputIndices, new Array(outputIndices.length).fill(null), options).then(\n            (outputs) => {\n              if (outputs.some((o) => o[3] !== 'cpu')) {\n                postMessage({ type, err: 'Proxy does not support non-cpu tensor location.' });\n              } else {\n                postMessage(\n                  { type, out: outputs } as OrtWasmMessage,\n                  extractTransferableBuffers([...inputs, ...outputs] as SerializableTensorMetadata[]),\n                );\n              }\n            },\n            (err) => {\n              postMessage({ type, err });\n            },\n          );\n          break;\n        }\n        case 'end-profiling':\n          endProfiling(message!);\n          postMessage({ type });\n          break;\n        default:\n      }\n    } catch (err) {\n      postMessage({ type, err } as OrtWasmMessage);\n    }\n  };\n}\n\nexport default isProxyWorker\n  ? null\n  : (urlOverride?: string) =>\n      new Worker(urlOverride ?? scriptSrc!, { type: BUILD_DEFS.IS_ESM ? 'module' : 'classic', name: WORKER_NAME });\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport type { OrtWasmModule } from './wasm-types';\nimport { isNode } from './wasm-utils-env';\n\n/**\n * The origin of the current location.\n *\n * In Node.js, this is undefined.\n */\nconst origin = isNode || typeof location === 'undefined' ? undefined : location.origin;\n\n/**\n * Some bundlers (eg. Webpack) will rewrite `import.meta.url` to a file URL at compile time.\n *\n * This function checks if `import.meta.url` starts with `file:`, but using the `>` and `<` operators instead of\n * `startsWith` function so that code minimizers can remove the dead code correctly.\n *\n * For example, if we use terser to minify the following code:\n * ```js\n * if (\"file://hard-coded-filename\".startsWith(\"file:\")) {\n *   console.log(1)\n * } else {\n *   console.log(2)\n * }\n *\n * if (\"file://hard-coded-filename\" > \"file:\" && \"file://hard-coded-filename\" < \"file;\") {\n *   console.log(3)\n * } else {\n *   console.log(4)\n * }\n * ```\n *\n * The minified code will be:\n * ```js\n * \"file://hard-coded-filename\".startsWith(\"file:\")?console.log(1):console.log(2),console.log(3);\n * ```\n *\n * (use Terser 5.39.0 with default options, https://try.terser.org/)\n *\n * @returns true if the import.meta.url is hardcoded as a file URI.\n */\nexport const isEsmImportMetaUrlHardcodedAsFileUri =\n  BUILD_DEFS.IS_ESM && BUILD_DEFS.ESM_IMPORT_META_URL! > 'file:' && BUILD_DEFS.ESM_IMPORT_META_URL! < 'file;';\n\nconst getScriptSrc = (): string | undefined => {\n  // if Nodejs, return undefined\n  if (isNode) {\n    return undefined;\n  }\n  // if It's ESM, use import.meta.url\n  if (BUILD_DEFS.IS_ESM) {\n    // For ESM, if the import.meta.url is a file URL, this usually means the bundler rewrites `import.meta.url` to\n    // the file path at compile time. In this case, this file path cannot be used to determine the runtime URL.\n    //\n    // We need to use the URL constructor like this:\n    // ```js\n    // new URL('actual-bundle-name.js', import.meta.url).href\n    // ```\n    // So that bundler can preprocess the URL correctly.\n    if (isEsmImportMetaUrlHardcodedAsFileUri) {\n      // if the rewritten URL is a relative path, we need to use the origin to resolve the URL.\n\n      // The following is a workaround for Vite.\n      //\n      // Vite uses a bundler(rollup/rolldown) that does not rewrite `import.meta.url` to a file URL. So in theory, this\n      // code path should not be executed in Vite. However, the bundler does not know it and it still try to load the\n      // following pattern:\n      // - `return new URL('filename', import.meta.url).href`\n      //\n      // By replacing the pattern above with the following code, we can skip the resource loading behavior:\n      // - `const URL2 = URL; return new URL2('filename', import.meta.url).href;`\n      //\n      // And it still works in Webpack.\n      const URL2 = URL;\n      return new URL(new URL2(BUILD_DEFS.BUNDLE_FILENAME, BUILD_DEFS.ESM_IMPORT_META_URL).href, origin).href;\n    }\n\n    return BUILD_DEFS.ESM_IMPORT_META_URL;\n  }\n\n  return typeof document !== 'undefined'\n    ? (document.currentScript as HTMLScriptElement)?.src\n    : // use `self.location.href` if available\n      typeof self !== 'undefined'\n      ? self.location?.href\n      : undefined;\n};\n\n/**\n * The classic script source URL. This is not always available in non ESModule environments.\n *\n * In Node.js, this is undefined.\n */\nexport const scriptSrc = getScriptSrc();\n\n/**\n * Infer the wasm path prefix from the script source URL.\n *\n * @returns The inferred wasm path prefix, or undefined if the script source URL is not available or is a blob URL.\n */\nexport const inferWasmPathPrefixFromScriptSrc = (): string | undefined => {\n  if (scriptSrc && !scriptSrc.startsWith('blob:')) {\n    return scriptSrc.substring(0, scriptSrc.lastIndexOf('/') + 1);\n  }\n  return undefined;\n};\n\n/**\n * Check if the given filename with prefix is from the same origin.\n */\nconst isSameOrigin = (filename: string, prefixOverride?: string) => {\n  try {\n    const baseUrl = prefixOverride ?? scriptSrc;\n    const url = baseUrl ? new URL(filename, baseUrl) : new URL(filename);\n    return url.origin === origin;\n  } catch {\n    return false;\n  }\n};\n\n/**\n * Normalize the inputs to an absolute URL with the given prefix override. If failed, return undefined.\n */\nconst normalizeUrl = (filename: string, prefixOverride?: string) => {\n  const baseUrl = prefixOverride ?? scriptSrc;\n  try {\n    const url = baseUrl ? new URL(filename, baseUrl) : new URL(filename);\n    return url.href;\n  } catch {\n    return undefined;\n  }\n};\n\n/**\n * Create a fallback URL if an absolute URL cannot be created by the normalizeUrl function.\n */\nconst fallbackUrl = (filename: string, prefixOverride?: string) => `${prefixOverride ?? './'}${filename}`;\n\n/**\n * This helper function is used to preload a module from a URL.\n *\n * If the origin of the worker URL is different from the current origin, the worker cannot be loaded directly.\n * See discussions in https://github.com/webpack-contrib/worker-loader/issues/154\n *\n * In this case, we will fetch the worker URL and create a new Blob URL with the same origin as a workaround.\n *\n * @param absoluteUrl - The absolute URL to preload.\n *\n * @returns - A promise that resolves to a new Blob URL\n */\nconst preload = async (absoluteUrl: string): Promise<string> => {\n  const response = await fetch(absoluteUrl, { credentials: 'same-origin' });\n  const blob = await response.blob();\n  return URL.createObjectURL(blob);\n};\n\n/**\n * This helper function is used to dynamically import a module from a URL.\n *\n * The build script has special handling for this function to ensure that the URL is not bundled into the final output.\n *\n * @param url - The URL to import.\n *\n * @returns - A promise that resolves to the default export of the module.\n */\nconst dynamicImportDefault = async <T>(url: string): Promise<T> =>\n  (await import(/* webpackIgnore: true */ /* @vite-ignore */ url)).default;\n\n/**\n * The proxy worker factory imported from the proxy worker module.\n *\n * This is only available when the WebAssembly proxy is not disabled.\n */\nconst createProxyWorker: ((urlOverride?: string) => Worker) | undefined =\n  // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires\n  BUILD_DEFS.DISABLE_WASM_PROXY ? undefined : require('./proxy-worker/main').default;\n\n/**\n * Import the proxy worker.\n *\n * This function will perform the following steps:\n * 1. If a preload is needed, it will preload the module and return the object URL.\n * 2. Use the proxy worker factory to create the proxy worker.\n *\n * @returns - A promise that resolves to a tuple of 2 elements:\n *            - The object URL of the preloaded module, or undefined if no preload is needed.\n *            - The proxy worker.\n */\nexport const importProxyWorker = async (): Promise<[undefined | string, Worker]> => {\n  if (!scriptSrc) {\n    throw new Error('Failed to load proxy worker: cannot determine the script source URL.');\n  }\n\n  // If the script source is from the same origin, we can use the embedded proxy module directly.\n  if (isSameOrigin(scriptSrc)) {\n    return [undefined, createProxyWorker!()];\n  }\n\n  // Otherwise, need to preload\n  const url = await preload(scriptSrc);\n  return [url, createProxyWorker!(url)];\n};\n\n/**\n * The embedded WebAssembly module.\n *\n * This is only available in ESM and when embedding is not disabled.\n */\nconst embeddedWasmModule: EmscriptenModuleFactory<OrtWasmModule> | undefined =\n  BUILD_DEFS.IS_ESM && BUILD_DEFS.ENABLE_BUNDLE_WASM_JS\n    ? // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires\n      require(\n        !BUILD_DEFS.DISABLE_JSEP\n          ? '../../dist/ort-wasm-simd-threaded.jsep.mjs'\n          : BUILD_DEFS.ENABLE_JSPI\n            ? '../../dist/ort-wasm-simd-threaded.jspi.mjs'\n            : !BUILD_DEFS.DISABLE_WEBGPU\n              ? '../../dist/ort-wasm-simd-threaded.asyncify.mjs'\n              : '../../dist/ort-wasm-simd-threaded.mjs',\n      ).default\n    : undefined;\n\n/**\n * Import the WebAssembly module.\n *\n * This function will perform the following steps:\n * 1. If the embedded module exists and no custom URL is specified, use the embedded module.\n * 2. If a preload is needed, it will preload the module and return the object URL.\n * 3. Otherwise, it will perform a dynamic import of the module.\n *\n * @returns - A promise that resolves to a tuple of 2 elements:\n *            - The object URL of the preloaded module, or undefined if no preload is needed.\n *            - The default export of the module, which is a factory function to create the WebAssembly module.\n */\nexport const importWasmModule = async (\n  urlOverride: string | undefined,\n  prefixOverride: string | undefined,\n  isMultiThreaded: boolean,\n  isWasmOverridden: boolean,\n): Promise<[undefined | string, EmscriptenModuleFactory<OrtWasmModule>]> => {\n  //\n  // Check if we should use the embedded module.\n  //\n\n  // To use the embedded module, it should be available, and no URL override or prefix override should be specified.\n  let useEmbeddedModule = embeddedWasmModule && !(urlOverride || prefixOverride);\n  if (useEmbeddedModule) {\n    if (!scriptSrc) {\n      // no URL info available.\n      //\n      // Note: when the embedded module is available, it means the current script is ESM. Usually, in ESM, the\n      // `import.meta.url` is available. But in some cases (eg. Cloudflare Workers), the value of `import.meta.url`\n      // can be `null` or `undefined`. In this case, we can only load the embedded module when:\n      //\n      // 1. The WebAssembly module binary is overridden:\n      //    ```js\n      //    env.wasm.wasmPaths = undefined;  // or not specified\n      //    env.wasm.wasmBinary = /* a Uint8Array containing the WebAssembly binary */;\n      //    ```\n      //\n      // 2. The \".wasm\" only is overridden.\n      //    ```js\n      //    env.wasm.wasmPaths = { wasm: /* URL of the .wasm file */ };\n      //    ```\n      //\n      if (isWasmOverridden && !isMultiThreaded) {\n        useEmbeddedModule = true;\n      } else {\n        throw new Error('cannot determine the script source URL.');\n      }\n    } else {\n      // if the script source is available, we can check if it is from the same origin.\n      // Also use the embedded module when wasmBinary is provided and single-threaded (eg. Blob URL workers\n      // where isSameOrigin fails but no file resolution or worker spawning is needed).\n      useEmbeddedModule = isSameOrigin(scriptSrc) || (isWasmOverridden && !isMultiThreaded);\n    }\n  }\n  if (useEmbeddedModule) {\n    return [undefined, embeddedWasmModule!];\n  } else {\n    const wasmModuleFilename = !BUILD_DEFS.DISABLE_JSEP\n      ? 'ort-wasm-simd-threaded.jsep.mjs'\n      : BUILD_DEFS.ENABLE_JSPI\n        ? 'ort-wasm-simd-threaded.jspi.mjs'\n        : !BUILD_DEFS.DISABLE_WEBGPU\n          ? 'ort-wasm-simd-threaded.asyncify.mjs'\n          : 'ort-wasm-simd-threaded.mjs';\n    const wasmModuleUrl = urlOverride ?? normalizeUrl(wasmModuleFilename, prefixOverride);\n    // need to preload if all of the following conditions are met:\n    // 1. not in Node.js.\n    //    - Node.js does not have the same origin policy for creating workers.\n    // 2. multi-threaded is enabled.\n    //    - If multi-threaded is disabled, no worker will be created. So we don't need to preload the module.\n    // 3. the absolute URL is available.\n    //    - If the absolute URL is failed to be created, the origin cannot be determined. In this case, we will not\n    //    preload the module.\n    // 4. the worker URL is not from the same origin.\n    //    - If the worker URL is from the same origin, we can create the worker directly.\n    const needPreload = !isNode && isMultiThreaded && wasmModuleUrl && !isSameOrigin(wasmModuleUrl, prefixOverride);\n    const url = needPreload\n      ? await preload(wasmModuleUrl)\n      : (wasmModuleUrl ?? fallbackUrl(wasmModuleFilename, prefixOverride));\n    return [needPreload ? url : undefined, await dynamicImportDefault<EmscriptenModuleFactory<OrtWasmModule>>(url)];\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Env } from 'onnxruntime-common';\n\nimport type { OrtWasmModule } from './wasm-types';\nimport { importWasmModule, inferWasmPathPrefixFromScriptSrc } from './wasm-utils-import';\n\nlet wasm: OrtWasmModule | undefined;\nlet initialized = false;\nlet initializing = false;\nlet aborted = false;\n\nconst isMultiThreadSupported = (): boolean => {\n  // If 'SharedArrayBuffer' is not available, WebAssembly threads will not work.\n  if (typeof SharedArrayBuffer === 'undefined') {\n    return false;\n  }\n\n  try {\n    // Test for transferability of SABs (for browsers. needed for Firefox)\n    // https://groups.google.com/forum/#!msg/mozilla.dev.platform/IHkBZlHETpA/dwsMNchWEQAJ\n    if (typeof MessageChannel !== 'undefined') {\n      new MessageChannel().port1.postMessage(new SharedArrayBuffer(1));\n    }\n\n    // Test for WebAssembly threads capability (for both browsers and Node.js)\n    // This typed array is a WebAssembly program containing threaded instructions.\n    return WebAssembly.validate(\n      new Uint8Array([\n        0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 4, 1, 3, 1, 1, 10, 11, 1, 9, 0, 65, 0, 254, 16,\n        2, 0, 26, 11,\n      ]),\n    );\n  } catch {\n    return false;\n  }\n};\n\nconst isSimdSupported = (): boolean => {\n  try {\n    // Test for WebAssembly SIMD capability (for both browsers and Node.js)\n    // This typed array is a WebAssembly program containing SIMD instructions.\n\n    // The binary data is generated from the following code by wat2wasm:\n    //\n    // (module\n    //   (type $t0 (func))\n    //   (func $f0 (type $t0)\n    //     (drop\n    //       (i32x4.dot_i16x8_s\n    //         (i8x16.splat\n    //           (i32.const 0))\n    //         (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)))))\n\n    return WebAssembly.validate(\n      new Uint8Array([\n        0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 30, 1, 28, 0, 65, 0, 253, 15, 253, 12, 0, 0, 0,\n        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 253, 186, 1, 26, 11,\n      ]),\n    );\n  } catch {\n    return false;\n  }\n};\n\nconst isRelaxedSimdSupported = (): boolean => {\n  try {\n    // Test for WebAssembly Relaxed SIMD capability (for both browsers and Node.js)\n    // This typed array is a WebAssembly program containing Relaxed SIMD instructions.\n\n    // The binary data is generated from the following code by wat2wasm:\n    // (module\n    //   (func (result v128)\n    //      i32.const 1\n    //      i8x16.splat\n    //      i32.const 2\n    //      i8x16.splat\n    //      i32.const 3\n    //      i8x16.splat\n    //      i32x4.relaxed_dot_i8x16_i7x16_add_s\n    //   )\n    //  )\n    return WebAssembly.validate(\n      new Uint8Array([\n        0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 123, 3, 2, 1, 0, 10, 19, 1, 17, 0, 65, 1, 253, 15, 65, 2, 253,\n        15, 65, 3, 253, 15, 253, 147, 2, 11,\n      ]),\n    );\n  } catch {\n    return false;\n  }\n};\n\nexport const initializeWebAssembly = async (flags: Env.WebAssemblyFlags): Promise<void> => {\n  if (initialized) {\n    return Promise.resolve();\n  }\n  if (initializing) {\n    throw new Error(\"multiple calls to 'initializeWebAssembly()' detected.\");\n  }\n  if (aborted) {\n    throw new Error(\"previous call to 'initializeWebAssembly()' failed.\");\n  }\n\n  initializing = true;\n\n  // wasm flags are already initialized\n  const timeout = flags.initTimeout!;\n  let numThreads = flags.numThreads!;\n\n  // ensure SIMD is supported\n  if (flags.simd === false) {\n    // skip SIMD feature checking as it is disabled explicitly by user\n  } else if (flags.simd === 'relaxed') {\n    // check if relaxed SIMD is supported\n    if (!isRelaxedSimdSupported()) {\n      throw new Error('Relaxed WebAssembly SIMD is not supported in the current environment.');\n    }\n  } else if (!isSimdSupported()) {\n    throw new Error('WebAssembly SIMD is not supported in the current environment.');\n  }\n\n  if (BUILD_DEFS.ENABLE_JSPI) {\n    if (!('Suspending' in WebAssembly)) {\n      throw new Error('WebAssembly JSPI is not supported in the current environment.');\n    }\n  }\n\n  // check if multi-threading is supported\n  const multiThreadSupported = isMultiThreadSupported();\n  if (numThreads > 1 && !multiThreadSupported) {\n    if (typeof self !== 'undefined' && !self.crossOriginIsolated) {\n      // eslint-disable-next-line no-console\n      console.warn(\n        'env.wasm.numThreads is set to ' +\n          numThreads +\n          ', but this will not work unless you enable crossOriginIsolated mode. ' +\n          'See https://web.dev/cross-origin-isolation-guide/ for more info.',\n      );\n    }\n\n    // eslint-disable-next-line no-console\n    console.warn(\n      'WebAssembly multi-threading is not supported in the current environment. ' + 'Falling back to single-threading.',\n    );\n\n    // set flags.numThreads to 1 so that OrtInit() will not create a global thread pool.\n    flags.numThreads = numThreads = 1;\n  }\n\n  const wasmPaths = flags.wasmPaths;\n  const wasmPrefixOverride = typeof wasmPaths === 'string' ? wasmPaths : undefined;\n  const mjsPathOverrideFlag = (wasmPaths as Env.WasmFilePaths)?.mjs;\n  const mjsPathOverride = (mjsPathOverrideFlag as URL)?.href ?? mjsPathOverrideFlag;\n  const wasmPathOverrideFlag = (wasmPaths as Env.WasmFilePaths)?.wasm;\n  const wasmPathOverride = (wasmPathOverrideFlag as URL)?.href ?? wasmPathOverrideFlag;\n  const wasmBinaryOverride = flags.wasmBinary;\n\n  const [objectUrl, ortWasmFactory] = await importWasmModule(\n    mjsPathOverride,\n    wasmPrefixOverride,\n    numThreads > 1,\n    !!wasmBinaryOverride || !!wasmPathOverride,\n  );\n\n  let isTimeout = false;\n\n  const tasks: Array<Promise<void>> = [];\n\n  // promise for timeout\n  if (timeout > 0) {\n    tasks.push(\n      new Promise((resolve) => {\n        setTimeout(() => {\n          isTimeout = true;\n          resolve();\n        }, timeout);\n      }),\n    );\n  }\n\n  // promise for module initialization\n  tasks.push(\n    new Promise((resolve, reject) => {\n      const config: Partial<OrtWasmModule> = {\n        /**\n         * The number of threads. WebAssembly will create (Module.numThreads - 1) workers. If it is 1, no worker will be\n         * created.\n         */\n        numThreads,\n      };\n\n      if (wasmBinaryOverride) {\n        // Set a custom buffer which contains the WebAssembly binary. This will skip the wasm file fetching.\n        config.wasmBinary = wasmBinaryOverride;\n\n        // Offer an implementation of locateFile() that returns the file name directly. This helps to avoid an error\n        // thrown later from the following code when `import.meta.url` is a blob URL:\n        // ```\n        //   return new URL(\"ort-wasm-simd-threaded.jsep.wasm\", import.meta.url).href;\n        // ```\n        config.locateFile = (fileName) => fileName;\n      } else if (wasmPathOverride || wasmPrefixOverride) {\n        // A callback function to locate the WebAssembly file. The function should return the full path of the file.\n        //\n        // Since Emscripten 3.1.58, this function is only called for the .wasm file.\n        config.locateFile = (fileName) => wasmPathOverride ?? wasmPrefixOverride + fileName;\n      } else if (mjsPathOverride && mjsPathOverride.indexOf('blob:') !== 0) {\n        // if mjs path is specified, use it as the base path for the .wasm file.\n        config.locateFile = (fileName) => new URL(fileName, mjsPathOverride).href;\n      } else if (objectUrl) {\n        const inferredWasmPathPrefix = inferWasmPathPrefixFromScriptSrc();\n        if (inferredWasmPathPrefix) {\n          // if the wasm module is preloaded, use the inferred wasm path as the base path for the .wasm file.\n          config.locateFile = (fileName) => inferredWasmPathPrefix + fileName;\n        }\n      }\n\n      ortWasmFactory(config).then(\n        // wasm module initialized successfully\n        (module) => {\n          initializing = false;\n          initialized = true;\n          wasm = module;\n          resolve();\n          if (objectUrl) {\n            URL.revokeObjectURL(objectUrl);\n          }\n        },\n        // wasm module failed to initialize\n        (what) => {\n          initializing = false;\n          aborted = true;\n          reject(what);\n        },\n      );\n    }),\n  );\n\n  await Promise.race(tasks);\n\n  if (isTimeout) {\n    throw new Error(`WebAssembly backend initializing failed due to timeout: ${timeout}ms`);\n  }\n};\n\nexport const getInstance = (): OrtWasmModule => {\n  if (initialized && wasm) {\n    return wasm;\n  }\n\n  throw new Error('WebAssembly is not initialized yet.');\n};\n\nexport const dispose = (): void => {\n  if (initialized && !initializing && !aborted) {\n    // TODO: currently \"PThread.terminateAllThreads()\" is not exposed in the wasm module.\n    //       And this function is not yet called by any code.\n    //       If it is needed in the future, we should expose it in the wasm module and uncomment the following line.\n\n    // wasm?.PThread?.terminateAllThreads();\n    wasm = undefined;\n\n    initializing = false;\n    initialized = false;\n    aborted = true;\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { getInstance } from './wasm-factory';\n\nexport const allocWasmString = (data: string, allocs: number[]): number => {\n  const wasm = getInstance();\n\n  const dataLength = wasm.lengthBytesUTF8(data) + 1;\n  const dataOffset = wasm._malloc(dataLength);\n  wasm.stringToUTF8(data, dataOffset, dataLength);\n  allocs.push(dataOffset);\n\n  return dataOffset;\n};\n\ninterface ExtraOptionsHandler {\n  (name: string, value: string): void;\n}\n\nexport const iterateExtraOptions = (\n  options: Record<string, unknown>,\n  prefix: string,\n  seen: WeakSet<Record<string, unknown>>,\n  handler: ExtraOptionsHandler,\n): void => {\n  if (typeof options == 'object' && options !== null) {\n    if (seen.has(options)) {\n      throw new Error('Circular reference in options');\n    } else {\n      seen.add(options);\n    }\n  }\n\n  Object.entries(options).forEach(([key, value]) => {\n    const name = prefix ? prefix + key : key;\n    if (typeof value === 'object') {\n      iterateExtraOptions(value as Record<string, unknown>, name + '.', seen, handler);\n    } else if (typeof value === 'string' || typeof value === 'number') {\n      handler(name, value.toString());\n    } else if (typeof value === 'boolean') {\n      handler(name, value ? '1' : '0');\n    } else {\n      throw new Error(`Can't handle extra config type: ${typeof value}`);\n    }\n  });\n};\n\n/**\n * check web assembly API's last error and throw error if any error occurred.\n * @param message a message used when an error occurred.\n */\nexport const checkLastError = (message: string): void => {\n  const wasm = getInstance();\n\n  const stack = wasm.stackSave();\n  try {\n    const ptrSize = wasm.PTR_SIZE;\n    const paramsOffset = wasm.stackAlloc(2 * ptrSize);\n    wasm._OrtGetLastError(paramsOffset, paramsOffset + ptrSize);\n    const errorCode = Number(wasm.getValue(paramsOffset, ptrSize === 4 ? 'i32' : 'i64'));\n    const errorMessagePointer = wasm.getValue(paramsOffset + ptrSize, '*');\n    const errorMessage = errorMessagePointer ? wasm.UTF8ToString(errorMessagePointer) : '';\n    throw new Error(`${message} ERROR_CODE: ${errorCode}, ERROR_MESSAGE: ${errorMessage}`);\n  } finally {\n    wasm.stackRestore(stack);\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { InferenceSession } from 'onnxruntime-common';\n\nimport { getInstance } from './wasm-factory';\nimport { allocWasmString, checkLastError, iterateExtraOptions } from './wasm-utils';\n\nexport const setRunOptions = (options: InferenceSession.RunOptions): [number, number[]] => {\n  const wasm = getInstance();\n  let runOptionsHandle = 0;\n  const allocs: number[] = [];\n\n  const runOptions: InferenceSession.RunOptions = options || {};\n\n  try {\n    if (options?.logSeverityLevel === undefined) {\n      runOptions.logSeverityLevel = 2; // Default to warning\n    } else if (\n      typeof options.logSeverityLevel !== 'number' ||\n      !Number.isInteger(options.logSeverityLevel) ||\n      options.logSeverityLevel < 0 ||\n      options.logSeverityLevel > 4\n    ) {\n      throw new Error(`log severity level is not valid: ${options.logSeverityLevel}`);\n    }\n\n    if (options?.logVerbosityLevel === undefined) {\n      runOptions.logVerbosityLevel = 0; // Default to 0\n    } else if (typeof options.logVerbosityLevel !== 'number' || !Number.isInteger(options.logVerbosityLevel)) {\n      throw new Error(`log verbosity level is not valid: ${options.logVerbosityLevel}`);\n    }\n\n    if (options?.terminate === undefined) {\n      runOptions.terminate = false;\n    }\n\n    let tagDataOffset = 0;\n    if (options?.tag !== undefined) {\n      tagDataOffset = allocWasmString(options.tag, allocs);\n    }\n\n    runOptionsHandle = wasm._OrtCreateRunOptions(\n      runOptions.logSeverityLevel!,\n      runOptions.logVerbosityLevel!,\n      !!runOptions.terminate!,\n      tagDataOffset,\n    );\n    if (runOptionsHandle === 0) {\n      checkLastError(\"Can't create run options.\");\n    }\n\n    if (options?.extra !== undefined) {\n      iterateExtraOptions(options.extra, '', new WeakSet<Record<string, unknown>>(), (key, value) => {\n        const keyDataOffset = allocWasmString(key, allocs);\n        const valueDataOffset = allocWasmString(value, allocs);\n\n        if (wasm._OrtAddRunConfigEntry(runOptionsHandle, keyDataOffset, valueDataOffset) !== 0) {\n          checkLastError(`Can't set a run config entry: ${key} - ${value}.`);\n        }\n      });\n    }\n\n    return [runOptionsHandle, allocs];\n  } catch (e) {\n    if (runOptionsHandle !== 0) {\n      wasm._OrtReleaseRunOptions(runOptionsHandle);\n    }\n    allocs.forEach((alloc) => wasm._free(alloc));\n    throw e;\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport type { InferenceSession } from 'onnxruntime-common';\n\nimport { getInstance } from './wasm-factory';\nimport { allocWasmString, checkLastError, iterateExtraOptions } from './wasm-utils';\n\nconst getGraphOptimzationLevel = (graphOptimizationLevel: string | unknown): number => {\n  switch (graphOptimizationLevel) {\n    case 'disabled':\n      return 0;\n    case 'basic':\n      return 1;\n    case 'extended':\n      return 2;\n    case 'layout':\n      return 3;\n    case 'all':\n      return 99;\n    default:\n      throw new Error(`unsupported graph optimization level: ${graphOptimizationLevel}`);\n  }\n};\n\nconst getExecutionMode = (executionMode: 'sequential' | 'parallel'): number => {\n  switch (executionMode) {\n    case 'sequential':\n      return 0;\n    case 'parallel':\n      return 1;\n    default:\n      throw new Error(`unsupported execution mode: ${executionMode}`);\n  }\n};\n\nconst appendDefaultOptions = (options: InferenceSession.SessionOptions): void => {\n  if (!options.extra) {\n    options.extra = {};\n  }\n  if (!options.extra.session) {\n    options.extra.session = {};\n  }\n  const session = options.extra.session as Record<string, string>;\n  if (!session.use_ort_model_bytes_directly) {\n    // eslint-disable-next-line camelcase\n    session.use_ort_model_bytes_directly = '1';\n  }\n\n  // if using JSEP with WebGPU, always disable memory pattern\n  if (\n    options.executionProviders &&\n    options.executionProviders.some((ep) => (typeof ep === 'string' ? ep : ep.name) === 'webgpu')\n  ) {\n    options.enableMemPattern = false;\n  }\n};\n\nconst appendSessionConfig = (sessionOptionsHandle: number, key: string, value: string, allocs: number[]): void => {\n  const keyDataOffset = allocWasmString(key, allocs);\n  const valueDataOffset = allocWasmString(value, allocs);\n  if (getInstance()._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !== 0) {\n    checkLastError(`Can't set a session config entry: ${key} - ${value}.`);\n  }\n};\n\nconst appendEpOption = (epOptions: Array<[number, number]>, key: string, value: string, allocs: number[]): void => {\n  const keyDataOffset = allocWasmString(key, allocs);\n  const valueDataOffset = allocWasmString(value, allocs);\n  epOptions.push([keyDataOffset, valueDataOffset]);\n};\n\nconst setExecutionProviders = async (\n  sessionOptionsHandle: number,\n  sessionOptions: InferenceSession.SessionOptions,\n  allocs: number[],\n): Promise<void> => {\n  const executionProviders = sessionOptions.executionProviders!;\n  for (const ep of executionProviders) {\n    let epName = typeof ep === 'string' ? ep : ep.name;\n    const epOptions: Array<[number, number]> = [];\n\n    // check EP name\n    switch (epName) {\n      case 'webnn':\n        epName = 'WEBNN';\n        // Disable QDQ fusion so DQ/Q nodes are preserved as individual ops for WebNN EP.\n        appendSessionConfig(sessionOptionsHandle, 'session.disable_quant_qdq', '1', allocs);\n        // Forcibly prevent constant folding from replacing DQ nodes with constants.\n        appendSessionConfig(sessionOptionsHandle, 'session.disable_qdq_constant_folding', '1', allocs);\n        if (typeof ep !== 'string') {\n          const webnnOptions = ep as InferenceSession.WebNNExecutionProviderOption;\n          // const context = (webnnOptions as InferenceSession.WebNNOptionsWithMLContext)?.context;\n          const deviceType = (webnnOptions as InferenceSession.WebNNContextOptions)?.deviceType;\n          if (deviceType) {\n            appendSessionConfig(sessionOptionsHandle, 'deviceType', deviceType, allocs);\n          }\n        }\n        break;\n      case 'webgpu':\n        if (!BUILD_DEFS.DISABLE_WEBGPU) {\n          epName = 'WebGPU';\n          let customDevice: GPUDevice | undefined;\n\n          if (typeof ep !== 'string') {\n            const webgpuOptions = ep as InferenceSession.WebGpuExecutionProviderOption;\n\n            // set custom GPU device\n            if (webgpuOptions.device) {\n              if (typeof GPUDevice !== 'undefined' && webgpuOptions.device instanceof GPUDevice) {\n                customDevice = webgpuOptions.device;\n              } else {\n                throw new Error('Invalid GPU device set in WebGPU EP options.');\n              }\n            }\n\n            // set graph capture option from session options\n            const { enableGraphCapture } = sessionOptions;\n            if (typeof enableGraphCapture === 'boolean' && enableGraphCapture) {\n              appendEpOption(epOptions, 'enableGraphCapture', '1', allocs);\n            }\n\n            // set layout option\n            if (typeof webgpuOptions.preferredLayout === 'string') {\n              appendEpOption(epOptions, 'preferredLayout', webgpuOptions.preferredLayout, allocs);\n            }\n\n            // set force CPU fallback nodes\n            if (webgpuOptions.forceCpuNodeNames) {\n              const names = Array.isArray(webgpuOptions.forceCpuNodeNames)\n                ? webgpuOptions.forceCpuNodeNames\n                : [webgpuOptions.forceCpuNodeNames];\n\n              appendEpOption(epOptions, 'forceCpuNodeNames', names.join('\\n'), allocs);\n            }\n\n            // set validation mode\n            if (webgpuOptions.validationMode) {\n              appendEpOption(epOptions, 'validationMode', webgpuOptions.validationMode, allocs);\n            }\n          }\n\n          const info = getInstance().webgpuRegisterDevice!(customDevice);\n          if (info) {\n            const [deviceId, instanceHandle, deviceHandle] = info;\n            appendEpOption(epOptions, 'deviceId', deviceId.toString(), allocs);\n            appendEpOption(epOptions, 'webgpuInstance', instanceHandle.toString(), allocs);\n            appendEpOption(epOptions, 'webgpuDevice', deviceHandle.toString(), allocs);\n          }\n        } else {\n          epName = 'JS';\n          if (typeof ep !== 'string') {\n            const webgpuOptions = ep as InferenceSession.WebGpuExecutionProviderOption;\n            if (webgpuOptions?.preferredLayout) {\n              if (webgpuOptions.preferredLayout !== 'NCHW' && webgpuOptions.preferredLayout !== 'NHWC') {\n                throw new Error(`preferredLayout must be either 'NCHW' or 'NHWC': ${webgpuOptions.preferredLayout}`);\n              }\n              appendSessionConfig(sessionOptionsHandle, 'preferredLayout', webgpuOptions.preferredLayout, allocs);\n            }\n          }\n        }\n        break;\n      case 'wasm':\n      case 'cpu':\n        continue;\n      default:\n        throw new Error(`not supported execution provider: ${epName}`);\n    }\n\n    const epNameDataOffset = allocWasmString(epName, allocs);\n    const epOptionsCount = epOptions.length;\n    let keysOffset = 0;\n    let valuesOffset = 0;\n    if (epOptionsCount > 0) {\n      keysOffset = getInstance()._malloc(epOptionsCount * getInstance().PTR_SIZE);\n      allocs.push(keysOffset);\n      valuesOffset = getInstance()._malloc(epOptionsCount * getInstance().PTR_SIZE);\n      allocs.push(valuesOffset);\n      for (let i = 0; i < epOptionsCount; i++) {\n        getInstance().setValue(keysOffset + i * getInstance().PTR_SIZE, epOptions[i][0], '*');\n        getInstance().setValue(valuesOffset + i * getInstance().PTR_SIZE, epOptions[i][1], '*');\n      }\n    }\n    if (\n      (await getInstance()._OrtAppendExecutionProvider(\n        sessionOptionsHandle,\n        epNameDataOffset,\n        keysOffset,\n        valuesOffset,\n        epOptionsCount,\n      )) !== 0\n    ) {\n      checkLastError(`Can't append execution provider: ${epName}.`);\n    }\n  }\n};\n\nexport const setSessionOptions = async (options?: InferenceSession.SessionOptions): Promise<[number, number[]]> => {\n  const wasm = getInstance();\n  let sessionOptionsHandle = 0;\n  const allocs: number[] = [];\n\n  const sessionOptions: InferenceSession.SessionOptions = options || {};\n  appendDefaultOptions(sessionOptions);\n\n  try {\n    const graphOptimizationLevel = getGraphOptimzationLevel(sessionOptions.graphOptimizationLevel ?? 'all');\n    const executionMode = getExecutionMode(sessionOptions.executionMode ?? 'sequential');\n    const logIdDataOffset =\n      typeof sessionOptions.logId === 'string' ? allocWasmString(sessionOptions.logId, allocs) : 0;\n\n    const logSeverityLevel = sessionOptions.logSeverityLevel ?? 2; // Default to 2 - warning\n    if (!Number.isInteger(logSeverityLevel) || logSeverityLevel < 0 || logSeverityLevel > 4) {\n      throw new Error(`log severity level is not valid: ${logSeverityLevel}`);\n    }\n\n    const logVerbosityLevel = sessionOptions.logVerbosityLevel ?? 0; // Default to 0 - verbose\n    if (!Number.isInteger(logVerbosityLevel) || logVerbosityLevel < 0 || logVerbosityLevel > 4) {\n      throw new Error(`log verbosity level is not valid: ${logVerbosityLevel}`);\n    }\n\n    const optimizedModelFilePathOffset =\n      typeof sessionOptions.optimizedModelFilePath === 'string'\n        ? allocWasmString(sessionOptions.optimizedModelFilePath, allocs)\n        : 0;\n\n    sessionOptionsHandle = wasm._OrtCreateSessionOptions(\n      graphOptimizationLevel,\n      !!sessionOptions.enableCpuMemArena,\n      !!sessionOptions.enableMemPattern,\n      executionMode,\n      !!sessionOptions.enableProfiling,\n      0,\n      logIdDataOffset,\n      logSeverityLevel,\n      logVerbosityLevel,\n      optimizedModelFilePathOffset,\n    );\n    if (sessionOptionsHandle === 0) {\n      checkLastError(\"Can't create session options.\");\n    }\n\n    if (sessionOptions.executionProviders) {\n      await setExecutionProviders(sessionOptionsHandle, sessionOptions, allocs);\n    }\n\n    if (sessionOptions.enableGraphCapture !== undefined) {\n      if (typeof sessionOptions.enableGraphCapture !== 'boolean') {\n        throw new Error(`enableGraphCapture must be a boolean value: ${sessionOptions.enableGraphCapture}`);\n      }\n      appendSessionConfig(\n        sessionOptionsHandle,\n        'enableGraphCapture',\n        sessionOptions.enableGraphCapture.toString(),\n        allocs,\n      );\n    }\n\n    if (sessionOptions.freeDimensionOverrides) {\n      for (const [name, value] of Object.entries(sessionOptions.freeDimensionOverrides)) {\n        if (typeof name !== 'string') {\n          throw new Error(`free dimension override name must be a string: ${name}`);\n        }\n        if (typeof value !== 'number' || !Number.isInteger(value) || value < 0) {\n          throw new Error(`free dimension override value must be a non-negative integer: ${value}`);\n        }\n        const nameOffset = allocWasmString(name, allocs);\n        if (wasm._OrtAddFreeDimensionOverride(sessionOptionsHandle, nameOffset, value) !== 0) {\n          checkLastError(`Can't set a free dimension override: ${name} - ${value}.`);\n        }\n      }\n    }\n\n    if (sessionOptions.extra !== undefined) {\n      iterateExtraOptions(sessionOptions.extra, '', new WeakSet<Record<string, unknown>>(), (key, value) => {\n        appendSessionConfig(sessionOptionsHandle, key, value, allocs);\n      });\n    }\n\n    return [sessionOptionsHandle, allocs];\n  } catch (e) {\n    if (sessionOptionsHandle !== 0) {\n      if (wasm._OrtReleaseSessionOptions(sessionOptionsHandle) !== 0) {\n        checkLastError(\"Can't release session options.\");\n      }\n    }\n    allocs.forEach((alloc) => wasm._free(alloc));\n    throw e;\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Tensor } from 'onnxruntime-common';\n\n// a dummy type declaration for Float16Array in case any polyfill is available.\ndeclare global {\n  // eslint-disable-next-line @typescript-eslint/naming-convention, @typescript-eslint/no-explicit-any\n  const Float16Array: any;\n}\n\n// This file includes common definitions. They do NOT have dependency on the WebAssembly instance.\n\n/**\n * Copied from ONNX definition. Use this to drop dependency 'onnx_proto' to decrease compiled .js file size.\n */\nexport const enum DataType {\n  undefined = 0,\n  float = 1,\n  uint8 = 2,\n  int8 = 3,\n  uint16 = 4,\n  int16 = 5,\n  int32 = 6,\n  int64 = 7,\n  string = 8,\n  bool = 9,\n  float16 = 10,\n  double = 11,\n  uint32 = 12,\n  uint64 = 13,\n  complex64 = 14,\n  complex128 = 15,\n  bfloat16 = 16,\n\n  // 4-bit data-types\n  uint4 = 21,\n  int4 = 22,\n}\n\n/**\n * Map string tensor data to enum value\n */\nexport const tensorDataTypeStringToEnum = (type: string): DataType => {\n  switch (type) {\n    case 'int8':\n      return DataType.int8;\n    case 'uint8':\n      return DataType.uint8;\n    case 'bool':\n      return DataType.bool;\n    case 'int16':\n      return DataType.int16;\n    case 'uint16':\n      return DataType.uint16;\n    case 'int32':\n      return DataType.int32;\n    case 'uint32':\n      return DataType.uint32;\n    case 'float16':\n      return DataType.float16;\n    case 'float32':\n      return DataType.float;\n    case 'float64':\n      return DataType.double;\n    case 'string':\n      return DataType.string;\n    case 'int64':\n      return DataType.int64;\n    case 'uint64':\n      return DataType.uint64;\n    case 'int4':\n      return DataType.int4;\n    case 'uint4':\n      return DataType.uint4;\n\n    default:\n      throw new Error(`unsupported data type: ${type}`);\n  }\n};\n\n/**\n * Map enum value to string tensor data\n */\nexport const tensorDataTypeEnumToString = (typeProto: DataType): Tensor.Type => {\n  switch (typeProto) {\n    case DataType.int8:\n      return 'int8';\n    case DataType.uint8:\n      return 'uint8';\n    case DataType.bool:\n      return 'bool';\n    case DataType.int16:\n      return 'int16';\n    case DataType.uint16:\n      return 'uint16';\n    case DataType.int32:\n      return 'int32';\n    case DataType.uint32:\n      return 'uint32';\n    case DataType.float16:\n      return 'float16';\n    case DataType.float:\n      return 'float32';\n    case DataType.double:\n      return 'float64';\n    case DataType.string:\n      return 'string';\n    case DataType.int64:\n      return 'int64';\n    case DataType.uint64:\n      return 'uint64';\n    case DataType.int4:\n      return 'int4';\n    case DataType.uint4:\n      return 'uint4';\n\n    default:\n      throw new Error(`unsupported data type: ${typeProto}`);\n  }\n};\n\n/**\n * get tensor size in bytes by the given data type and dimensions\n * @returns size in integer or undefined if the data type is not supported\n */\nexport const calculateTensorSizeInBytes = (\n  dateType: number,\n  dimsOrSize: readonly number[] | number,\n): number | undefined => {\n  const elementSize = [\n    -1, // undefined = 0\n    4, // float = 1\n    1, // uint8 = 2\n    1, // int8 = 3\n    2, // uint16 = 4\n    2, // int16 = 5\n    4, // int32 = 6\n    8, // int64 = 7\n    -1, // string = 8\n    1, // bool = 9\n    2, // float16 = 10\n    8, // double = 11\n    4, // uint32 = 12\n    8, // uint64 = 13\n    -1, // complex64 = 14\n    -1, // complex128 = 15\n    -1, // bfloat16 = 16\n    -1, // FLOAT8E4M3FN = 17\n    -1, // FLOAT8E4M3FNUZ = 18\n    -1, // FLOAT8E5M2 = 19\n    -1, // FLOAT8E5M2FNUZ = 20\n    0.5, // uint4 = 21\n    0.5, // int4 = 22\n  ][dateType];\n\n  const size = typeof dimsOrSize === 'number' ? dimsOrSize : dimsOrSize.reduce((a, b) => a * b, 1);\n  return elementSize > 0 ? Math.ceil(size * elementSize) : undefined;\n};\n\n/**\n * get typed array constructor by the given tensor type\n */\nexport const tensorTypeToTypedArrayConstructor = (\n  type: Tensor.Type,\n):\n  | Float32ArrayConstructor\n  | Uint8ArrayConstructor\n  | Int8ArrayConstructor\n  | Uint16ArrayConstructor\n  | Int16ArrayConstructor\n  | Int32ArrayConstructor\n  | BigInt64ArrayConstructor\n  | Uint8ArrayConstructor\n  | Float64ArrayConstructor\n  | Uint32ArrayConstructor\n  | BigUint64ArrayConstructor => {\n  switch (type) {\n    case 'float16':\n      // allow Float16Array polyfill.\n      return typeof Float16Array !== 'undefined' && Float16Array.from ? Float16Array : Uint16Array;\n    case 'float32':\n      return Float32Array;\n    case 'uint8':\n      return Uint8Array;\n    case 'int8':\n      return Int8Array;\n    case 'uint16':\n      return Uint16Array;\n    case 'int16':\n      return Int16Array;\n    case 'int32':\n      return Int32Array;\n    case 'bool':\n      return Uint8Array;\n    case 'float64':\n      return Float64Array;\n    case 'uint32':\n      return Uint32Array;\n    case 'int64':\n      return BigInt64Array;\n    case 'uint64':\n      return BigUint64Array;\n    default:\n      throw new Error(`unsupported type: ${type}`);\n  }\n};\n\n/**\n * Map string log level to integer value\n */\nexport const logLevelStringToEnum = (logLevel?: 'verbose' | 'info' | 'warning' | 'error' | 'fatal'): number => {\n  switch (logLevel) {\n    case 'verbose':\n      return 0;\n    case 'info':\n      return 1;\n    case 'warning':\n      return 2;\n    case 'error':\n      return 3;\n    case 'fatal':\n      return 4;\n    default:\n      throw new Error(`unsupported logging level: ${logLevel}`);\n  }\n};\n\n/**\n * Check whether the given tensor type is supported by GPU buffer\n */\nexport const isGpuBufferSupportedType = (type: Tensor.Type): type is Tensor.GpuBufferDataTypes =>\n  type === 'float32' ||\n  type === 'float16' ||\n  type === 'int32' ||\n  type === 'int64' ||\n  type === 'uint32' ||\n  type === 'uint8' ||\n  type === 'bool' ||\n  type === 'uint4' ||\n  type === 'int4';\n\n/**\n * Check whether the given tensor type is supported by WebNN MLTensor\n */\nexport const isMLTensorSupportedType = (type: Tensor.Type): type is Tensor.MLTensorDataTypes =>\n  type === 'float32' ||\n  type === 'float16' ||\n  type === 'int32' ||\n  type === 'int64' ||\n  type === 'uint32' ||\n  type === 'uint64' ||\n  type === 'int8' ||\n  type === 'uint8' ||\n  type === 'bool' ||\n  type === 'uint4' ||\n  type === 'int4';\n\n/**\n * Map string data location to integer value\n */\nexport const dataLocationStringToEnum = (location: Tensor.DataLocation): number => {\n  switch (location) {\n    case 'none':\n      return 0;\n    case 'cpu':\n      return 1;\n    case 'cpu-pinned':\n      return 2;\n    case 'texture':\n      return 3;\n    case 'gpu-buffer':\n      return 4;\n    case 'ml-tensor':\n      return 5;\n    default:\n      throw new Error(`unsupported data location: ${location}`);\n  }\n};\n\n/**\n * Map integer data location to string value\n */\nexport const dataLocationEnumToString = (location: number): Tensor.DataLocation | undefined =>\n  (['none', 'cpu', 'cpu-pinned', 'texture', 'gpu-buffer', 'ml-tensor'] as const)[location];\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { isNode } from './wasm-utils-env';\n\n/**\n * Load a file into a Uint8Array.\n *\n * @param file - the file to load. Can be a URL/path, a Blob, an ArrayBuffer, or a Uint8Array.\n * @returns a Uint8Array containing the file data.\n */\nexport const loadFile = async (file: string | Blob | ArrayBufferLike | Uint8Array): Promise<Uint8Array> => {\n  if (typeof file === 'string') {\n    if (isNode) {\n      // load file into ArrayBuffer in Node.js\n      try {\n        const { readFile } = require('node:fs/promises');\n        return new Uint8Array(await readFile(file));\n      } catch (e) {\n        if (e.code === 'ERR_FS_FILE_TOO_LARGE') {\n          // file is too large, use fs.createReadStream instead\n          const { createReadStream } = require('node:fs');\n          const stream = createReadStream(file);\n          const chunks: Uint8Array[] = [];\n          for await (const chunk of stream) {\n            chunks.push(chunk);\n          }\n          return new Uint8Array(Buffer.concat(chunks));\n        }\n        throw e;\n      }\n    } else {\n      // load file into ArrayBuffer in browsers\n      const response = await fetch(file);\n      if (!response.ok) {\n        throw new Error(`failed to load external data file: ${file}`);\n      }\n      const contentLengthHeader = response.headers.get('Content-Length');\n      const fileSize = contentLengthHeader ? parseInt(contentLengthHeader, 10) : 0;\n      if (fileSize < 1073741824 /* 1GB */) {\n        // when Content-Length header is not set, we cannot determine the file size. We assume it is small enough to\n        // load into memory.\n        return new Uint8Array(await response.arrayBuffer());\n      } else {\n        // file is too large, use stream instead\n        if (!response.body) {\n          throw new Error(`failed to load external data file: ${file}, no response body.`);\n        }\n        const reader = response.body.getReader();\n\n        let buffer;\n        try {\n          // try to create ArrayBuffer directly\n          buffer = new ArrayBuffer(fileSize);\n        } catch (e) {\n          if (e instanceof RangeError) {\n            // use WebAssembly Memory to allocate larger ArrayBuffer\n            const pages = Math.ceil(fileSize / 65536);\n            buffer = new WebAssembly.Memory({ initial: pages, maximum: pages }).buffer;\n          } else {\n            throw e;\n          }\n        }\n\n        let offset = 0;\n        while (true) {\n          const { done, value } = await reader.read();\n          if (done) {\n            break;\n          }\n          const chunkSize = value.byteLength;\n          const chunk = new Uint8Array(buffer, offset, chunkSize);\n          chunk.set(value);\n          offset += chunkSize;\n        }\n        return new Uint8Array(buffer, 0, fileSize);\n      }\n    }\n  } else if (file instanceof Blob) {\n    return new Uint8Array(await file.arrayBuffer());\n  } else if (file instanceof Uint8Array) {\n    return file;\n  } else {\n    return new Uint8Array(file);\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Tensor } from 'onnxruntime-common';\n\nimport { tensorTypeToTypedArrayConstructor } from '../wasm-common';\n\nexport const createView = (\n  dataBuffer: ArrayBuffer,\n  type: Tensor.Type,\n):\n  | Int32Array\n  | Uint32Array\n  | BigInt64Array\n  | BigUint64Array\n  | Uint8Array\n  | Float32Array\n  | Float64Array\n  | Int8Array\n  | Int16Array\n  | Uint16Array => new (tensorTypeToTypedArrayConstructor(type))(dataBuffer);\n\n/**\n * a TensorView does not own the data.\n */\nexport interface TensorView {\n  readonly data: number;\n  readonly dataType: number;\n  readonly dims: readonly number[];\n\n  /**\n   * get a Float16Array data view of the tensor data. tensor data must be on CPU.\n   */\n  getUint16Array(): Uint16Array;\n\n  /**\n   * get a Float32Array data view of the tensor data. tensor data must be on CPU.\n   */\n  getFloat32Array(): Float32Array;\n\n  /**\n   * get a BigInt64Array data view of the tensor data. tensor data must be on CPU.\n   */\n  getBigInt64Array(): BigInt64Array;\n\n  /**\n   * get a Int32Array data view of the tensor data. tensor data must be on CPU.\n   */\n  getInt32Array(): Int32Array;\n\n  /**\n   * get a Uint16Array data view of the tensor data. tensor data must be on CPU.\n   */\n  getUint16Array(): Uint16Array;\n\n  /**\n   * create a new tensor view with the same data but different dimensions.\n   */\n  reshape(newDims: readonly number[]): TensorView;\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Env } from 'onnxruntime-common';\n\nimport { logLevelStringToEnum } from '../wasm-common';\n\ntype LogLevel = NonNullable<Env['logLevel']>;\ntype MessageString = string;\ntype MessageFunction = () => string;\ntype Message = MessageString | MessageFunction;\n\nconst logLevelPrefix = ['V', 'I', 'W', 'E', 'F'];\n\nconst doLog = (level: number, message: string): void => {\n  // eslint-disable-next-line no-console\n  console.log(`[${logLevelPrefix[level]},${new Date().toISOString()}]${message}`);\n};\n\nlet configLogLevel: LogLevel | undefined;\nlet debug: boolean | undefined;\n\nexport const configureLogger = ($configLogLevel: LogLevel, $debug: boolean): void => {\n  configLogLevel = $configLogLevel;\n  debug = $debug;\n};\n\n/**\n * A simple logging utility to log messages to the console.\n */\nexport const LOG = (logLevel: LogLevel, msg: Message): void => {\n  const messageLevel = logLevelStringToEnum(logLevel);\n  const configLevel = logLevelStringToEnum(configLogLevel);\n  if (messageLevel >= configLevel) {\n    doLog(messageLevel, typeof msg === 'function' ? msg() : msg);\n  }\n};\n\n/**\n * A simple logging utility to log messages to the console. Only logs when debug is enabled.\n */\nexport const LOG_DEBUG: typeof LOG = (...args: Parameters<typeof LOG>) => {\n  if (debug) {\n    LOG(...args);\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { WebNNBackend } from '../backend-webnn';\nimport { tensorTypeToTypedArrayConstructor } from '../../wasm-common';\nimport { LOG_DEBUG } from '../log';\n\n// WebNN API currently does not have a TypeScript definition file. This file is a workaround with types generated from\n// WebNN API specification.\n// https://github.com/webmachinelearning/webnn/issues/677\n/// <reference path=\"webnn.d.ts\" />\n\n/**\n * Map from MLOperandDataType to size in bits. Using bits instead of bytes to avoid possible precision loss on int4 and uint4.\n */\nconst webnnDataTypeToSize = new Map<MLOperandDataType, number>([\n  ['float32', 32],\n  ['float16', 16],\n  ['int32', 32],\n  ['uint32', 32],\n  ['int64', 64],\n  ['uint64', 64],\n  ['int8', 8],\n  ['uint8', 8],\n  ['int4', 4],\n  ['uint4', 4],\n]);\n\n// Convert integer data to an Int32Array buffer.\n// Supports conversion from int64, uint64, uint32, int8 and uint8 to int32.\nexport const convertDataToInt32 = (data: Uint8Array, dataType: MLOperandDataType): Uint8Array => {\n  if (dataType === 'int32') {\n    return data;\n  }\n\n  const dataTypeSize = webnnDataTypeToSize.get(dataType);\n  if (!dataTypeSize) {\n    throw new Error(`WebNN backend does not support data type: ${dataType}`);\n  }\n  const bytesPerElement = dataTypeSize / 8;\n  // Make sure the data length is a multiple of the data type size.\n  if (data.byteLength % bytesPerElement !== 0) {\n    throw new Error(`Invalid Uint8Array length - must be a multiple of ${bytesPerElement}.`);\n  }\n\n  // Convert Uint8Array to original typed array.\n  const numElements = data.byteLength / bytesPerElement;\n  const originalArray = new (tensorTypeToTypedArrayConstructor(dataType))(data.buffer, data.byteOffset, numElements);\n\n  switch (dataType) {\n    case 'int64':\n    case 'uint64': {\n      // Convert original typed array to Int32Array.\n      const int32Array = new Int32Array(numElements);\n      for (let i = 0; i < numElements; i++) {\n        const value = originalArray[i];\n\n        // Check for overflow.\n        if (value > 2147483647n || value < -2147483648n) {\n          throw new Error(`Can not convert int64 data to int32 - value out of range.`);\n        }\n\n        int32Array[i] = Number(value);\n      }\n\n      return new Uint8Array(int32Array.buffer);\n    }\n    case 'int8':\n    case 'uint8':\n    case 'uint32': {\n      // Check for overflow.\n      if (dataType === 'uint32') {\n        if (originalArray.some((value) => value > 2147483647)) {\n          throw new Error(`Can not convert uint32 data to int32 - value out of range.`);\n        }\n      }\n      // Convert original typed array to Int32Array.\n      const int32Array = Int32Array.from(originalArray, Number);\n      return new Uint8Array(int32Array.buffer);\n    }\n    default:\n      throw new Error(`Unsupported data conversion from ${dataType} to 'int32'`);\n  }\n};\n\n// Convert Int32Array data to original integer data buffer.\n// Supports conversion from int32 to int64, uint64, uint32, int8 and uint8.\nexport const convertInt32ToData = (data: Uint8Array, dataType: MLOperandDataType): Uint8Array => {\n  if (dataType === 'int32') {\n    return data;\n  }\n\n  // Make sure the data length is a multiple of 4 bytes (Int32Array).\n  if (data.byteLength % 4 !== 0) {\n    throw new Error('Invalid Uint8Array length - must be a multiple of 4 (int32).');\n  }\n\n  // Convert Uint8Array to Int32Array.\n  const numElements = data.byteLength / 4;\n  const int32Array = new Int32Array(data.buffer, data.byteOffset, numElements);\n\n  switch (dataType) {\n    case 'int64': {\n      const bigInt64Array = BigInt64Array.from(int32Array, BigInt);\n      return new Uint8Array(bigInt64Array.buffer);\n    }\n    case 'uint64': {\n      if (int32Array.some((value) => value < 0)) {\n        throw new Error('Can not convert int32 data to uin64 - negative value found.');\n      }\n      const bigUint64Array = BigUint64Array.from(int32Array, BigInt);\n      return new Uint8Array(bigUint64Array.buffer);\n    }\n    case 'int8': {\n      if (int32Array.some((value) => value < -128 || value > 127)) {\n        throw new Error('Can not convert int32 data to int8 - value out of range.');\n      }\n      const int8Array = Int8Array.from(int32Array, Number);\n      return new Uint8Array(int8Array.buffer);\n    }\n    case 'uint8': {\n      if (int32Array.some((value) => value < 0 || value > 255)) {\n        throw new Error('Can not convert int32 data to uint8 - value out of range.');\n      }\n      return Uint8Array.from(int32Array, Number);\n    }\n    case 'uint32': {\n      if (int32Array.some((value) => value < 0)) {\n        throw new Error('Can not convert int32 data to uint32 - negative value found.');\n      }\n      const uint32Array = Uint32Array.from(int32Array, Number);\n      return new Uint8Array(uint32Array.buffer);\n    }\n    default:\n      throw new Error(`Unsupported data conversion from 'int32' to ${dataType}`);\n  }\n};\n\nexport type TensorId = number;\n\n/**\n * Manages TensorId to MLTensor mapping.\n */\nexport interface TensorManager {\n  /**\n   * Reserve a new TensorId.\n   */\n  reserveTensorId(): TensorId;\n  /**\n   * Release a TensorId.\n   */\n  releaseTensorId(tensorId: TensorId): void;\n  /**\n   * Ensure a MLTensor is created for the TensorId.\n   */\n  ensureTensor(\n    sessionId: number,\n    tensorId: TensorId,\n    dataType: MLOperandDataType,\n    shape: readonly number[],\n    copyOld: boolean,\n  ): Promise<MLTensor>;\n  /**\n   * Upload data to a MLTensor.\n   */\n  upload(tensorId: TensorId, data: Uint8Array): void;\n  /**\n   * Download data from a MLTensor.\n   */\n  download(tensorId: TensorId): Promise<ArrayBuffer>;\n  download(tensorId: TensorId, dstTensor: ArrayBufferView | ArrayBuffer): Promise<undefined>;\n  /**\n   * Release all tensors for a given session.\n   */\n  releaseTensorsForSession(session: number): void;\n  /**\n   * Register an externally created MLTensor with a given session id and return a TensorId.\n   */\n  registerTensor(sessionId: number, mlTensor: MLTensor, dataType: MLOperandDataType, shape: number[]): TensorId;\n}\n\nlet tensorGuid = 1;\nconst createNewTensorId = (): TensorId => tensorGuid++;\n\n/**\n * Map from data type to fallback data type.\n * When the context does not support the original data type, use fallback data type as workaround.\n * Note: Currently, we only support fallback to int32 for certain integer data types.\n */\nconst webnnDataTypeToFallback = new Map<MLOperandDataType, MLOperandDataType>([\n  ['int8', 'int32'],\n  ['uint8', 'int32'],\n  ['uint32', 'int32'],\n  ['int64', 'int32'],\n]);\n\n/**\n * Calculate the byte length of a tensor with the given data type and shape.\n */\nconst calculateByteLength = (dataType: MLOperandDataType, shape: readonly number[]): number => {\n  const dataTypeSize = webnnDataTypeToSize.get(dataType);\n  if (!dataTypeSize) {\n    throw new Error(`WebNN backend does not support data type: ${dataType}`);\n  }\n  return shape.length > 0 ? Math.ceil((shape.reduce((a, b) => a * b) * dataTypeSize) / 8) : 0;\n};\n\n/**\n * TensorWrapper wraps an MLTensor and provides a way to track the last session that used it.\n */\nclass TensorWrapper {\n  // The id of the last session that used this tensor.\n  public sessionId: number;\n  // This flag is used to indicate whether the data has been converted to fallback data type.\n  public isDataConverted = false;\n\n  private mlContext: MLContext;\n  private mlTensor: MLTensor;\n  private dataType: MLOperandDataType;\n  // Fallback data type to use when the context does not support the original data type.\n  private fallbackDataType: MLOperandDataType | undefined;\n  private tensorShape: readonly number[];\n\n  constructor(descriptor: {\n    sessionId: number;\n    context: MLContext;\n    tensor: MLTensor;\n    dataType: MLOperandDataType;\n    shape: readonly number[];\n    fallbackDataType?: MLOperandDataType;\n  }) {\n    const { sessionId, context, tensor, dataType, shape, fallbackDataType } = descriptor;\n    this.sessionId = sessionId;\n    this.mlContext = context;\n    this.mlTensor = tensor;\n    this.dataType = dataType;\n    this.tensorShape = shape;\n    this.fallbackDataType = fallbackDataType;\n  }\n\n  public get tensor(): MLTensor {\n    return this.mlTensor;\n  }\n\n  public get type(): MLOperandDataType {\n    return this.dataType;\n  }\n\n  public get fallbackType(): MLOperandDataType | undefined {\n    return this.fallbackDataType;\n  }\n\n  public get shape(): readonly number[] {\n    return this.tensorShape;\n  }\n\n  public get byteLength(): number {\n    return calculateByteLength(this.dataType, this.tensorShape);\n  }\n\n  public destroy(): void {\n    LOG_DEBUG('verbose', () => '[WebNN] TensorWrapper.destroy');\n    this.mlTensor.destroy();\n  }\n\n  public write(data: Uint8Array): void {\n    this.mlContext.writeTensor(this.mlTensor, data);\n  }\n\n  public async read(): Promise<ArrayBuffer>;\n  public async read(dstBuffer?: ArrayBufferView | ArrayBuffer): Promise<ArrayBuffer | undefined>;\n  public async read(dstBuffer?: ArrayBufferView | ArrayBuffer): Promise<ArrayBuffer | undefined> {\n    if (this.fallbackDataType) {\n      // This tensor has been fallback to int32 as workaround, we need to read it as its original integer data type.\n      const data = await this.mlContext.readTensor(this.mlTensor);\n      const originalData = convertInt32ToData(new Uint8Array(data), this.dataType);\n\n      if (dstBuffer) {\n        const targetBuffer =\n          dstBuffer instanceof ArrayBuffer\n            ? new Uint8Array(dstBuffer)\n            : new Uint8Array(dstBuffer.buffer, dstBuffer.byteOffset, dstBuffer.byteLength);\n        targetBuffer.set(originalData);\n        return undefined;\n      } else {\n        return originalData.buffer;\n      }\n    } else {\n      return dstBuffer ? this.mlContext.readTensor(this.mlTensor, dstBuffer) : this.mlContext.readTensor(this.mlTensor);\n    }\n  }\n\n  public canReuseTensor(context: MLContext, dataType: MLOperandDataType, shape: readonly number[]): boolean {\n    return (\n      this.mlContext === context &&\n      this.dataType === dataType &&\n      this.tensorShape.length === shape.length &&\n      this.tensorShape.every((v, i) => v === shape[i])\n    );\n  }\n\n  public setIsDataConverted(isConverted: boolean): void {\n    this.isDataConverted = isConverted;\n  }\n}\n\n/**\n * TensorTracker tracks the MLTensor and pending upload data.\n *\n * We need to track the MLTensor and pending upload data because we delay the creation of MLTensor until\n * we know the data type and shape. This is because WebNN only support creating MLTensors with dataTypes and shape.\n */\nclass TensorIdTracker {\n  private activeUpload?: Uint8Array;\n\n  constructor(\n    private tensorManager: TensorManagerImpl,\n    private wrapper?: TensorWrapper,\n  ) {}\n\n  public get tensorWrapper(): TensorWrapper | undefined {\n    return this.wrapper;\n  }\n\n  public releaseTensor(): void {\n    if (this.tensorWrapper) {\n      this.tensorManager.releaseTensor(this.tensorWrapper);\n      this.wrapper = undefined;\n    }\n  }\n\n  public async ensureTensor(\n    sessionId: number,\n    dataType: MLOperandDataType,\n    shape: readonly number[],\n    copyOld: boolean,\n  ): Promise<MLTensor> {\n    const context = this.tensorManager.getMLContext(sessionId);\n    const opLimits = this.tensorManager.getMLOpSupportLimits(sessionId);\n    let fallbackDataType: MLOperandDataType | undefined;\n    // Check if the context supports the data type. If not, try to use the fallback data type.\n    if (!opLimits?.input.dataTypes.includes(dataType)) {\n      fallbackDataType = webnnDataTypeToFallback.get(dataType);\n      if (!fallbackDataType || opLimits?.input.dataTypes.includes(fallbackDataType)) {\n        throw new Error(`WebNN backend does not support data type: ${dataType}`);\n      }\n      LOG_DEBUG(\n        'verbose',\n        () => `[WebNN] TensorIdTracker.ensureTensor: fallback dataType from ${dataType} to ${fallbackDataType}`,\n      );\n    }\n\n    if (this.wrapper) {\n      if (this.wrapper.canReuseTensor(context, dataType, shape)) {\n        return this.wrapper.tensor;\n      } else {\n        if (copyOld) {\n          if (this.wrapper.byteLength !== calculateByteLength(dataType, shape)) {\n            throw new Error('Unable to copy data to tensor with different size.');\n          }\n          this.activeUpload = new Uint8Array(await this.wrapper.read());\n        }\n        this.tensorManager.releaseTensor(this.wrapper);\n      }\n    }\n\n    // eslint-disable-next-line no-bitwise\n    const usage = typeof MLTensorUsage == 'undefined' ? undefined : MLTensorUsage.READ | MLTensorUsage.WRITE;\n    this.wrapper = await this.tensorManager.getCachedTensor(\n      sessionId,\n      dataType,\n      shape,\n      usage,\n      true,\n      true,\n      fallbackDataType,\n    );\n\n    if (copyOld && this.activeUpload) {\n      // We don't need to convert the original integer data to int32,\n      // because it has been converted when it was uploaded.\n      this.wrapper.write(this.activeUpload);\n      this.activeUpload = undefined;\n    }\n\n    return this.wrapper.tensor;\n  }\n\n  public upload(data: Uint8Array): void {\n    let newData = data;\n    if (this.wrapper) {\n      if (this.wrapper.fallbackType) {\n        if (this.wrapper.fallbackType === 'int32') {\n          // Convert original integer data to int32.\n          newData = convertDataToInt32(data, this.wrapper.type);\n          this.wrapper.setIsDataConverted(true);\n        } else {\n          throw new Error(`Unsupported fallback data type: ${this.wrapper.fallbackType}`);\n        }\n      }\n\n      // Check if the data size matches the tensor size.\n      if (data.byteLength === this.wrapper.byteLength) {\n        // Write the newData to the tensor.\n        this.wrapper.write(newData);\n        return;\n      } else {\n        LOG_DEBUG('verbose', () => 'Data size does not match tensor size. Releasing tensor.');\n        this.releaseTensor();\n      }\n    }\n\n    if (this.activeUpload) {\n      this.activeUpload.set(newData);\n    } else {\n      this.activeUpload = new Uint8Array(newData);\n    }\n  }\n\n  public async download(dstBuffer?: ArrayBufferView | ArrayBuffer): Promise<ArrayBuffer | undefined> {\n    if (this.activeUpload) {\n      // If this.activeUpload has been converted to int32, we need to convert it back to original integer data type.\n      const dstData = this.wrapper?.isDataConverted\n        ? convertInt32ToData(this.activeUpload, this.wrapper?.type)\n        : this.activeUpload;\n\n      if (dstBuffer) {\n        if (dstBuffer instanceof ArrayBuffer) {\n          new Uint8Array(dstBuffer).set(dstData);\n        } else {\n          new Uint8Array(dstBuffer.buffer, dstBuffer.byteOffset, dstBuffer.byteLength).set(dstData);\n        }\n        return;\n      } else {\n        return dstData.buffer;\n      }\n    }\n    if (!this.wrapper) {\n      throw new Error('Tensor has not been created.');\n    }\n\n    if (!dstBuffer) {\n      return this.wrapper.read();\n    }\n    return this.wrapper.read(dstBuffer);\n  }\n}\n\nclass TensorManagerImpl implements TensorManager {\n  private tensorTrackersById: Map<TensorId, TensorIdTracker> = new Map();\n  private freeTensors: TensorWrapper[] = [];\n  private externalTensors: Set<TensorWrapper> = new Set();\n\n  constructor(private backend: WebNNBackend) {}\n\n  public getMLContext(sessionId: number): MLContext {\n    const context = this.backend.getMLContext(sessionId);\n    if (!context) {\n      throw new Error('MLContext not found for session.');\n    }\n    return context;\n  }\n\n  public getMLOpSupportLimits(sessionId: number): MLOpSupportLimits | undefined {\n    return this.backend.getMLOpSupportLimits(sessionId);\n  }\n\n  public reserveTensorId(): TensorId {\n    const tensorId = createNewTensorId();\n    this.tensorTrackersById.set(tensorId, new TensorIdTracker(this));\n    return tensorId;\n  }\n\n  public releaseTensorId(tensorId: TensorId): void {\n    const tensorTracker = this.tensorTrackersById.get(tensorId);\n    if (!tensorTracker) {\n      return;\n    }\n    this.tensorTrackersById.delete(tensorId);\n    if (tensorTracker.tensorWrapper) {\n      this.releaseTensor(tensorTracker.tensorWrapper);\n    }\n  }\n\n  public async ensureTensor(\n    sessionId: number,\n    tensorId: TensorId,\n    dataType: MLOperandDataType,\n    shape: number[],\n    copyOld: boolean,\n  ): Promise<MLTensor> {\n    LOG_DEBUG(\n      'verbose',\n      () =>\n        `[WebNN] TensorManager.ensureTensor {tensorId: ${tensorId}, dataType: ${\n          dataType\n        }, shape: ${shape}, copyOld: ${copyOld}}`,\n    );\n    const tensor = this.tensorTrackersById.get(tensorId);\n    if (!tensor) {\n      throw new Error('Tensor not found.');\n    }\n    return tensor.ensureTensor(sessionId, dataType, shape, copyOld);\n  }\n\n  public upload(tensorId: TensorId, data: Uint8Array): void {\n    const tensor = this.tensorTrackersById.get(tensorId);\n    if (!tensor) {\n      throw new Error('Tensor not found.');\n    }\n    tensor.upload(data);\n  }\n\n  public async download(tensorId: TensorId): Promise<ArrayBuffer>;\n  public async download(tensorId: TensorId, dstBuffer: ArrayBufferView | ArrayBuffer): Promise<undefined>;\n  async download(tensorId: TensorId, dstBuffer?: ArrayBufferView | ArrayBuffer): Promise<ArrayBuffer | undefined> {\n    LOG_DEBUG(\n      'verbose',\n      () => `[WebNN] TensorManager.download {tensorId: ${tensorId}, dstBuffer: ${dstBuffer?.byteLength}}`,\n    );\n    const tensorTracker = this.tensorTrackersById.get(tensorId);\n    if (!tensorTracker) {\n      throw new Error('Tensor not found.');\n    }\n    return tensorTracker.download(dstBuffer);\n  }\n\n  public releaseTensorsForSession(sessionId: number): void {\n    for (const tensor of this.freeTensors) {\n      if (tensor.sessionId === sessionId) {\n        tensor.destroy();\n      }\n    }\n    this.freeTensors = this.freeTensors.filter((tensor) => tensor.sessionId !== sessionId);\n  }\n\n  public registerTensor(\n    sessionId: number,\n    mlTensor: MLTensor,\n    dataType: MLOperandDataType,\n    shape: readonly number[],\n  ): TensorId {\n    const context = this.getMLContext(sessionId);\n    const tensorId = createNewTensorId();\n    // Defaulting to READ | WRITE if usage is not provided.\n    const wrapper = new TensorWrapper({\n      sessionId,\n      context,\n      tensor: mlTensor,\n      dataType,\n      shape,\n    });\n    this.tensorTrackersById.set(tensorId, new TensorIdTracker(this, wrapper));\n    this.externalTensors.add(wrapper);\n    return tensorId;\n  }\n\n  /**\n   * Get or create an MLTensor with the given data type and shape.\n   */\n  public async getCachedTensor(\n    sessionId: number,\n    dataType: MLOperandDataType,\n    shape: readonly number[],\n    usage: MLTensorUsageFlags | undefined,\n    writable: boolean,\n    readable: boolean,\n    fallbackDataType?: MLOperandDataType,\n  ): Promise<TensorWrapper> {\n    const context = this.getMLContext(sessionId);\n    for (const [index, tensor] of this.freeTensors.entries()) {\n      if (tensor.canReuseTensor(context, dataType, shape)) {\n        LOG_DEBUG(\n          'verbose',\n          () =>\n            `[WebNN] Reusing tensor {dataType: ${dataType}, ${\n              fallbackDataType ? `fallbackDataType: ${fallbackDataType},` : ''\n            } shape: ${shape}`,\n        );\n        const wrapper = this.freeTensors.splice(index, 1)[0];\n        wrapper.sessionId = sessionId;\n        return wrapper;\n      }\n    }\n    LOG_DEBUG(\n      'verbose',\n      () =>\n        `[WebNN] MLContext.createTensor {dataType: ${dataType}, ${\n          fallbackDataType ? `fallbackDataType: ${fallbackDataType},` : ''\n        } shape: ${shape}}`,\n    );\n    const tensor = await context.createTensor({\n      dataType: fallbackDataType ?? dataType, // If fallback data type is provided, use it.\n      shape,\n      dimensions: shape,\n      usage,\n      writable,\n      readable,\n    });\n    return new TensorWrapper({ sessionId, context, tensor, dataType, shape, fallbackDataType });\n  }\n\n  /**\n   * Release tensor for reuse unless external.\n   */\n  public releaseTensor(tensorWrapper: TensorWrapper) {\n    if (this.externalTensors.has(tensorWrapper)) {\n      this.externalTensors.delete(tensorWrapper);\n    }\n    this.freeTensors.push(tensorWrapper);\n  }\n}\n\nexport const createTensorManager = (...args: ConstructorParameters<typeof TensorManagerImpl>): TensorManager =>\n  new TensorManagerImpl(...args);\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n// WebNN API currently does not have a TypeScript definition file. This file is a workaround with types generated from\n// WebNN API specification.\n// https://github.com/webmachinelearning/webnn/issues/677\n/// <reference path=\"webnn/webnn.d.ts\" />\n\nimport { Env, Tensor } from 'onnxruntime-common';\n\nimport { DataType, tensorDataTypeStringToEnum } from '../wasm-common';\nimport { getInstance } from '../wasm-factory';\n\nimport { createView } from './tensor-view';\nimport { TensorId, createTensorManager, convertDataToInt32 } from './webnn/tensor-manager';\nimport { configureLogger, LOG_DEBUG } from './log';\n\n/*\n * TensorProto::data_type to WebNN OperandType mapping.\n */\nconst onnxDataTypeToWebnnDataType = new Map<DataType, MLOperandDataType>([\n  [DataType.float, 'float32'],\n  [DataType.float16, 'float16'],\n  [DataType.int32, 'int32'],\n  [DataType.uint32, 'uint32'],\n  [DataType.int64, 'int64'],\n  [DataType.uint64, 'uint64'],\n  [DataType.int4, 'int4'],\n  [DataType.uint4, 'uint4'],\n  [DataType.int8, 'int8'],\n  [DataType.uint8, 'uint8'],\n  [DataType.bool, 'uint8'],\n]);\n\ntype MLContextEntry = {\n  gpuDevice?: GPUDevice;\n  options?: MLContextOptions;\n  mlContext: MLContext;\n};\n\nconst compareMLContextOptions = (a?: MLContextOptions, b?: MLContextOptions): boolean => {\n  if (a === b) {\n    return true;\n  }\n  if (a === undefined || b === undefined) {\n    return false;\n  }\n  const aKeys = Object.keys(a).sort() as Array<keyof typeof a>;\n  const bKeys = Object.keys(b).sort() as Array<keyof typeof b>;\n  return aKeys.length === bKeys.length && aKeys.every((key, index) => key === bKeys[index] && a[key] === b[key]);\n};\n\n/**\n * WebNN backend implementation. This class is used to keep track of the MLTensors created by the backend and keep track\n * of the current MLContext being used by the sessions.\n */\nexport class WebNNBackend {\n  /**\n   * Tensor managers for each session.\n   */\n  private tensorManager = createTensorManager(this);\n  /**\n   * Maps from session id to MLContexts.\n   */\n  private mlContextBySessionId = new Map<number, MLContext>();\n  /**\n   * Maps from MLContext to session ids.\n   */\n  private sessionIdsByMLContext = new Map<MLContext, Set<number>>();\n  /**\n   * Cache of MLContexts.\n   */\n  private mlContextCache: MLContextEntry[] = [];\n  /**\n   * Current session id.\n   */\n  private activeSessionId?: number;\n  /**\n   * Maps from session id to list of graph inputs.\n   */\n  private sessionGraphInputs: Map<number, string[]> = new Map();\n  /**\n   * Maps from session id to list of graph outputs.\n   */\n  private sessionGraphOutputs: Map<number, string[]> = new Map();\n  /**\n   * Temporary graph inputs for the current session.\n   * These inputs will be registered when the session is created.\n   */\n  private temporaryGraphInputs: string[] = [];\n  /**\n   * Temporary graph outputs for the current session.\n   * These outputs will be registered when the session is created.\n   */\n  private temporaryGraphOutputs: string[] = [];\n  /**\n   * Temporary tensors for the current session.\n   */\n  private temporarySessionTensorIds: Map<number, TensorId[]> = new Map();\n  /**\n   * Maps from session id to MLOpSupportLimits.\n   */\n  private mlOpSupportLimitsBySessionId = new Map<number, MLOpSupportLimits>();\n\n  constructor(env: Env) {\n    configureLogger(env.logLevel!, !!env.debug);\n  }\n\n  public get currentSessionId(): number {\n    if (this.activeSessionId === undefined) {\n      throw new Error('No active session');\n    }\n    return this.activeSessionId;\n  }\n\n  public onRunStart(sessionId: number): void {\n    LOG_DEBUG('verbose', () => `[WebNN] onRunStart {sessionId: ${sessionId}}`);\n    this.activeSessionId = sessionId;\n  }\n\n  public onRunEnd(sessionId: number): void {\n    LOG_DEBUG('verbose', () => `[WebNN] onRunEnd {sessionId: ${sessionId}}`);\n    const tensorIds = this.temporarySessionTensorIds.get(sessionId);\n    if (!tensorIds) {\n      return;\n    }\n    for (const tensorId of tensorIds) {\n      LOG_DEBUG('verbose', () => `[WebNN] releasing temporary tensor {tensorId: ${tensorId}}`);\n      this.tensorManager.releaseTensorId(tensorId);\n    }\n    this.temporarySessionTensorIds.delete(sessionId);\n    this.activeSessionId = undefined;\n  }\n\n  public async createMLContext(optionsOrDevice?: MLContextOptions | GPUDevice): Promise<MLContext> {\n    if (optionsOrDevice instanceof GPUDevice) {\n      const mlContextIndex = this.mlContextCache.findIndex((entry) => entry.gpuDevice === optionsOrDevice);\n      if (mlContextIndex !== -1) {\n        return this.mlContextCache[mlContextIndex].mlContext;\n      } else {\n        const mlContext = await navigator.ml.createContext(optionsOrDevice);\n        this.mlContextCache.push({ gpuDevice: optionsOrDevice, mlContext });\n        return mlContext;\n      }\n    } else if (optionsOrDevice === undefined) {\n      const mlContextIndex = this.mlContextCache.findIndex(\n        (entry) => entry.options === undefined && entry.gpuDevice === undefined,\n      );\n      if (mlContextIndex !== -1) {\n        return this.mlContextCache[mlContextIndex].mlContext;\n      } else {\n        const mlContext = await navigator.ml.createContext();\n        this.mlContextCache.push({ mlContext });\n        return mlContext;\n      }\n    }\n\n    const mlContextIndex = this.mlContextCache.findIndex((entry) =>\n      compareMLContextOptions(entry.options, optionsOrDevice),\n    );\n    if (mlContextIndex !== -1) {\n      return this.mlContextCache[mlContextIndex].mlContext;\n    } else {\n      const mlContext = await navigator.ml.createContext(optionsOrDevice);\n      this.mlContextCache.push({ options: optionsOrDevice, mlContext });\n      return mlContext;\n    }\n  }\n\n  public registerMLContext(sessionId: number, mlContext: MLContext): void {\n    this.mlContextBySessionId.set(sessionId, mlContext);\n    let sessionIds = this.sessionIdsByMLContext.get(mlContext);\n    if (!sessionIds) {\n      sessionIds = new Set();\n      this.sessionIdsByMLContext.set(mlContext, sessionIds);\n    }\n    sessionIds.add(sessionId);\n\n    if (!this.mlOpSupportLimitsBySessionId.has(sessionId)) {\n      this.mlOpSupportLimitsBySessionId.set(sessionId, mlContext.opSupportLimits());\n    }\n\n    if (this.temporaryGraphInputs.length > 0) {\n      this.sessionGraphInputs.set(sessionId, this.temporaryGraphInputs);\n      this.temporaryGraphInputs = [];\n    }\n    if (this.temporaryGraphOutputs.length > 0) {\n      this.sessionGraphOutputs.set(sessionId, this.temporaryGraphOutputs);\n      this.temporaryGraphOutputs = [];\n    }\n  }\n\n  public onReleaseSession(sessionId: number): void {\n    this.sessionGraphInputs.delete(sessionId);\n    this.sessionGraphOutputs.delete(sessionId);\n    const mlContext = this.mlContextBySessionId.get(sessionId)!;\n    if (!mlContext) {\n      // Current session is not a WebNN session.\n      return;\n    }\n    this.tensorManager.releaseTensorsForSession(sessionId);\n    this.mlContextBySessionId.delete(sessionId);\n    this.mlOpSupportLimitsBySessionId.delete(sessionId);\n    const sessionIds = this.sessionIdsByMLContext.get(mlContext)!;\n    sessionIds.delete(sessionId);\n    if (sessionIds.size === 0) {\n      this.sessionIdsByMLContext.delete(mlContext);\n      const mlContextIndex = this.mlContextCache.findIndex((entry) => entry.mlContext === mlContext);\n      if (mlContextIndex !== -1) {\n        this.mlContextCache.splice(mlContextIndex, 1);\n      }\n    }\n  }\n\n  public getMLContext(sessionId: number): MLContext | undefined {\n    return this.mlContextBySessionId.get(sessionId);\n  }\n\n  public getMLOpSupportLimits(sessionId: number): MLOpSupportLimits | undefined {\n    return this.mlOpSupportLimitsBySessionId.get(sessionId);\n  }\n\n  public reserveTensorId(): TensorId {\n    return this.tensorManager.reserveTensorId();\n  }\n\n  public releaseTensorId(tensorId: TensorId): void {\n    LOG_DEBUG('verbose', () => `[WebNN] releaseTensorId {tensorId: ${tensorId}}`);\n    this.tensorManager.releaseTensorId(tensorId);\n  }\n\n  public async ensureTensor(\n    sessionId: number | undefined,\n    tensorId: TensorId,\n    onnxDataType: DataType,\n    dimensions: number[],\n    copyOld: boolean,\n  ): Promise<MLTensor> {\n    const webnnDataType = onnxDataTypeToWebnnDataType.get(onnxDataType);\n    if (!webnnDataType) {\n      throw new Error(`Unsupported ONNX data type: ${onnxDataType}`);\n    }\n    return this.tensorManager.ensureTensor(\n      sessionId ?? this.currentSessionId,\n      tensorId,\n      webnnDataType,\n      dimensions,\n      copyOld,\n    );\n  }\n\n  public async createTemporaryTensor(\n    sessionId: number,\n    onnxDataType: DataType,\n    shape: readonly number[],\n  ): Promise<TensorId> {\n    LOG_DEBUG('verbose', () => `[WebNN] createTemporaryTensor {onnxDataType: ${onnxDataType}, shape: ${shape}}`);\n    const dataType = onnxDataTypeToWebnnDataType.get(onnxDataType);\n    if (!dataType) {\n      throw new Error(`Unsupported ONNX data type: ${onnxDataType}`);\n    }\n    const tensorId = this.tensorManager.reserveTensorId();\n    await this.tensorManager.ensureTensor(sessionId, tensorId, dataType, shape, false);\n    const tensorIds = this.temporarySessionTensorIds.get(sessionId);\n    if (!tensorIds) {\n      this.temporarySessionTensorIds.set(sessionId, [tensorId]);\n    } else {\n      tensorIds.push(tensorId);\n    }\n    return tensorId;\n  }\n\n  public uploadTensor(tensorId: TensorId, data: Uint8Array): void {\n    const wasm = getInstance();\n    if (!wasm.shouldTransferToMLTensor) {\n      throw new Error('Trying to upload to a MLTensor while shouldTransferToMLTensor is false');\n    }\n    LOG_DEBUG('verbose', () => `[WebNN] uploadTensor {tensorId: ${tensorId}, data: ${data.byteLength}}`);\n    this.tensorManager.upload(tensorId, data);\n  }\n\n  public async downloadTensor(tensorId: TensorId, dstBuffer: ArrayBufferView | ArrayBuffer): Promise<undefined> {\n    return this.tensorManager.download(tensorId, dstBuffer);\n  }\n\n  public createMLTensorDownloader(tensorId: TensorId, type: Tensor.MLTensorDataTypes): () => Promise<Tensor.DataType> {\n    return async () => {\n      const data = await this.tensorManager.download(tensorId);\n      return createView(data, type);\n    };\n  }\n\n  public registerMLTensor(sessionId: number, tensor: MLTensor, onnxDataType: DataType, dimensions: number[]): TensorId {\n    const webnnDataType = onnxDataTypeToWebnnDataType.get(onnxDataType);\n    if (!webnnDataType) {\n      throw new Error(`Unsupported ONNX data type: ${onnxDataType}`);\n    }\n\n    const id = this.tensorManager.registerTensor(sessionId, tensor, webnnDataType, dimensions);\n    LOG_DEBUG(\n      'verbose',\n      () =>\n        `[WebNN] registerMLTensor {tensor: ${tensor}, dataType: ${webnnDataType}, dimensions: ${\n          dimensions\n        }} -> {tensorId: ${id}}`,\n    );\n    return id;\n  }\n\n  // Register a WebNN Constant operand from external data.\n  public registerMLConstant(\n    externalFilePath: string,\n    dataOffset: number,\n    dataLength: number,\n    builder: MLGraphBuilder,\n    desc: MLOperandDescriptor,\n    mountedFiles: Map<string, Uint8Array> | undefined,\n    shouldConvertInt64ToInt32 = false,\n  ): MLOperand {\n    // If available, \"Module.MountedFiles\" is a Map for all preloaded files.\n    if (!mountedFiles) {\n      throw new Error('External mounted files are not available.');\n    }\n\n    let filePath = externalFilePath;\n    if (externalFilePath.startsWith('./')) {\n      filePath = externalFilePath.substring(2);\n    }\n    const fileData = mountedFiles.get(filePath);\n    if (!fileData) {\n      throw new Error(`File with name ${filePath} not found in preloaded files.`);\n    }\n\n    if (dataOffset + dataLength > fileData.byteLength) {\n      throw new Error('Out of bounds: data offset and length exceed the external file data size.');\n    }\n\n    const buffer = fileData.slice(dataOffset, dataOffset + dataLength).buffer;\n    let bufferView: ArrayBufferView;\n    switch (desc.dataType) {\n      case 'float32':\n        bufferView = new Float32Array(buffer);\n        break;\n      case 'float16':\n        bufferView =\n          typeof Float16Array !== 'undefined' && Float16Array.from ? new Float16Array(buffer) : new Uint16Array(buffer);\n        break;\n      case 'int32':\n        bufferView = new Int32Array(buffer);\n        break;\n      case 'uint32':\n        bufferView = new Uint32Array(buffer);\n        break;\n      case 'int64':\n        if (shouldConvertInt64ToInt32) {\n          // Int64 is not supported by current context, use int32 instead.\n          const int32Buffer = convertDataToInt32(new Uint8Array(buffer), 'int64');\n          bufferView = new Int32Array(int32Buffer.buffer);\n          desc.dataType = 'int32';\n        } else {\n          bufferView = new BigInt64Array(buffer);\n        }\n        break;\n      case 'uint64':\n        bufferView = new BigUint64Array(buffer);\n        break;\n      case 'int8':\n        bufferView = new Int8Array(buffer);\n        break;\n      case 'int4':\n      case 'uint4':\n      case 'uint8':\n        bufferView = new Uint8Array(buffer);\n        break;\n      default:\n        throw new Error(`Unsupported data type: ${desc.dataType} in creating WebNN Constant from external data.`);\n    }\n\n    LOG_DEBUG(\n      'verbose',\n      () =>\n        `[WebNN] registerMLConstant {dataType: ${desc.dataType}, shape: ${desc.shape}}} ${\n          shouldConvertInt64ToInt32 ? '(Note: it was int64 data type and registered to int32 as workaround)' : ''\n        }`,\n    );\n\n    return builder.constant(desc, bufferView);\n  }\n\n  public registerGraphInput(inputName: string): void {\n    this.temporaryGraphInputs.push(inputName);\n  }\n\n  public registerGraphOutput(outputName: string): void {\n    this.temporaryGraphOutputs.push(outputName);\n  }\n\n  public isGraphInput(sessionId: number, inputName: string): boolean {\n    const inputNames = this.sessionGraphInputs.get(sessionId);\n    if (!inputNames) {\n      return false;\n    }\n    return inputNames.includes(inputName);\n  }\n\n  public isGraphOutput(sessionId: number, outputName: string): boolean {\n    const outputNames = this.sessionGraphOutputs.get(sessionId);\n    if (!outputNames) {\n      return false;\n    }\n    return outputNames.includes(outputName);\n  }\n\n  public isGraphInputOutputTypeSupported(sessionId: number, type: Tensor.Type, isInput = true): boolean {\n    const dataType = onnxDataTypeToWebnnDataType.get(tensorDataTypeStringToEnum(type));\n    const opLimits = this.mlOpSupportLimitsBySessionId.get(sessionId);\n\n    if (typeof dataType === 'undefined') {\n      return false;\n    }\n\n    if (isInput) {\n      return !!opLimits?.input.dataTypes.includes(dataType);\n    } else {\n      return !!opLimits?.output.dataTypes.includes(dataType);\n    }\n  }\n\n  public flush(): void {\n    // Unlike the WebGPU backend, the WebNN backend does not need to flush any pending operations.\n  }\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n// WebNN API currently does not have a TypeScript definition file. This file is a workaround with types generated from\n// WebNN API specification.\n// https://github.com/webmachinelearning/webnn/issues/677\n/// <reference path=\"jsep/webnn/webnn.d.ts\" />\n\nimport { Env, InferenceSession, Tensor, TRACE_EVENT_BEGIN, TRACE_EVENT_END } from 'onnxruntime-common';\n\nimport {\n  SerializableInternalBuffer,\n  SerializableSessionMetadata,\n  SerializableTensorMetadata,\n  TensorMetadata,\n} from './proxy-messages';\nimport { setRunOptions } from './run-options';\nimport { setSessionOptions } from './session-options';\nimport {\n  calculateTensorSizeInBytes,\n  dataLocationStringToEnum,\n  isGpuBufferSupportedType,\n  isMLTensorSupportedType,\n  logLevelStringToEnum,\n  tensorDataTypeEnumToString,\n  tensorDataTypeStringToEnum,\n  tensorTypeToTypedArrayConstructor,\n} from './wasm-common';\nimport { getInstance } from './wasm-factory';\nimport { allocWasmString, checkLastError } from './wasm-utils';\nimport { loadFile } from './wasm-utils-load-file';\n\n// #region Initializations\n\n/**\n * There are 4 different \"initialization\" steps for ORT. They happen in different places and different time.\n *\n * 1. JavaScript initialization for onnxruntime-common and onnxruntime-web.\n *    This is the first initialization step. In this step, onnxruntime-web calls onnxruntime-common's registerBackend()\n * function multiple times to register all the available backends. The backend registration is very fast. It only\n * registers the backend name with the uninitialized backend object. No heavy initialization is done in this step.\n *    Refer to web/lib/index.ts for the backend registration.\n *\n * 2. WebAssembly artifact initialization.\n *    This happens when any registered wasm backend is used for the first time (ie. `ort.InferenceSession.create()` is\n * called). In this step, onnxruntime-web does the followings:\n *     - create a proxy worker and make sure the proxy worker is ready to receive messages, if proxy is enabled.\n *     - perform feature detection, locate correct WebAssembly artifact path and call the Emscripten generated\n * JavaScript code to initialize the WebAssembly runtime.\n *         - if proxy is enabled, this step happens in the proxy worker using message 'init-wasm'.\n *         - downloading the 'ort-wasm{...}.wasm' file is done in this step.\n *         - if multi-thread is enabled, one or more webworker will be created to initialize the PThread threadpool.\n *\n * 3. ORT environment initialization.\n *    This happens after step 2. In this step, onnxruntime-web performs ONNX Runtime environment initialization.\n * Function `_OrtInit()` is called in this step.\n *     - if proxy is enabled, this step happens in the proxy worker using message 'init-ort'.\n *     - logging level (ort.env.logLevel) and thread number (ort.env.wasm.numThreads) are set in this step.\n *\n * 4. Session initialization.\n *    This happens when `ort.InferenceSession.create()` is called. Unlike the first 3 steps (they only called once),\n * this step will be done for each session. In this step, onnxruntime-web does the followings:\n *    If the parameter is a URL:\n *    - download the model data from the URL.\n *    - copy the model data to the WASM heap. (proxy: 'copy-from')\n *    - dereference the model buffer. This step allows the original ArrayBuffer to be garbage collected.\n *    - call `_OrtCreateSession()` to create the session. (proxy: 'create')\n *\n *    If the parameter is a Uint8Array object:\n *    - copy the model data to the WASM heap. (proxy: 'copy-from')\n *    - call `_OrtCreateSession()` to create the session. (proxy: 'create')\n *\n *\n */\n\n/**\n * initialize ORT environment.\n *\n * @param numThreads SetGlobalIntraOpNumThreads(numThreads)\n * @param loggingLevel CreateEnv(static_cast<OrtLoggingLevel>(logging_level))\n */\nconst initOrt = (numThreads: number, loggingLevel: number): void => {\n  const errorCode = getInstance()._OrtInit(numThreads, loggingLevel);\n  if (errorCode !== 0) {\n    checkLastError(\"Can't initialize onnxruntime.\");\n  }\n};\n\n/**\n * initialize runtime environment.\n * @param env passed in the environment config object.\n */\nexport const initRuntime = async (env: Env): Promise<void> => {\n  // init ORT\n  initOrt(env.wasm.numThreads!, logLevelStringToEnum(env.logLevel));\n};\n\n/**\n * perform EP specific initialization.\n *\n * @param env\n * @param epName\n */\nexport const initEp = async (env: Env, epName: string): Promise<void> => {\n  // initialize ASYNCIFY support\n  getInstance().asyncInit?.();\n\n  // perform WebGPU availability check ( either JSEP or WebGPU EP )\n  let webgpuAdapter = env.webgpu.adapter as GPUAdapter | null;\n  if (epName === 'webgpu') {\n    if (typeof navigator === 'undefined' || !navigator.gpu) {\n      throw new Error('WebGPU is not supported in current environment');\n    }\n    if (!webgpuAdapter) {\n      // if adapter is not set, request a new adapter.\n      const powerPreference = env.webgpu.powerPreference;\n      if (powerPreference !== undefined && powerPreference !== 'low-power' && powerPreference !== 'high-performance') {\n        throw new Error(`Invalid powerPreference setting: \"${powerPreference}\"`);\n      }\n      const forceFallbackAdapter = env.webgpu.forceFallbackAdapter;\n      if (forceFallbackAdapter !== undefined && typeof forceFallbackAdapter !== 'boolean') {\n        throw new Error(`Invalid forceFallbackAdapter setting: \"${forceFallbackAdapter}\"`);\n      }\n      webgpuAdapter = await navigator.gpu.requestAdapter({ powerPreference, forceFallbackAdapter });\n      if (!webgpuAdapter) {\n        throw new Error(\n          'Failed to get GPU adapter. ' +\n            'You may need to enable flag \"--enable-unsafe-webgpu\" if you are using Chrome.',\n        );\n      }\n    } else {\n      // if adapter is set, validate it.\n      if (\n        typeof webgpuAdapter.limits !== 'object' ||\n        typeof webgpuAdapter.features !== 'object' ||\n        typeof webgpuAdapter.requestDevice !== 'function'\n      ) {\n        throw new Error('Invalid GPU adapter set in `env.webgpu.adapter`. It must be a GPUAdapter object.');\n      }\n    }\n  }\n\n  // perform WebNN availability check ( either JSEP or WebNN EP )\n  if (epName === 'webnn') {\n    if (typeof navigator === 'undefined' || !(navigator as unknown as { ml: unknown }).ml) {\n      throw new Error('WebNN is not supported in current environment');\n    }\n  }\n\n  if (!BUILD_DEFS.DISABLE_JSEP) {\n    // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires\n    const initJsep = require('./jsep/init').init;\n\n    if (epName === 'webgpu') {\n      await initJsep('webgpu', getInstance(), env, webgpuAdapter);\n    }\n    if (epName === 'webnn') {\n      await initJsep('webnn', getInstance(), env);\n    }\n  } else {\n    if (!BUILD_DEFS.DISABLE_WEBGPU && epName === 'webgpu') {\n      getInstance().webgpuInit!((device) => {\n        env.webgpu.device = device;\n      });\n    }\n    if (!BUILD_DEFS.DISABLE_WEBNN && epName === 'webnn') {\n      // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires\n      const backend = new (require('./jsep/backend-webnn').WebNNBackend)(env);\n      getInstance().webnnInit!([\n        backend,\n        // webnnReserveTensorId\n        () => backend.reserveTensorId(),\n        // webnnReleaseTensorId,\n        (tensorId: number) => backend.releaseTensorId(tensorId),\n        // webnnEnsureTensor\n        async (sessionId: number | undefined, tensorId: number, onnxDataType: number, shape: number[], copyOld) =>\n          backend.ensureTensor(sessionId, tensorId, onnxDataType, shape, copyOld),\n        // webnnUploadTensor\n        (tensorId: number, data: Uint8Array) => {\n          backend.uploadTensor(tensorId, data);\n        },\n        // webnnDownloadTensor\n        async (tensorId: number, dstBuffer: ArrayBufferView | ArrayBuffer) =>\n          backend.downloadTensor(tensorId, dstBuffer),\n        // webnnRegisterMLContext\n        (sessionId: number, mlContext: MLContext) => backend.registerMLContext(sessionId, mlContext),\n        // webnnEnableTraceEvent\n        !!env.trace,\n      ]);\n    }\n  }\n};\n\n// #endregion Initializations\n\n/**\n * valid data locations for input/output tensors.\n */\ntype SupportedTensorDataLocationForInputOutput =\n  | 'cpu'\n  | 'cpu-pinned'\n  | 'gpu-buffer'\n  | 'ml-tensor'\n  // Use 'ml-tensor' during inference, but output a tensor located on the CPU.\n  | 'ml-tensor-cpu-output';\n\ntype IOBindingState = {\n  /**\n   * the handle of IO binding.\n   */\n  readonly handle: number;\n\n  /**\n   * the preferred location for each output tensor.\n   *\n   * value is one of 'cpu', 'cpu-pinned', 'gpu-buffer', 'ml-tensor'.\n   */\n  readonly outputPreferredLocations: readonly SupportedTensorDataLocationForInputOutput[];\n\n  /**\n   * enum value of the preferred location for each output tensor.\n   */\n  readonly outputPreferredLocationsEncoded: readonly number[];\n};\n\n/**\n *  tuple elements are: InferenceSession ID; inputNamesUTF8Encoded; outputNamesUTF8Encoded; bindingState\n */\ntype SessionMetadata = [\n  inferenceSessionId: number,\n  inputNamesUTF8Encoded: number[],\n  outputNamesUTF8Encoded: number[],\n  bindingState: IOBindingState | null,\n  enableGraphCapture: boolean,\n  inputOutputBound: boolean,\n];\n\nconst activeSessions = new Map<number, SessionMetadata>();\n\n/**\n * get the input/output count of the session.\n * @param sessionHandle the handle representing the session. should be non-zero.\n * @returns a tuple including 2 numbers, representing the input count and output count.\n */\nconst getSessionInputOutputCount = (sessionHandle: number): [number, number] => {\n  const wasm = getInstance();\n  const stack = wasm.stackSave();\n  try {\n    const ptrSize = wasm.PTR_SIZE;\n    const dataOffset = wasm.stackAlloc(2 * ptrSize);\n    const errorCode = wasm._OrtGetInputOutputCount(sessionHandle, dataOffset, dataOffset + ptrSize);\n    if (errorCode !== 0) {\n      checkLastError(\"Can't get session input/output count.\");\n    }\n    const type = ptrSize === 4 ? 'i32' : 'i64';\n    return [Number(wasm.getValue(dataOffset, type)), Number(wasm.getValue(dataOffset + ptrSize, type))];\n  } finally {\n    wasm.stackRestore(stack);\n  }\n};\n\nconst getSessionInputOutputMetadata = (\n  sessionHandle: number,\n  index: number,\n): [nameOffset: number, elementType: number, dims?: Array<number | string>] => {\n  const wasm = getInstance();\n  const stack = wasm.stackSave();\n  let metadataOffset = 0;\n  try {\n    const ptrSize = wasm.PTR_SIZE;\n    const dataOffset = wasm.stackAlloc(2 * ptrSize);\n    const errorCode = wasm._OrtGetInputOutputMetadata(sessionHandle, index, dataOffset, dataOffset + ptrSize);\n    if (errorCode !== 0) {\n      checkLastError(\"Can't get session input/output metadata.\");\n    }\n    const nameOffset = Number(wasm.getValue(dataOffset, '*'));\n    metadataOffset = Number(wasm.getValue(dataOffset + ptrSize, '*'));\n    // get element type\n    const elementType = wasm.HEAP32[metadataOffset / 4];\n    if (elementType === 0) {\n      return [nameOffset, 0]; // non-tensor\n    }\n\n    // get dims count\n    const dimsCount = wasm.HEAPU32[metadataOffset / 4 + 1];\n    // get dims\n    const dims: Array<number | string> = [];\n    for (let i = 0; i < dimsCount; i++) {\n      const symbolicDimNameOffset = Number(wasm.getValue(metadataOffset + 8 + i * ptrSize, '*'));\n      dims.push(\n        symbolicDimNameOffset !== 0\n          ? wasm.UTF8ToString(symbolicDimNameOffset)\n          : Number(wasm.getValue(metadataOffset + 8 + (i + dimsCount) * ptrSize, '*')),\n      );\n    }\n    return [nameOffset, elementType, dims];\n  } finally {\n    wasm.stackRestore(stack);\n    if (metadataOffset !== 0) {\n      wasm._OrtFree(metadataOffset);\n    }\n  }\n};\n\n/**\n * allocate the memory and memcpy the external buffer.\n *\n * @param model - the external buffer containing the model data. Must not be the same buffer as the WASM heap.\n * @returns a 2-elements tuple - the pointer and size of the allocated buffer\n */\nexport const copyFromExternalBuffer = (model: Uint8Array): [number, number] => {\n  const wasm = getInstance();\n  const modelDataOffset = wasm._malloc(model.byteLength);\n  if (modelDataOffset === 0) {\n    throw new Error(`Can't create a session. failed to allocate a buffer of size ${model.byteLength}.`);\n  }\n  wasm.HEAPU8.set(model, modelDataOffset);\n  return [modelDataOffset, model.byteLength];\n};\n\n/**\n * create an inference session from a model data buffer.\n *\n * @param modelData - either a Uint8Array object representing the model data, or a 2-elements tuple containing the\n *     pointer and size of the model data buffer.\n * @param options an optional session options object.\n * @returns a 3-elements tuple containing [session handle, input names, output names]\n */\nexport const createSession = async (\n  modelData: Uint8Array | SerializableInternalBuffer,\n  options?: InferenceSession.SessionOptions,\n): Promise<SerializableSessionMetadata> => {\n  let modelDataOffset: number, modelDataLength: number;\n  const wasm = getInstance();\n\n  if (Array.isArray(modelData)) {\n    // if model data is an array, it must be a 2-elements tuple containing the pointer and size of the model data\n    [modelDataOffset, modelDataLength] = modelData;\n  } else if (modelData.buffer === wasm.HEAPU8.buffer) {\n    // if model data uses the same buffer as the WASM heap, we don't need to copy it.\n    [modelDataOffset, modelDataLength] = [modelData.byteOffset, modelData.byteLength];\n  } else {\n    // otherwise, copy the model data to the WASM heap.\n    [modelDataOffset, modelDataLength] = copyFromExternalBuffer(modelData);\n  }\n\n  let sessionHandle = 0;\n  let sessionOptionsHandle = 0;\n  let ioBindingHandle = 0;\n  let allocs: number[] = [];\n  const inputNamesUTF8Encoded = [];\n  const outputNamesUTF8Encoded = [];\n\n  try {\n    [sessionOptionsHandle, allocs] = await setSessionOptions(options);\n\n    if (options?.externalData && wasm.mountExternalData) {\n      const loadingPromises = [];\n      for (const file of options.externalData) {\n        const path = typeof file === 'string' ? file : file.path;\n        loadingPromises.push(\n          loadFile(typeof file === 'string' ? file : file.data).then((data) => {\n            wasm.mountExternalData(path, data);\n          }),\n        );\n      }\n\n      // wait for all external data files to be loaded\n      await Promise.all(loadingPromises);\n    }\n\n    for (const provider of options?.executionProviders ?? []) {\n      const providerName = typeof provider === 'string' ? provider : provider.name;\n      if (providerName === 'webnn') {\n        wasm.shouldTransferToMLTensor = false;\n        if (typeof provider !== 'string') {\n          const webnnOptions = provider as InferenceSession.WebNNExecutionProviderOption;\n          const context = (webnnOptions as InferenceSession.WebNNOptionsWithMLContext)?.context;\n          const gpuDevice = (webnnOptions as InferenceSession.WebNNOptionsWebGpu)?.gpuDevice;\n          const deviceType = (webnnOptions as InferenceSession.WebNNContextOptions)?.deviceType;\n          const powerPreference = (webnnOptions as InferenceSession.WebNNContextOptions)?.powerPreference;\n          if (context) {\n            wasm.currentContext = context as MLContext;\n          } else if (gpuDevice) {\n            wasm.currentContext = await wasm.webnnCreateMLContext!(gpuDevice);\n          } else {\n            wasm.currentContext = await wasm.webnnCreateMLContext!({ deviceType, powerPreference });\n          }\n        } else {\n          wasm.currentContext = await wasm.webnnCreateMLContext!();\n        }\n        break;\n      }\n    }\n\n    sessionHandle = await wasm._OrtCreateSession(modelDataOffset, modelDataLength, sessionOptionsHandle);\n    wasm.webgpuOnCreateSession?.(sessionHandle);\n    if (sessionHandle === 0) {\n      checkLastError(\"Can't create a session.\");\n    }\n\n    wasm.jsepOnCreateSession?.();\n\n    // clear current MLContext after session creation\n    if (wasm.currentContext) {\n      wasm.webnnRegisterMLContext!(sessionHandle, wasm.currentContext);\n      wasm.currentContext = undefined;\n      wasm.shouldTransferToMLTensor = true;\n    }\n\n    const [inputCount, outputCount] = getSessionInputOutputCount(sessionHandle);\n\n    const enableGraphCapture = !!options?.enableGraphCapture;\n\n    const inputNames = [];\n    const outputNames = [];\n    const inputMetadata: InferenceSession.ValueMetadata[] = [];\n    const outputMetadata: InferenceSession.ValueMetadata[] = [];\n    const outputPreferredLocations: SupportedTensorDataLocationForInputOutput[] = [];\n    for (let i = 0; i < inputCount; i++) {\n      const [nameOffset, elementType, shape] = getSessionInputOutputMetadata(sessionHandle, i);\n      if (nameOffset === 0) {\n        checkLastError(\"Can't get an input name.\");\n      }\n      inputNamesUTF8Encoded.push(nameOffset);\n      const name = wasm.UTF8ToString(nameOffset);\n      inputNames.push(name);\n      inputMetadata.push(\n        elementType === 0\n          ? { name, isTensor: false }\n          : { name, isTensor: true, type: tensorDataTypeEnumToString(elementType), shape: shape! },\n      );\n    }\n    for (let i = 0; i < outputCount; i++) {\n      const [nameOffset, elementType, shape] = getSessionInputOutputMetadata(sessionHandle, i + inputCount);\n      if (nameOffset === 0) {\n        checkLastError(\"Can't get an output name.\");\n      }\n      outputNamesUTF8Encoded.push(nameOffset);\n      const nameString = wasm.UTF8ToString(nameOffset);\n      outputNames.push(nameString);\n      outputMetadata.push(\n        elementType === 0\n          ? { name: nameString, isTensor: false }\n          : { name: nameString, isTensor: true, type: tensorDataTypeEnumToString(elementType), shape: shape! },\n      );\n\n      if (!BUILD_DEFS.DISABLE_JSEP || !BUILD_DEFS.DISABLE_WEBGPU) {\n        if (enableGraphCapture && options?.preferredOutputLocation === undefined) {\n          outputPreferredLocations.push('gpu-buffer');\n          continue;\n        }\n        const location =\n          typeof options?.preferredOutputLocation === 'string'\n            ? options.preferredOutputLocation\n            : (options?.preferredOutputLocation?.[nameString] ?? 'cpu');\n        const isGraphOutput = wasm.webnnIsGraphOutput;\n        if (location === 'cpu' && isGraphOutput && isGraphOutput(sessionHandle, nameString)) {\n          outputPreferredLocations.push('ml-tensor-cpu-output');\n          continue;\n        }\n        if (location !== 'cpu' && location !== 'cpu-pinned' && location !== 'gpu-buffer' && location !== 'ml-tensor') {\n          throw new Error(`Not supported preferred output location: ${location}.`);\n        }\n        if (enableGraphCapture && location !== 'gpu-buffer') {\n          throw new Error(\n            `Not supported preferred output location: ${location}. Only 'gpu-buffer' location is supported when enableGraphCapture is true.`,\n          );\n        }\n        outputPreferredLocations.push(location);\n      }\n    }\n\n    // use IO binding only when at least one output is preferred to be on GPU.\n    let bindingState: IOBindingState | null = null;\n    if (\n      (!BUILD_DEFS.DISABLE_JSEP || !BUILD_DEFS.DISABLE_WEBGPU) &&\n      outputPreferredLocations.some((l) => l === 'gpu-buffer' || l === 'ml-tensor' || l === 'ml-tensor-cpu-output')\n    ) {\n      ioBindingHandle = wasm._OrtCreateBinding(sessionHandle);\n      if (ioBindingHandle === 0) {\n        checkLastError(\"Can't create IO binding.\");\n      }\n\n      bindingState = {\n        handle: ioBindingHandle,\n        outputPreferredLocations,\n        outputPreferredLocationsEncoded: outputPreferredLocations\n          // 'ml-tensor-cpu-output' is treated as 'ml-tensor' for the purpose of IO binding.\n          .map((l) => (l === 'ml-tensor-cpu-output' ? 'ml-tensor' : l))\n          .map((l) => dataLocationStringToEnum(l)),\n      };\n    }\n\n    activeSessions.set(sessionHandle, [\n      sessionHandle,\n      inputNamesUTF8Encoded,\n      outputNamesUTF8Encoded,\n      bindingState,\n      enableGraphCapture,\n      false,\n    ]);\n    return [sessionHandle, inputNames, outputNames, inputMetadata, outputMetadata];\n  } catch (e) {\n    inputNamesUTF8Encoded.forEach((buf) => wasm._OrtFree(buf));\n    outputNamesUTF8Encoded.forEach((buf) => wasm._OrtFree(buf));\n\n    if (ioBindingHandle !== 0) {\n      if (wasm._OrtReleaseBinding(ioBindingHandle) !== 0) {\n        checkLastError(\"Can't release IO binding.\");\n      }\n    }\n\n    if (sessionHandle !== 0) {\n      if (wasm._OrtReleaseSession(sessionHandle) !== 0) {\n        checkLastError(\"Can't release session.\");\n      }\n    }\n    throw e;\n  } finally {\n    wasm._free(modelDataOffset);\n    if (sessionOptionsHandle !== 0) {\n      if (wasm._OrtReleaseSessionOptions(sessionOptionsHandle) !== 0) {\n        checkLastError(\"Can't release session options.\");\n      }\n    }\n    allocs.forEach((alloc) => wasm._free(alloc));\n\n    // unmount external data if necessary\n    wasm.unmountExternalData?.();\n  }\n};\n\nexport const releaseSession = (sessionId: number): void => {\n  const wasm = getInstance();\n  const session = activeSessions.get(sessionId);\n  if (!session) {\n    throw new Error(`cannot release session. invalid session id: ${sessionId}`);\n  }\n  const [sessionHandle, inputNamesUTF8Encoded, outputNamesUTF8Encoded, ioBindingState, enableGraphCapture] = session;\n\n  if (ioBindingState) {\n    if (enableGraphCapture) {\n      if (wasm._OrtClearBoundOutputs(ioBindingState.handle) !== 0) {\n        checkLastError(\"Can't clear bound outputs.\");\n      }\n    }\n    if (wasm._OrtReleaseBinding(ioBindingState.handle) !== 0) {\n      checkLastError(\"Can't release IO binding.\");\n    }\n  }\n\n  wasm.jsepOnReleaseSession?.(sessionId);\n  wasm.webnnOnReleaseSession?.(sessionId);\n  wasm.webgpuOnReleaseSession?.(sessionId);\n\n  inputNamesUTF8Encoded.forEach((buf) => wasm._OrtFree(buf));\n  outputNamesUTF8Encoded.forEach((buf) => wasm._OrtFree(buf));\n  if (wasm._OrtReleaseSession(sessionHandle) !== 0) {\n    checkLastError(\"Can't release session.\");\n  }\n  activeSessions.delete(sessionId);\n};\n\nexport const prepareInputOutputTensor = async (\n  tensor: TensorMetadata | null,\n  tensorHandles: number[],\n  allocs: number[],\n  sessionId: number,\n  tensorNameUTF8Encoded: number,\n  index: number,\n  enableGraphCapture = false,\n): Promise<void> => {\n  if (!tensor) {\n    tensorHandles.push(0);\n    return;\n  }\n\n  const wasm = getInstance();\n  const ptrSize = wasm.PTR_SIZE;\n\n  const dataType = tensor[0];\n  const dims = tensor[1];\n  const location = tensor[3];\n  let actualLocation = location;\n\n  let rawData: number;\n  let dataByteLength: number;\n\n  if (dataType === 'string' && (location === 'gpu-buffer' || location === 'ml-tensor')) {\n    throw new Error('String tensor is not supported on GPU.');\n  }\n\n  if (enableGraphCapture && location !== 'gpu-buffer') {\n    throw new Error(\n      `External buffer must be provided for input/output index ${index} when enableGraphCapture is true.`,\n    );\n  }\n\n  if (location === 'gpu-buffer') {\n    const gpuBuffer = tensor[2].gpuBuffer;\n    dataByteLength = calculateTensorSizeInBytes(tensorDataTypeStringToEnum(dataType), dims)!;\n\n    if (!BUILD_DEFS.DISABLE_WEBGPU) {\n      const registerBuffer = wasm.webgpuRegisterBuffer;\n      if (!registerBuffer) {\n        throw new Error('Tensor location \"gpu-buffer\" is not supported without using WebGPU.');\n      }\n\n      rawData = registerBuffer(gpuBuffer, sessionId);\n    } else {\n      const registerBuffer = wasm.jsepRegisterBuffer;\n      if (!registerBuffer) {\n        throw new Error('Tensor location \"gpu-buffer\" is not supported without using WebGPU.');\n      }\n      rawData = registerBuffer(sessionId, index, gpuBuffer, dataByteLength);\n    }\n  } else if (location === 'ml-tensor') {\n    const mlTensor = tensor[2].mlTensor as MLTensor;\n    dataByteLength = calculateTensorSizeInBytes(tensorDataTypeStringToEnum(dataType), dims)!;\n\n    const registerMLTensor = wasm.webnnRegisterMLTensor;\n    if (!registerMLTensor) {\n      throw new Error('Tensor location \"ml-tensor\" is not supported without using WebNN.');\n    }\n    rawData = registerMLTensor(sessionId, mlTensor, tensorDataTypeStringToEnum(dataType), dims);\n  } else {\n    const data = tensor[2];\n\n    if (Array.isArray(data)) {\n      // string tensor\n      dataByteLength = ptrSize * data.length;\n      rawData = wasm._malloc(dataByteLength);\n      allocs.push(rawData);\n      for (let i = 0; i < data.length; i++) {\n        if (typeof data[i] !== 'string') {\n          throw new TypeError(`tensor data at index ${i} is not a string`);\n        }\n        wasm.setValue(rawData + i * ptrSize, allocWasmString(data[i], allocs), '*');\n      }\n    } else {\n      const isGraphInput = wasm.webnnIsGraphInput;\n      const isGraphOutput = wasm.webnnIsGraphOutput;\n      if (dataType !== 'string' && isGraphInput && isGraphOutput) {\n        const tensorName = wasm.UTF8ToString(tensorNameUTF8Encoded);\n        // Promote the tensor to 'ml-tensor' if it is a graph input.\n        if (isGraphInput(sessionId, tensorName) || isGraphOutput(sessionId, tensorName)) {\n          const dataTypeEnum = tensorDataTypeStringToEnum(dataType);\n          dataByteLength = calculateTensorSizeInBytes(dataTypeEnum, dims)!;\n          actualLocation = 'ml-tensor';\n          const createTemporaryTensor = wasm.webnnCreateTemporaryTensor;\n          const uploadTensor = wasm.webnnUploadTensor;\n          if (!createTemporaryTensor || !uploadTensor) {\n            throw new Error('Tensor location \"ml-tensor\" is not supported without using WebNN.');\n          }\n          const tensorId = await createTemporaryTensor(sessionId, dataTypeEnum, dims as number[]);\n          uploadTensor(tensorId, new Uint8Array(data.buffer, data.byteOffset, data.byteLength));\n          rawData = tensorId;\n        } else {\n          dataByteLength = data.byteLength;\n          rawData = wasm._malloc(dataByteLength);\n          allocs.push(rawData);\n          wasm.HEAPU8.set(new Uint8Array(data.buffer, data.byteOffset, dataByteLength), rawData);\n        }\n      } else {\n        dataByteLength = data.byteLength;\n        rawData = wasm._malloc(dataByteLength);\n        allocs.push(rawData);\n        wasm.HEAPU8.set(new Uint8Array(data.buffer, data.byteOffset, dataByteLength), rawData);\n      }\n    }\n  }\n\n  const stack = wasm.stackSave();\n  const dimsOffset = wasm.stackAlloc(4 * dims.length);\n  try {\n    dims.forEach((d, index) => wasm.setValue(dimsOffset + index * ptrSize, d, ptrSize === 4 ? 'i32' : 'i64'));\n    const tensor = wasm._OrtCreateTensor(\n      tensorDataTypeStringToEnum(dataType),\n      rawData,\n      dataByteLength,\n      dimsOffset,\n      dims.length,\n      dataLocationStringToEnum(actualLocation),\n    );\n    if (tensor === 0) {\n      checkLastError(`Can't create tensor for input/output. session=${sessionId}, index=${index}.`);\n    }\n    tensorHandles.push(tensor);\n  } finally {\n    wasm.stackRestore(stack);\n  }\n};\n\n/**\n * perform inference run\n */\nexport const run = async (\n  sessionId: number,\n  inputIndices: number[],\n  inputTensors: TensorMetadata[],\n  outputIndices: number[],\n  outputTensors: Array<TensorMetadata | null>,\n  options: InferenceSession.RunOptions,\n): Promise<TensorMetadata[]> => {\n  const wasm = getInstance();\n  const ptrSize = wasm.PTR_SIZE;\n  const session = activeSessions.get(sessionId);\n  if (!session) {\n    throw new Error(`cannot run inference. invalid session id: ${sessionId}`);\n  }\n  const sessionHandle = session[0];\n  const inputNamesUTF8Encoded = session[1];\n  const outputNamesUTF8Encoded = session[2];\n  const ioBindingState = session[3];\n  const enableGraphCapture = session[4];\n  const inputOutputBound = session[5];\n\n  const inputCount = inputIndices.length;\n  const outputCount = outputIndices.length;\n\n  let runOptionsHandle = 0;\n  let runOptionsAllocs: number[] = [];\n\n  const inputTensorHandles: number[] = [];\n  const outputTensorHandles: number[] = [];\n  const inputOutputAllocs: number[] = [];\n  const preAllocatedOutputs: number[] = [];\n\n  const beforeRunStack = wasm.stackSave();\n  const inputValuesOffset = wasm.stackAlloc(inputCount * ptrSize);\n  const inputNamesOffset = wasm.stackAlloc(inputCount * ptrSize);\n  const outputValuesOffset = wasm.stackAlloc(outputCount * ptrSize);\n  const outputNamesOffset = wasm.stackAlloc(outputCount * ptrSize);\n\n  try {\n    [runOptionsHandle, runOptionsAllocs] = setRunOptions(options);\n\n    TRACE_EVENT_BEGIN('wasm prepareInputOutputTensor');\n    // create input tensors\n    for (let i = 0; i < inputCount; i++) {\n      await prepareInputOutputTensor(\n        inputTensors[i],\n        inputTensorHandles,\n        inputOutputAllocs,\n        sessionId,\n        inputNamesUTF8Encoded[inputIndices[i]],\n        inputIndices[i],\n        enableGraphCapture,\n      );\n    }\n\n    // create output tensors\n    for (let i = 0; i < outputCount; i++) {\n      await prepareInputOutputTensor(\n        outputTensors[i],\n        outputTensorHandles,\n        inputOutputAllocs,\n        sessionId,\n        outputNamesUTF8Encoded[outputIndices[i]],\n        inputCount + outputIndices[i],\n        enableGraphCapture,\n      );\n    }\n    TRACE_EVENT_END('wasm prepareInputOutputTensor');\n\n    for (let i = 0; i < inputCount; i++) {\n      wasm.setValue(inputValuesOffset + i * ptrSize, inputTensorHandles[i], '*');\n      wasm.setValue(inputNamesOffset + i * ptrSize, inputNamesUTF8Encoded[inputIndices[i]], '*');\n    }\n    for (let i = 0; i < outputCount; i++) {\n      wasm.setValue(outputValuesOffset + i * ptrSize, outputTensorHandles[i], '*');\n      wasm.setValue(outputNamesOffset + i * ptrSize, outputNamesUTF8Encoded[outputIndices[i]], '*');\n    }\n\n    if ((!BUILD_DEFS.DISABLE_JSEP || !BUILD_DEFS.DISABLE_WEBGPU) && ioBindingState && !inputOutputBound) {\n      const { handle, outputPreferredLocations, outputPreferredLocationsEncoded } = ioBindingState;\n\n      if (inputNamesUTF8Encoded.length !== inputCount) {\n        throw new Error(\n          `input count from feeds (${inputCount}) is expected to be always equal to model's input count (${inputNamesUTF8Encoded.length}).`,\n        );\n      }\n\n      TRACE_EVENT_BEGIN('wasm bindInputsOutputs');\n      // process inputs\n      for (let i = 0; i < inputCount; i++) {\n        const index = inputIndices[i];\n        const errorCode = await wasm._OrtBindInput(handle, inputNamesUTF8Encoded[index], inputTensorHandles[i]);\n        if (errorCode !== 0) {\n          checkLastError(`Can't bind input[${i}] for session=${sessionId}.`);\n        }\n      }\n\n      // process pre-allocated outputs\n      for (let i = 0; i < outputCount; i++) {\n        const index = outputIndices[i];\n        const location = outputTensors[i]?.[3]; // undefined means output is not pre-allocated.\n\n        if (location) {\n          // output is pre-allocated, store and bind the tensor.\n          preAllocatedOutputs.push(outputTensorHandles[i]);\n          const errorCode = wasm._OrtBindOutput(handle, outputNamesUTF8Encoded[index], outputTensorHandles[i], 0);\n          if (errorCode !== 0) {\n            checkLastError(`Can't bind pre-allocated output[${i}] for session=${sessionId}.`);\n          }\n        } else {\n          // output is not pre-allocated. reset preferred location.\n          const errorCode = wasm._OrtBindOutput(\n            handle,\n            outputNamesUTF8Encoded[index],\n            0,\n            outputPreferredLocationsEncoded[index],\n          );\n          if (errorCode !== 0) {\n            checkLastError(`Can't bind output[${i}] to ${outputPreferredLocations[i]} for session=${sessionId}.`);\n          }\n        }\n      }\n      TRACE_EVENT_END('wasm bindInputsOutputs');\n      activeSessions.set(sessionId, [\n        sessionHandle,\n        inputNamesUTF8Encoded,\n        outputNamesUTF8Encoded,\n        ioBindingState,\n        enableGraphCapture,\n        true,\n      ]);\n    }\n\n    wasm.jsepOnRunStart?.(sessionHandle);\n    wasm.webnnOnRunStart?.(sessionHandle);\n\n    let errorCode: number;\n    if ((!BUILD_DEFS.DISABLE_JSEP || !BUILD_DEFS.DISABLE_WEBGPU) && ioBindingState) {\n      errorCode = await wasm._OrtRunWithBinding(\n        sessionHandle,\n        ioBindingState.handle,\n        outputCount,\n        outputValuesOffset,\n        runOptionsHandle,\n      );\n    } else {\n      errorCode = await wasm._OrtRun(\n        sessionHandle,\n        inputNamesOffset,\n        inputValuesOffset,\n        inputCount,\n        outputNamesOffset,\n        outputCount,\n        outputValuesOffset,\n        runOptionsHandle,\n      );\n    }\n\n    if (errorCode !== 0) {\n      checkLastError('failed to call OrtRun().');\n    }\n\n    const output: TensorMetadata[] = [];\n    const outputPromises: Array<Promise<[number, Tensor.DataType]>> = [];\n\n    TRACE_EVENT_BEGIN('wasm ProcessOutputTensor');\n    for (let i = 0; i < outputCount; i++) {\n      const tensor = Number(wasm.getValue(outputValuesOffset + i * ptrSize, '*'));\n      // TODO: revisit this part to ensure it works for WebGPU when both pre-allocated outputs and\n      // preferred location are specified.\n      // Certain pre-allocated tensors may already be bound in the IO binding. e.g. the WebNN backend\n      // always binds its tensor to 'ml-tensor'. In such cases, the tensor ID might change after binding,\n      // but copying data for these tensors should still be avoided.\n      if (tensor === outputTensorHandles[i] || preAllocatedOutputs.includes(outputTensorHandles[i])) {\n        // output tensor is pre-allocated. no need to copy data.\n        output.push(outputTensors[i]!);\n        if (tensor !== outputTensorHandles[i]) {\n          // release redundant tensor earlier.\n          if (wasm._OrtReleaseTensor(tensor) !== 0) {\n            checkLastError(\"Can't release tensor.\");\n          }\n        }\n        continue;\n      }\n\n      const beforeGetTensorDataStack = wasm.stackSave();\n      // stack allocate 4 pointer value\n      const tensorDataOffset = wasm.stackAlloc(4 * ptrSize);\n\n      let keepOutputTensor = false;\n      let type: Tensor.Type | undefined,\n        dataOffset = 0;\n      try {\n        const errorCode = wasm._OrtGetTensorData(\n          tensor,\n          tensorDataOffset,\n          tensorDataOffset + ptrSize,\n          tensorDataOffset + 2 * ptrSize,\n\n          tensorDataOffset + 3 * ptrSize,\n        );\n        if (errorCode !== 0) {\n          checkLastError(`Can't access output tensor data on index ${i}.`);\n        }\n        const valueType = ptrSize === 4 ? 'i32' : 'i64';\n        const dataType = Number(wasm.getValue(tensorDataOffset, valueType));\n        dataOffset = wasm.getValue(tensorDataOffset + ptrSize, '*');\n        const dimsOffset = wasm.getValue(tensorDataOffset + ptrSize * 2, '*');\n        const dimsLength = Number(wasm.getValue(tensorDataOffset + ptrSize * 3, valueType));\n        const dims = [];\n        for (let i = 0; i < dimsLength; i++) {\n          dims.push(Number(wasm.getValue(dimsOffset + i * ptrSize, valueType)));\n        }\n        if (wasm._OrtFree(dimsOffset) !== 0) {\n          checkLastError(\"Can't free memory for tensor dims.\");\n        }\n        const size = dims.reduce((a, b) => a * b, 1);\n        type = tensorDataTypeEnumToString(dataType);\n\n        const preferredLocation = ioBindingState?.outputPreferredLocations[outputIndices[i]];\n\n        if (type === 'string') {\n          if (preferredLocation === 'gpu-buffer' || preferredLocation === 'ml-tensor') {\n            throw new Error('String tensor is not supported on GPU.');\n          }\n          const stringData: string[] = [];\n          for (let i = 0; i < size; i++) {\n            const offset = wasm.getValue(dataOffset + i * ptrSize, '*');\n            const nextOffset = wasm.getValue(dataOffset + (i + 1) * ptrSize, '*');\n            const maxBytesToRead = i === size - 1 ? undefined : nextOffset - offset;\n            stringData.push(wasm.UTF8ToString(offset, maxBytesToRead));\n          }\n          output.push([type, dims, stringData, 'cpu']);\n        } else {\n          // If a certain output's preferred location is GPU but the tensor is empty, we still need to create a CPU\n          // tensor for it. There is no mapping GPU buffer for an empty tensor.\n          if (preferredLocation === 'gpu-buffer' && size > 0) {\n            const getBuffer = !BUILD_DEFS.DISABLE_WEBGPU ? wasm.webgpuGetBuffer : wasm.jsepGetBuffer;\n            if (!getBuffer) {\n              throw new Error('preferredLocation \"gpu-buffer\" is not supported without using WebGPU.');\n            }\n            const gpuBuffer = getBuffer(dataOffset);\n            const bufferSize = calculateTensorSizeInBytes(dataType, size);\n            if (bufferSize === undefined || !isGpuBufferSupportedType(type)) {\n              throw new Error(`Unsupported data type: ${type}`);\n            }\n\n            // do not release the tensor right now. it will be released when user calls tensor.dispose().\n            keepOutputTensor = true;\n\n            if (!BUILD_DEFS.DISABLE_WEBGPU) {\n              wasm.webgpuRegisterBuffer!(gpuBuffer, sessionId, dataOffset);\n              const downloadDataFunction = wasm.webgpuCreateDownloader!(gpuBuffer, bufferSize, sessionId);\n              output.push([\n                type,\n                dims,\n                {\n                  gpuBuffer,\n                  download: async () => {\n                    const arrayBuffer = await downloadDataFunction();\n                    const data = new (tensorTypeToTypedArrayConstructor(type!))(arrayBuffer);\n                    return data as Tensor.DataTypeMap[Tensor.GpuBufferDataTypes];\n                  },\n                  dispose: () => {\n                    if (wasm._OrtReleaseTensor(tensor) !== 0) {\n                      checkLastError(\"Can't release tensor.\");\n                    }\n                  },\n                },\n                'gpu-buffer',\n              ]);\n            } else {\n              output.push([\n                type,\n                dims,\n                {\n                  gpuBuffer,\n                  download: wasm.jsepCreateDownloader!(gpuBuffer, bufferSize, type),\n                  dispose: () => {\n                    if (wasm._OrtReleaseTensor(tensor) !== 0) {\n                      checkLastError(\"Can't release tensor.\");\n                    }\n                  },\n                },\n                'gpu-buffer',\n              ]);\n            }\n          } else if (preferredLocation === 'ml-tensor' && size > 0) {\n            const ensureTensor = wasm.webnnEnsureTensor;\n            const isGraphInputOutputTypeSupported = wasm.webnnIsGraphInputOutputTypeSupported;\n            if (!ensureTensor || !isGraphInputOutputTypeSupported) {\n              throw new Error('preferredLocation \"ml-tensor\" is not supported without using WebNN.');\n            }\n            const tensorSize = calculateTensorSizeInBytes(dataType, size);\n            if (tensorSize === undefined || !isMLTensorSupportedType(type)) {\n              throw new Error(`Unsupported data type: ${type}`);\n            }\n            if (!isGraphInputOutputTypeSupported(sessionId, type, false)) {\n              throw new Error(\n                `preferredLocation \"ml-tensor\" for ${type} output is not supported by current WebNN Context.`,\n              );\n            }\n\n            // If the graph has been partitioned, the output tensor may have not been created. For this reason, we use\n            // ensureTensor to get/create the MLTensor. In which case, we don't need to copy the data if a new tensor\n            // has been created.\n            const mlTensor = await ensureTensor(sessionId, dataOffset, dataType, dims, false);\n\n            // do not release the tensor right now. it will be released when user calls tensor.dispose().\n            keepOutputTensor = true;\n\n            output.push([\n              type,\n              dims,\n              {\n                mlTensor,\n                download: wasm.webnnCreateMLTensorDownloader!(dataOffset, type),\n                dispose: () => {\n                  wasm.webnnReleaseTensorId!(dataOffset);\n                  wasm._OrtReleaseTensor(tensor);\n                },\n              },\n              'ml-tensor',\n            ]);\n          } else if (preferredLocation === 'ml-tensor-cpu-output' && size > 0) {\n            const data = wasm.webnnCreateMLTensorDownloader!(dataOffset, type as Tensor.MLTensorDataTypes)();\n            const index = output.length;\n            // Delay the data download and releasing the tensor until we can wait for all output tensors to be downloaded.\n            keepOutputTensor = true;\n            outputPromises.push(\n              (async () => {\n                const result: [number, Tensor.DataType] = [index, await data];\n                wasm.webnnReleaseTensorId!(dataOffset);\n                wasm._OrtReleaseTensor(tensor);\n                return result;\n              })(),\n            );\n            output.push([type, dims, [], 'cpu']);\n          } else {\n            const typedArrayConstructor = tensorTypeToTypedArrayConstructor(type);\n            const data = new typedArrayConstructor(size);\n            new Uint8Array(data.buffer, data.byteOffset, data.byteLength).set(\n              wasm.HEAPU8.subarray(dataOffset, dataOffset + data.byteLength),\n            );\n            output.push([type, dims, data, 'cpu']);\n          }\n        }\n      } finally {\n        wasm.stackRestore(beforeGetTensorDataStack);\n        if (type === 'string' && dataOffset) {\n          wasm._free(dataOffset);\n        }\n        if (!keepOutputTensor) {\n          wasm._OrtReleaseTensor(tensor);\n        }\n      }\n    }\n\n    if (ioBindingState && !enableGraphCapture) {\n      if (wasm._OrtClearBoundOutputs(ioBindingState.handle) !== 0) {\n        checkLastError(\"Can't clear bound outputs.\");\n      }\n      activeSessions.set(sessionId, [\n        sessionHandle,\n        inputNamesUTF8Encoded,\n        outputNamesUTF8Encoded,\n        ioBindingState,\n        enableGraphCapture,\n        false,\n      ]);\n    }\n    // Wait for all output tensor data to be downloaded.\n    for (const [index, data] of await Promise.all(outputPromises)) {\n      output[index][2] = data;\n    }\n    TRACE_EVENT_END('wasm ProcessOutputTensor');\n    return output;\n  } finally {\n    wasm.webnnOnRunEnd?.(sessionHandle);\n\n    wasm.stackRestore(beforeRunStack);\n\n    if (!BUILD_DEFS.DISABLE_WEBGPU) {\n      inputTensors.forEach((t) => {\n        if (t && t[3] === 'gpu-buffer') {\n          wasm.webgpuUnregisterBuffer!(t[2].gpuBuffer);\n        }\n      });\n      outputTensors.forEach((t) => {\n        if (t && t[3] === 'gpu-buffer') {\n          wasm.webgpuUnregisterBuffer!(t[2].gpuBuffer);\n        }\n      });\n    }\n    inputTensorHandles.forEach((v) => wasm._OrtReleaseTensor(v));\n    outputTensorHandles.forEach((v) => wasm._OrtReleaseTensor(v));\n    inputOutputAllocs.forEach((p) => wasm._free(p));\n\n    if (runOptionsHandle !== 0) {\n      wasm._OrtReleaseRunOptions(runOptionsHandle);\n    }\n    runOptionsAllocs.forEach((p) => wasm._free(p));\n  }\n};\n\n/**\n * end profiling\n */\nexport const endProfiling = (sessionId: number): void => {\n  const wasm = getInstance();\n  const session = activeSessions.get(sessionId);\n  if (!session) {\n    throw new Error('invalid session id');\n  }\n  const sessionHandle = session[0];\n\n  // profile file name is not used yet, but it must be freed.\n  const profileFileName = wasm._OrtEndProfiling(sessionHandle);\n  if (profileFileName === 0) {\n    checkLastError(\"Can't get an profile file name.\");\n  }\n  wasm._OrtFree(profileFileName);\n};\n\nexport const extractTransferableBuffers = (tensors: readonly SerializableTensorMetadata[]): ArrayBufferLike[] => {\n  const buffers: ArrayBufferLike[] = [];\n  for (const tensor of tensors) {\n    const data = tensor[2];\n    if (!Array.isArray(data) && 'buffer' in data) {\n      buffers.push(data.buffer);\n    }\n  }\n  return buffers;\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { env, InferenceSession } from 'onnxruntime-common';\n\nimport {\n  OrtWasmMessage,\n  SerializableInternalBuffer,\n  SerializableSessionMetadata,\n  SerializableTensorMetadata,\n  TensorMetadata,\n} from './proxy-messages';\nimport * as core from './wasm-core-impl';\nimport { initializeWebAssembly } from './wasm-factory';\nimport {\n  importProxyWorker,\n  inferWasmPathPrefixFromScriptSrc,\n  isEsmImportMetaUrlHardcodedAsFileUri,\n} from './wasm-utils-import';\n\nconst isProxy = (): boolean => !!env.wasm.proxy && typeof document !== 'undefined';\nlet proxyWorker: Worker | undefined;\nlet initializing = false;\nlet initialized = false;\nlet aborted = false;\nlet temporaryObjectUrl: string | undefined;\n\ntype PromiseCallbacks<T = void> = [resolve: (result: T) => void, reject: (reason: unknown) => void];\nlet initWasmCallbacks: PromiseCallbacks;\nconst queuedCallbacks: Map<OrtWasmMessage['type'], Array<PromiseCallbacks<unknown>>> = new Map();\n\nconst enqueueCallbacks = (type: OrtWasmMessage['type'], callbacks: PromiseCallbacks<unknown>): void => {\n  const queue = queuedCallbacks.get(type);\n  if (queue) {\n    queue.push(callbacks);\n  } else {\n    queuedCallbacks.set(type, [callbacks]);\n  }\n};\n\nconst ensureWorker = (): void => {\n  if (initializing || !initialized || aborted || !proxyWorker) {\n    throw new Error('worker not ready');\n  }\n};\n\nconst onProxyWorkerMessage = (ev: MessageEvent<OrtWasmMessage>): void => {\n  switch (ev.data.type) {\n    case 'init-wasm':\n      initializing = false;\n      if (ev.data.err) {\n        aborted = true;\n        initWasmCallbacks[1](ev.data.err);\n      } else {\n        initialized = true;\n        initWasmCallbacks[0]();\n      }\n      if (temporaryObjectUrl) {\n        URL.revokeObjectURL(temporaryObjectUrl);\n        temporaryObjectUrl = undefined;\n      }\n      break;\n    case 'init-ep':\n    case 'copy-from':\n    case 'create':\n    case 'release':\n    case 'run':\n    case 'end-profiling': {\n      const callbacks = queuedCallbacks.get(ev.data.type)!;\n      if (ev.data.err) {\n        callbacks.shift()![1](ev.data.err);\n      } else {\n        callbacks.shift()![0](ev.data.out!);\n      }\n      break;\n    }\n    default:\n  }\n};\n\nexport const initializeWebAssemblyAndOrtRuntime = async (): Promise<void> => {\n  if (initialized) {\n    return;\n  }\n  if (initializing) {\n    throw new Error(\"multiple calls to 'initWasm()' detected.\");\n  }\n  if (aborted) {\n    throw new Error(\"previous call to 'initWasm()' failed.\");\n  }\n\n  initializing = true;\n\n  if (!BUILD_DEFS.DISABLE_WASM_PROXY && isProxy()) {\n    return new Promise<void>((resolve, reject) => {\n      proxyWorker?.terminate();\n\n      void importProxyWorker().then(([objectUrl, worker]) => {\n        try {\n          proxyWorker = worker;\n          proxyWorker.onerror = (ev: ErrorEvent) => reject(ev);\n          proxyWorker.onmessage = onProxyWorkerMessage;\n          initWasmCallbacks = [resolve, reject];\n          const message: OrtWasmMessage = { type: 'init-wasm', in: env };\n\n          // if the proxy worker is loaded from a blob URL, we need to make sure the path information is not lost.\n          //\n          // when `env.wasm.wasmPaths` is not set, we need to pass the path information to the worker.\n          //\n          if (!BUILD_DEFS.ENABLE_BUNDLE_WASM_JS && !message.in!.wasm.wasmPaths && objectUrl) {\n            // for a build not bundled the wasm JS, we need to pass the path prefix to the worker.\n            // the path prefix will be used to resolve the path to both the wasm JS and the wasm file.\n            const inferredWasmPathPrefix = inferWasmPathPrefixFromScriptSrc();\n            if (inferredWasmPathPrefix) {\n              message.in!.wasm.wasmPaths = inferredWasmPathPrefix;\n            }\n          }\n\n          if (\n            BUILD_DEFS.IS_ESM &&\n            BUILD_DEFS.ENABLE_BUNDLE_WASM_JS &&\n            !message.in!.wasm.wasmPaths &&\n            (objectUrl || isEsmImportMetaUrlHardcodedAsFileUri)\n          ) {\n            // for a build bundled the wasm JS, if either of the following conditions is met:\n            // - the proxy worker is loaded from a blob URL\n            // - `import.meta.url` is a file URL, it means it is overwritten by the bundler.\n            //\n            // in either case, the path information is lost, we need to pass the path of the .wasm file to the worker.\n            // we need to use the bundler preferred URL format:\n            // new URL('filename', import.meta.url)\n            // so that the bundler can handle the file using corresponding loaders.\n            message.in!.wasm.wasmPaths = {\n              wasm: !BUILD_DEFS.DISABLE_JSEP\n                ? new URL('ort-wasm-simd-threaded.jsep.wasm', BUILD_DEFS.ESM_IMPORT_META_URL).href\n                : BUILD_DEFS.ENABLE_JSPI\n                  ? new URL('ort-wasm-simd-threaded.jspi.wasm', BUILD_DEFS.ESM_IMPORT_META_URL).href\n                  : !BUILD_DEFS.DISABLE_WEBGPU\n                    ? new URL('ort-wasm-simd-threaded.asyncify.wasm', BUILD_DEFS.ESM_IMPORT_META_URL).href\n                    : new URL('ort-wasm-simd-threaded.wasm', BUILD_DEFS.ESM_IMPORT_META_URL).href,\n            };\n          }\n          proxyWorker.postMessage(message);\n          temporaryObjectUrl = objectUrl;\n        } catch (e) {\n          reject(e);\n        }\n      }, reject);\n    });\n  } else {\n    try {\n      await initializeWebAssembly(env.wasm);\n      await core.initRuntime(env);\n      initialized = true;\n    } catch (e) {\n      aborted = true;\n      throw e;\n    } finally {\n      initializing = false;\n    }\n  }\n};\n\nexport const initializeOrtEp = async (epName: string): Promise<void> => {\n  if (!BUILD_DEFS.DISABLE_WASM_PROXY && isProxy()) {\n    ensureWorker();\n    return new Promise<void>((resolve, reject) => {\n      enqueueCallbacks('init-ep', [resolve, reject]);\n      const message: OrtWasmMessage = { type: 'init-ep', in: { epName, env } };\n      proxyWorker!.postMessage(message);\n    });\n  } else {\n    await core.initEp(env, epName);\n  }\n};\n\nexport const copyFromExternalBuffer = async (buffer: Uint8Array): Promise<SerializableInternalBuffer> => {\n  if (!BUILD_DEFS.DISABLE_WASM_PROXY && isProxy()) {\n    ensureWorker();\n    return new Promise<SerializableInternalBuffer>((resolve, reject) => {\n      enqueueCallbacks('copy-from', [resolve, reject]);\n      const message: OrtWasmMessage = { type: 'copy-from', in: { buffer } };\n      proxyWorker!.postMessage(message, [buffer.buffer]);\n    });\n  } else {\n    return core.copyFromExternalBuffer(buffer);\n  }\n};\n\nexport const createSession = async (\n  model: SerializableInternalBuffer | Uint8Array,\n  options?: InferenceSession.SessionOptions,\n): Promise<SerializableSessionMetadata> => {\n  if (!BUILD_DEFS.DISABLE_WASM_PROXY && isProxy()) {\n    // check unsupported options\n    if (options?.preferredOutputLocation) {\n      throw new Error('session option \"preferredOutputLocation\" is not supported for proxy.');\n    }\n    ensureWorker();\n    return new Promise<SerializableSessionMetadata>((resolve, reject) => {\n      enqueueCallbacks('create', [resolve, reject]);\n      const message: OrtWasmMessage = { type: 'create', in: { model, options: { ...options } } };\n      const transferable: Transferable[] = [];\n      if (model instanceof Uint8Array) {\n        transferable.push(model.buffer);\n      }\n      proxyWorker!.postMessage(message, transferable);\n    });\n  } else {\n    return core.createSession(model, options);\n  }\n};\n\nexport const releaseSession = async (sessionId: number): Promise<void> => {\n  if (!BUILD_DEFS.DISABLE_WASM_PROXY && isProxy()) {\n    ensureWorker();\n    return new Promise<void>((resolve, reject) => {\n      enqueueCallbacks('release', [resolve, reject]);\n      const message: OrtWasmMessage = { type: 'release', in: sessionId };\n      proxyWorker!.postMessage(message);\n    });\n  } else {\n    core.releaseSession(sessionId);\n  }\n};\n\nexport const run = async (\n  sessionId: number,\n  inputIndices: number[],\n  inputs: TensorMetadata[],\n  outputIndices: number[],\n  outputs: Array<TensorMetadata | null>,\n  options: InferenceSession.RunOptions,\n): Promise<TensorMetadata[]> => {\n  if (!BUILD_DEFS.DISABLE_WASM_PROXY && isProxy()) {\n    // check inputs location\n    if (inputs.some((t) => t[3] !== 'cpu')) {\n      throw new Error('input tensor on GPU is not supported for proxy.');\n    }\n    // check outputs location\n    if (outputs.some((t) => t)) {\n      throw new Error('pre-allocated output tensor is not supported for proxy.');\n    }\n    ensureWorker();\n    return new Promise<SerializableTensorMetadata[]>((resolve, reject) => {\n      enqueueCallbacks('run', [resolve, reject]);\n      const serializableInputs = inputs as SerializableTensorMetadata[]; // every input is on CPU.\n      const message: OrtWasmMessage = {\n        type: 'run',\n        in: { sessionId, inputIndices, inputs: serializableInputs, outputIndices, options },\n      };\n      proxyWorker!.postMessage(message, core.extractTransferableBuffers(serializableInputs));\n    });\n  } else {\n    return core.run(sessionId, inputIndices, inputs, outputIndices, outputs, options);\n  }\n};\n\nexport const endProfiling = async (sessionId: number): Promise<void> => {\n  if (!BUILD_DEFS.DISABLE_WASM_PROXY && isProxy()) {\n    ensureWorker();\n    return new Promise<void>((resolve, reject) => {\n      enqueueCallbacks('end-profiling', [resolve, reject]);\n      const message: OrtWasmMessage = { type: 'end-profiling', in: sessionId };\n      proxyWorker!.postMessage(message);\n    });\n  } else {\n    core.endProfiling(sessionId);\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {\n  InferenceSession,\n  InferenceSessionHandler,\n  SessionHandler,\n  Tensor,\n  TRACE_FUNC_BEGIN,\n  TRACE_FUNC_END,\n} from 'onnxruntime-common';\n\nimport { SerializableInternalBuffer, TensorMetadata } from './proxy-messages';\nimport { copyFromExternalBuffer, createSession, endProfiling, releaseSession, run } from './proxy-wrapper';\nimport { isGpuBufferSupportedType, isMLTensorSupportedType } from './wasm-common';\nimport { isNode } from './wasm-utils-env';\nimport { loadFile } from './wasm-utils-load-file';\n\nexport const encodeTensorMetadata = (tensor: Tensor, getName: () => string): TensorMetadata => {\n  switch (tensor.location) {\n    case 'cpu':\n      return [tensor.type, tensor.dims, tensor.data, 'cpu'];\n    case 'gpu-buffer':\n      return [tensor.type, tensor.dims, { gpuBuffer: tensor.gpuBuffer }, 'gpu-buffer'];\n    case 'ml-tensor':\n      return [tensor.type, tensor.dims, { mlTensor: tensor.mlTensor }, 'ml-tensor'];\n    default:\n      throw new Error(`invalid data location: ${tensor.location} for ${getName()}`);\n  }\n};\n\nexport const decodeTensorMetadata = (tensor: TensorMetadata): Tensor => {\n  switch (tensor[3]) {\n    case 'cpu':\n      return new Tensor(tensor[0], tensor[2], tensor[1]);\n    case 'gpu-buffer': {\n      const dataType = tensor[0];\n      if (!isGpuBufferSupportedType(dataType)) {\n        throw new Error(`not supported data type: ${dataType} for deserializing GPU tensor`);\n      }\n      const { gpuBuffer, download, dispose } = tensor[2];\n      return Tensor.fromGpuBuffer(gpuBuffer, { dataType, dims: tensor[1], download, dispose });\n    }\n    case 'ml-tensor': {\n      const dataType = tensor[0];\n      if (!isMLTensorSupportedType(dataType)) {\n        throw new Error(`not supported data type: ${dataType} for deserializing MLTensor tensor`);\n      }\n      const { mlTensor, download, dispose } = tensor[2];\n      return Tensor.fromMLTensor(mlTensor, { dataType, dims: tensor[1], download, dispose });\n    }\n    default:\n      throw new Error(`invalid data location: ${tensor[3]}`);\n  }\n};\n\nexport class OnnxruntimeWebAssemblySessionHandler implements InferenceSessionHandler {\n  private sessionId: number;\n\n  inputNames: readonly string[];\n  outputNames: readonly string[];\n  inputMetadata: readonly InferenceSession.ValueMetadata[];\n  outputMetadata: readonly InferenceSession.ValueMetadata[];\n\n  async fetchModelAndCopyToWasmMemory(path: string): Promise<SerializableInternalBuffer> {\n    // fetch model from url and move to wasm heap.\n    return copyFromExternalBuffer(await loadFile(path));\n  }\n\n  async loadModel(pathOrBuffer: string | Uint8Array, options?: InferenceSession.SessionOptions): Promise<void> {\n    TRACE_FUNC_BEGIN();\n    let model: Parameters<typeof createSession>[0];\n\n    if (typeof pathOrBuffer === 'string') {\n      if (isNode) {\n        // node\n        model = await loadFile(pathOrBuffer);\n      } else {\n        // browser\n        // fetch model and copy to wasm heap.\n        model = await this.fetchModelAndCopyToWasmMemory(pathOrBuffer);\n      }\n    } else {\n      model = pathOrBuffer;\n    }\n\n    [this.sessionId, this.inputNames, this.outputNames, this.inputMetadata, this.outputMetadata] = await createSession(\n      model,\n      options,\n    );\n    TRACE_FUNC_END();\n  }\n\n  async dispose(): Promise<void> {\n    return releaseSession(this.sessionId);\n  }\n\n  async run(\n    feeds: SessionHandler.FeedsType,\n    fetches: SessionHandler.FetchesType,\n    options: InferenceSession.RunOptions,\n  ): Promise<SessionHandler.ReturnType> {\n    TRACE_FUNC_BEGIN();\n    const inputArray: Tensor[] = [];\n    const inputIndices: number[] = [];\n    Object.entries(feeds).forEach((kvp) => {\n      const name = kvp[0];\n      const tensor = kvp[1];\n      const index = this.inputNames.indexOf(name);\n      if (index === -1) {\n        throw new Error(`invalid input '${name}'`);\n      }\n      inputArray.push(tensor);\n      inputIndices.push(index);\n    });\n\n    const outputArray: Array<Tensor | null> = [];\n    const outputIndices: number[] = [];\n    Object.entries(fetches).forEach((kvp) => {\n      const name = kvp[0];\n      const tensor = kvp[1];\n      const index = this.outputNames.indexOf(name);\n      if (index === -1) {\n        throw new Error(`invalid output '${name}'`);\n      }\n      outputArray.push(tensor);\n      outputIndices.push(index);\n    });\n\n    const inputs = inputArray.map((t, i) =>\n      encodeTensorMetadata(t, () => `input \"${this.inputNames[inputIndices[i]]}\"`),\n    );\n    const outputs = outputArray.map((t, i) =>\n      t ? encodeTensorMetadata(t, () => `output \"${this.outputNames[outputIndices[i]]}\"`) : null,\n    );\n\n    const results = await run(this.sessionId, inputIndices, inputs, outputIndices, outputs, options);\n\n    const resultMap: SessionHandler.ReturnType = {};\n    for (let i = 0; i < results.length; i++) {\n      resultMap[this.outputNames[outputIndices[i]]] = outputArray[i] ?? decodeTensorMetadata(results[i]);\n    }\n    TRACE_FUNC_END();\n    return resultMap;\n  }\n\n  startProfiling(): void {\n    // TODO: implement profiling\n  }\n\n  endProfiling(): void {\n    void endProfiling(this.sessionId);\n  }\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Backend, env, InferenceSession, InferenceSessionHandler } from 'onnxruntime-common';\n\nimport { initializeOrtEp, initializeWebAssemblyAndOrtRuntime } from './wasm/proxy-wrapper';\nimport { OnnxruntimeWebAssemblySessionHandler } from './wasm/session-handler-inference';\n\n/**\n * This function initializes all flags for WebAssembly.\n *\n * Those flags are accessible from `ort.env.wasm`. Users are allow to set those flags before the first inference session\n * being created, to override default value.\n */\nexport const initializeFlags = (): void => {\n  if (typeof env.wasm.initTimeout !== 'number' || env.wasm.initTimeout < 0) {\n    env.wasm.initTimeout = 0;\n  }\n\n  const simd = env.wasm.simd;\n  if (typeof simd !== 'boolean' && simd !== undefined && simd !== 'fixed' && simd !== 'relaxed') {\n    // eslint-disable-next-line no-console\n    console.warn(\n      `Property \"env.wasm.simd\" is set to unknown value \"${simd}\". Reset it to \\`false\\` and ignore SIMD feature checking.`,\n    );\n    env.wasm.simd = false;\n  }\n\n  if (typeof env.wasm.proxy !== 'boolean') {\n    env.wasm.proxy = false;\n  }\n\n  if (typeof env.wasm.trace !== 'boolean') {\n    env.wasm.trace = false;\n  }\n\n  if (typeof env.wasm.numThreads !== 'number' || !Number.isInteger(env.wasm.numThreads) || env.wasm.numThreads <= 0) {\n    // The following logic only applies when `ort.env.wasm.numThreads` is not set by user. We will always honor user's\n    // setting if it is provided.\n\n    // Browser: when crossOriginIsolated is false, SharedArrayBuffer is not available so WebAssembly threads will not\n    // work. In this case, we will set numThreads to 1.\n    //\n    // There is an exception: when the browser is configured to force-enable SharedArrayBuffer (e.g. Chromuim with\n    // --enable-features=SharedArrayBuffer), it is possible that `self.crossOriginIsolated` is false and\n    // SharedArrayBuffer is available at the same time. This is usually for testing. In this case,  we will still set\n    // numThreads to 1 here. If we want to enable multi-threading in test, we should set `ort.env.wasm.numThreads` to a\n    // value greater than 1.\n    if (typeof self !== 'undefined' && !self.crossOriginIsolated) {\n      env.wasm.numThreads = 1;\n    } else {\n      const numCpuLogicalCores =\n        typeof navigator === 'undefined' ? require('node:os').cpus().length : navigator.hardwareConcurrency;\n      env.wasm.numThreads = Math.min(4, Math.ceil((numCpuLogicalCores || 1) / 2));\n    }\n  }\n};\n\nexport class OnnxruntimeWebAssemblyBackend implements Backend {\n  /**\n   * This function initializes the WebAssembly backend.\n   *\n   * This function will be called only once for each backend name. It will be called the first time when\n   * `ort.InferenceSession.create()` is called with a registered backend name.\n   *\n   * @param backendName - the registered backend name.\n   */\n  async init(backendName: string): Promise<void> {\n    // populate wasm flags\n    initializeFlags();\n\n    // init wasm\n    await initializeWebAssemblyAndOrtRuntime();\n\n    // performe EP specific initialization\n    await initializeOrtEp(backendName);\n  }\n  createInferenceSessionHandler(\n    path: string,\n    options?: InferenceSession.SessionOptions,\n  ): Promise<InferenceSessionHandler>;\n  createInferenceSessionHandler(\n    buffer: Uint8Array,\n    options?: InferenceSession.SessionOptions,\n  ): Promise<InferenceSessionHandler>;\n  async createInferenceSessionHandler(\n    pathOrBuffer: string | Uint8Array,\n    options?: InferenceSession.SessionOptions,\n  ): Promise<InferenceSessionHandler> {\n    const handler = new OnnxruntimeWebAssemblySessionHandler();\n    await handler.loadModel(pathOrBuffer, options);\n    return handler;\n  }\n}\n\nexport const wasmBackend = new OnnxruntimeWebAssemblyBackend();\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n/* eslint-disable @typescript-eslint/no-var-requires, @typescript-eslint/no-require-imports */\n\n// We use \"require\" instead of \"import\" here because import statement must be put in top level. Our current code does\n// not allow bundler to tree-shaking code as expected because some codes are treated as having side effects.\n// So we import code inside the if-clause to allow bundler remove the code safely.\n\nexport * from 'onnxruntime-common';\nimport * as ort from 'onnxruntime-common';\nexport default ort;\n\nimport { registerBackend, env } from 'onnxruntime-common';\nimport { version } from './version';\n\nif (!BUILD_DEFS.DISABLE_WEBGL) {\n  const onnxjsBackend = require('./backend-onnxjs').onnxjsBackend;\n  registerBackend('webgl', onnxjsBackend, -10);\n}\n\nif (!BUILD_DEFS.DISABLE_JSEP && !BUILD_DEFS.DISABLE_WEBGPU) {\n  throw new Error(\n    'The current build is specified to enable both JSEP and WebGPU EP. This is not a valid configuration. ' +\n      'JSEP and WebGPU EPs cannot be enabled at the same time.',\n  );\n}\n\nif (!BUILD_DEFS.DISABLE_WEBNN && BUILD_DEFS.DISABLE_JSEP && BUILD_DEFS.DISABLE_WEBGPU) {\n  throw new Error(\n    'The current build is specified to enable WebNN EP without JSEP or WebGPU EP. This is not a valid configuration. ' +\n      'WebNN EP requires either JSEP or WebGPU EP to be enabled.',\n  );\n}\n\nif (!BUILD_DEFS.DISABLE_WASM) {\n  const wasmBackend = require('./backend-wasm').wasmBackend;\n  if (!BUILD_DEFS.DISABLE_JSEP || !BUILD_DEFS.DISABLE_WEBGPU) {\n    registerBackend('webgpu', wasmBackend, 5);\n  }\n  if (!BUILD_DEFS.DISABLE_WEBNN) {\n    registerBackend('webnn', wasmBackend, 5);\n  }\n  registerBackend('cpu', wasmBackend, 10);\n  registerBackend('wasm', wasmBackend, 10);\n}\n\nObject.defineProperty(env.versions, 'web', { value: version, enumerable: true });\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n// This file is generated by /js/scripts/update-version.ts\n// Do not modify file content manually.\n\nexport const version = '1.26.0';\n"],
  "mappings": "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",
  "names": ["i", "env", "Float16Array", "Tensor", "Tensor", "InferenceSession", "InferenceSession", "Tensor", "env", "env", "wasm", "wasm", "wasm", "location", "tensor", "env", "mlContextIndex", "wasm", "env", "wasm", "location", "index", "tensor", "errorCode", "i", "initializing", "initialized", "aborted", "copyFromExternalBuffer", "createSession", "releaseSession", "run", "endProfiling", "env", "Tensor", "copyFromExternalBuffer", "createSession", "releaseSession", "run", "endProfiling", "env", "version", "wasmBackend", "env", "version"]
}
