3554 lines
545 KiB
JavaScript
3554 lines
545 KiB
JavaScript
/*!
|
|
* ONNX Runtime Web v1.22.0
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License.
|
|
*/
|
|
"use strict";
|
|
var ort = (() => {
|
|
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.22.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;
|
|
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);
|
|
};
|
|
}
|
|
});
|
|
|
|
// 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();
|
|
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_FUNC_END();
|
|
return returnValue;
|
|
}
|
|
async release() {
|
|
return this.handler.dispose();
|
|
}
|
|
static async create(arg0, arg1, arg2, arg3) {
|
|
TRACE_FUNC_BEGIN();
|
|
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_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_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: false ? "module" : "classic", name: WORKER_NAME });
|
|
}
|
|
});
|
|
|
|
// web/lib/wasm/wasm-utils-import.ts
|
|
var origin, 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;
|
|
getScriptSrc = () => {
|
|
if (isNode) {
|
|
return void 0;
|
|
}
|
|
if (false) {
|
|
if (isEsmImportMetaUrlHardcodedAsFileUri) {
|
|
const URL2 = URL;
|
|
return new URL(new URL2("ort.wasm.js", void 0).href, origin).href;
|
|
}
|
|
return void 0;
|
|
}
|
|
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 */
|
|
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 : null).default
|
|
) : void 0;
|
|
importWasmModule = async (urlOverride, prefixOverride, isMultiThreaded) => {
|
|
if (!urlOverride && !prefixOverride && embeddedWasmModule && scriptSrc && isSameOrigin(scriptSrc)) {
|
|
return [void 0, embeddedWasmModule];
|
|
} else {
|
|
const wasmModuleFilename = false ? "ort-wasm-simd-threaded.jsep.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 (e) {
|
|
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 (e) {
|
|
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 (e) {
|
|
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.");
|
|
}
|
|
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);
|
|
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;
|
|
} 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 serverity 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, 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 "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}.`);
|
|
}
|
|
};
|
|
setExecutionProviders = async (sessionOptionsHandle, executionProviders, allocs) => {
|
|
for (const ep of executionProviders) {
|
|
let epName = typeof ep === "string" ? ep : ep.name;
|
|
const epOptions = [];
|
|
switch (epName) {
|
|
case "webnn":
|
|
epName = "WEBNN";
|
|
if (typeof ep !== "string") {
|
|
const webnnOptions = ep;
|
|
const deviceType = webnnOptions?.deviceType;
|
|
if (deviceType) {
|
|
appendSessionConfig(sessionOptionsHandle, "deviceType", deviceType, allocs);
|
|
}
|
|
}
|
|
break;
|
|
case "webgpu":
|
|
if (false) {
|
|
epName = "WebGPU";
|
|
let customDevice;
|
|
if (typeof ep !== "string") {
|
|
const customOptions = ep;
|
|
if (customOptions.device) {
|
|
if (typeof GPUDevice !== "undefined" && customOptions.device instanceof GPUDevice) {
|
|
customDevice = customOptions.device;
|
|
} else {
|
|
throw new Error("Invalid GPU device set in WebGPU EP options.");
|
|
}
|
|
}
|
|
}
|
|
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 serverity 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.executionProviders, 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/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_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?.();
|
|
if (epName === "webgpu" && false) {
|
|
getInstance().webgpuInit((device) => {
|
|
env3.webgpu.device = device;
|
|
});
|
|
}
|
|
if (false) {
|
|
const initJsep = null.init;
|
|
if (epName === "webgpu" && true) {
|
|
if (typeof navigator === "undefined" || !navigator.gpu) {
|
|
throw new Error("WebGPU is not supported in current environment");
|
|
}
|
|
let adapter = env3.webgpu.adapter;
|
|
if (!adapter) {
|
|
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}"`);
|
|
}
|
|
adapter = await navigator.gpu.requestAdapter({ powerPreference, forceFallbackAdapter });
|
|
if (!adapter) {
|
|
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 adapter.limits !== "object" || typeof adapter.features !== "object" || typeof adapter.requestDevice !== "function") {
|
|
throw new Error("Invalid GPU adapter set in `env.webgpu.adapter`. It must be a GPUAdapter object.");
|
|
}
|
|
}
|
|
await initJsep("webgpu", getInstance(), env3, adapter);
|
|
}
|
|
if (epName === "webnn") {
|
|
if (typeof navigator === "undefined" || !navigator.ml) {
|
|
throw new Error("WebNN is not supported in current environment");
|
|
}
|
|
await initJsep("webnn", getInstance(), env3);
|
|
}
|
|
}
|
|
};
|
|
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 (false) {
|
|
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 (false) {
|
|
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 (false) {
|
|
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 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);
|
|
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
|
|
);
|
|
}
|
|
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 (false) {
|
|
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}).`
|
|
);
|
|
}
|
|
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) {
|
|
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}.`);
|
|
}
|
|
}
|
|
}
|
|
activeSessions.set(sessionId, [
|
|
sessionHandle,
|
|
inputNamesUTF8Encoded,
|
|
outputNamesUTF8Encoded,
|
|
ioBindingState,
|
|
enableGraphCapture,
|
|
true
|
|
]);
|
|
}
|
|
wasm2.jsepOnRunStart?.(sessionHandle);
|
|
wasm2.webnnOnRunStart?.(sessionHandle);
|
|
let errorCode;
|
|
if (false) {
|
|
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 = [];
|
|
for (let i = 0; i < outputCount; i++) {
|
|
const tensor = Number(wasm2.getValue(outputValuesOffset + i * ptrSize, "*"));
|
|
if (tensor === outputTensorHandles[i]) {
|
|
output.push(outputTensors[i]);
|
|
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 = false ? 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 (false) {
|
|
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;
|
|
}
|
|
return output;
|
|
} finally {
|
|
wasm2.webnnOnRunEnd?.(sessionHandle);
|
|
wasm2.stackRestore(beforeRunStack);
|
|
if (false) {
|
|
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", void 0).href : new URL("ort-wasm-simd-threaded.wasm", void 0).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
|
|
var index_exports = {};
|
|
__export(index_exports, {
|
|
InferenceSession: () => InferenceSession2,
|
|
TRACE: () => TRACE,
|
|
TRACE_FUNC_BEGIN: () => TRACE_FUNC_BEGIN,
|
|
TRACE_FUNC_END: () => TRACE_FUNC_END,
|
|
Tensor: () => Tensor2,
|
|
default: () => index_default,
|
|
env: () => env2,
|
|
registerBackend: () => registerBackend
|
|
});
|
|
init_esm();
|
|
init_esm();
|
|
init_esm();
|
|
|
|
// web/lib/version.ts
|
|
var version2 = "1.22.0";
|
|
|
|
// web/lib/index.ts
|
|
var index_default = esm_exports;
|
|
if (false) {
|
|
const onnxjsBackend = null.onnxjsBackend;
|
|
registerBackend("webgl", onnxjsBackend, -10);
|
|
}
|
|
if (true) {
|
|
const wasmBackend2 = (init_backend_wasm(), __toCommonJS(backend_wasm_exports)).wasmBackend;
|
|
if (false) {
|
|
registerBackend("webgpu", wasmBackend2, 5);
|
|
registerBackend("webnn", wasmBackend2, 5);
|
|
}
|
|
registerBackend("cpu", wasmBackend2, 10);
|
|
registerBackend("wasm", wasmBackend2, 10);
|
|
}
|
|
Object.defineProperty(env2.versions, "web", { value: version2, enumerable: true });
|
|
return __toCommonJS(index_exports);
|
|
})();
|
|
typeof exports=="object"&&typeof module=="object"&&(module.exports=ort);
|
|
//# 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/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.22.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     */\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     */\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        // eslint-disable-next-line @typescript-eslint/restrict-plus-operands\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", "// 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 } 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    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_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    // 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_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' | '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    preferredLayout?: 'NCHW' | 'NHWC';\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 */ 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          : '../../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): Promise<[undefined | string, EmscriptenModuleFactory<OrtWasmModule>]> => {\n  if (!urlOverride && !prefixOverride && embeddedWasmModule && scriptSrc && isSameOrigin(scriptSrc)) {\n    return [undefined, embeddedWasmModule];\n  } else {\n    const wasmModuleFilename = !BUILD_DEFS.DISABLE_JSEP\n      ? 'ort-wasm-simd-threaded.jsep.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 (e) {\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 (e) {\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 (e) {\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  // 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(mjsPathOverride, wasmPrefixOverride, numThreads > 1);\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      } 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 serverity 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 '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  executionProviders: readonly InferenceSession.ExecutionProviderConfig[],\n  allocs: number[],\n): Promise<void> => {\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        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.USE_WEBGPU_EP) {\n          epName = 'WebGPU';\n          let customDevice: GPUDevice | undefined;\n\n          if (typeof ep !== 'string') {\n            const customOptions = ep as unknown as { device: GPUDevice };\n            if (customOptions.device) {\n              if (typeof GPUDevice !== 'undefined' && customOptions.device instanceof GPUDevice) {\n                customDevice = customOptions.device;\n              } else {\n                throw new Error('Invalid GPU device set in WebGPU EP options.');\n              }\n            }\n\n            // TODO: handle more options\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 serverity 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.executionProviders, 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        // eslint-disable-next-line no-constant-condition\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\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 } 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  if (epName === 'webgpu' && BUILD_DEFS.USE_WEBGPU_EP) {\n    getInstance().webgpuInit!((device) => {\n      env.webgpu.device = device;\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' && !BUILD_DEFS.USE_WEBGPU_EP) {\n      // perform WebGPU availability check\n      if (typeof navigator === 'undefined' || !navigator.gpu) {\n        throw new Error('WebGPU is not supported in current environment');\n      }\n\n      let adapter = env.webgpu.adapter as GPUAdapter | null;\n      if (!adapter) {\n        // if adapter is not set, request a new adapter.\n        const powerPreference = env.webgpu.powerPreference;\n        if (\n          powerPreference !== undefined &&\n          powerPreference !== 'low-power' &&\n          powerPreference !== 'high-performance'\n        ) {\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        adapter = await navigator.gpu.requestAdapter({ powerPreference, forceFallbackAdapter });\n        if (!adapter) {\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 adapter.limits !== 'object' ||\n          typeof adapter.features !== 'object' ||\n          typeof adapter.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      await initJsep('webgpu', getInstance(), env, adapter);\n    }\n    if (epName === 'webnn') {\n      // perform WebNN availability check\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      await initJsep('webnn', getInstance(), env);\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) {\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 &&\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.USE_WEBGPU_EP) {\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\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    // 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\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 && 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      // 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. bind the tensor.\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      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 && 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    for (let i = 0; i < outputCount; i++) {\n      const tensor = Number(wasm.getValue(outputValuesOffset + i * ptrSize, '*'));\n      if (tensor === outputTensorHandles[i]) {\n        // output tensor is pre-allocated. no need to copy data.\n        output.push(outputTensors[i]!);\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.USE_WEBGPU_EP ? 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.USE_WEBGPU_EP) {\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    return output;\n  } finally {\n    wasm.webnnOnRunEnd?.(sessionHandle);\n\n    wasm.stackRestore(beforeRunStack);\n\n    if (BUILD_DEFS.USE_WEBGPU_EP) {\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 overwriten 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                : 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_WASM) {\n  const wasmBackend = require('./backend-wasm').wasmBackend;\n  if (!BUILD_DEFS.DISABLE_JSEP) {\n    registerBackend('webgpu', wasmBackend, 5);\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.22.0';\n"],
  "mappings": "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",
  "names": ["i", "env", "Float16Array", "Tensor", "Tensor", "InferenceSession", "InferenceSession", "Tensor", "env", "env", "wasm", "wasm", "wasm", "location", "env", "wasm", "location", "index", "tensor", "errorCode", "i", "initializing", "initialized", "aborted", "copyFromExternalBuffer", "createSession", "releaseSession", "run", "endProfiling", "env", "Tensor", "copyFromExternalBuffer", "createSession", "releaseSession", "run", "endProfiling", "env", "InferenceSession", "Tensor", "env", "version", "wasmBackend", "env", "version"]
}

|