diff --git "a/demo/ort-phi3/dist/esm/ort.wasm-core.js" "b/demo/ort-phi3/dist/esm/ort.wasm-core.js" new file mode 100644--- /dev/null +++ "b/demo/ort-phi3/dist/esm/ort.wasm-core.js" @@ -0,0 +1,3804 @@ +/*! + * ONNX Runtime Web v1.18.0 + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. + */ +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __esm = (fn, res) => function __init() { + return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res; +}; +var __commonJS = (cb, mod) => function __require() { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; +}; +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.18.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, 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 (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 }); + }; + 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] + ]); + 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 isFloat16ArrayAvailable = typeof Float16Array !== "undefined" && Float16Array.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", Float16Array); + NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.set(Float16Array, "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 + }); + 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") { + 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; + } + 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) { + throw new TypeError("Creating a float16 tensor from number array is not supported. Please use Uint16Array 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 { + 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 { + 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) { + 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 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; + } + // #endregion + // #region methods + async getData(releaseData) { + this.ensureValid(); + switch (this.dataLocation) { + case "cpu": + case "cpu-pinned": + return this.data; + case "texture": + case "gpu-buffer": { + 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.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; + } + }; + } +}); + +// 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/training-session-impl.js +var noBackendErrMsg, TrainingSession; +var init_training_session_impl = __esm({ + "common/dist/esm/training-session-impl.js"() { + "use strict"; + init_backend_impl(); + init_tensor(); + noBackendErrMsg = "Training backend could not be resolved. Make sure you're using the correct configuration & WebAssembly files."; + TrainingSession = class _TrainingSession { + constructor(handler, hasOptimizerModel, hasEvalModel) { + this.handler = handler; + this.hasOptimizerModel = hasOptimizerModel; + this.hasEvalModel = hasEvalModel; + } + get trainingInputNames() { + return this.handler.inputNames; + } + get trainingOutputNames() { + return this.handler.outputNames; + } + get evalInputNames() { + if (this.hasEvalModel) { + return this.handler.evalInputNames; + } else { + throw new Error("This training session has no evalModel loaded."); + } + } + get evalOutputNames() { + if (this.hasEvalModel) { + return this.handler.evalOutputNames; + } else { + throw new Error("This training session has no evalModel loaded."); + } + } + static async create(trainingOptions, sessionOptions) { + const evalModel = trainingOptions.evalModel || ""; + const optimizerModel = trainingOptions.optimizerModel || ""; + const options = sessionOptions || {}; + const [backend, optionsWithValidatedEPs] = await resolveBackendAndExecutionProviders(options); + if (backend.createTrainingSessionHandler) { + const handler = await backend.createTrainingSessionHandler(trainingOptions.checkpointState, trainingOptions.trainModel, evalModel, optimizerModel, optionsWithValidatedEPs); + return new _TrainingSession(handler, !!trainingOptions.optimizerModel, !!trainingOptions.evalModel); + } else { + throw new Error(noBackendErrMsg); + } + } + /** + * Helper function for runTrainStep and future runStep methods that handles the type-narrowing conversion from + * the given parameters to SessionHandler.FetchesType and RunOptions. + * + * @param inputNames the feeds object is checked that they contain all input names in the provided list of input + * names. + * @param outputNames the fetches object is checked that their keys match up with valid names in the list of output + * names. + * @param feeds the required input + * @param arg1 narrowed & converted into the SessionHandler.FetchesType or RunOptions object + * @param arg2 optional RunOptions object. + * @returns + */ + typeNarrowingForRunStep(inputNames, outputNames, feeds, arg1, arg2) { + 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 (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 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 inputNames) { + if (typeof feeds[name] === "undefined") { + throw new Error(`input '${name}' is missing in 'feeds'.`); + } + } + if (isFetchesEmpty) { + for (const name of outputNames) { + fetches[name] = null; + } + } + return [fetches, options]; + } + /** + * Helper method for runTrainStep and any other runStep methods. Takes the ReturnType result from the SessionHandler + * and changes it into a map of Tensors. + * + * @param results + * @returns + */ + convertHandlerReturnTypeToMapOfTensors(results) { + 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); + } + } + } + return returnValue; + } + async lazyResetGrad() { + await this.handler.lazyResetGrad(); + } + async runTrainStep(feeds, arg1, arg2) { + const [fetches, options] = this.typeNarrowingForRunStep(this.trainingInputNames, this.trainingOutputNames, feeds, arg1, arg2); + const results = await this.handler.runTrainStep(feeds, fetches, options); + return this.convertHandlerReturnTypeToMapOfTensors(results); + } + async runOptimizerStep(options) { + if (this.hasOptimizerModel) { + await this.handler.runOptimizerStep(options || {}); + } else { + throw new Error("This TrainingSession has no OptimizerModel loaded."); + } + } + async runEvalStep(feeds, arg1, arg2) { + if (this.hasEvalModel) { + const [fetches, options] = this.typeNarrowingForRunStep(this.evalInputNames, this.evalOutputNames, feeds, arg1, arg2); + const results = await this.handler.runEvalStep(feeds, fetches, options); + return this.convertHandlerReturnTypeToMapOfTensors(results); + } else { + throw new Error("This TrainingSession has no EvalModel loaded."); + } + } + async getParametersSize(trainableOnly = true) { + return this.handler.getParametersSize(trainableOnly); + } + async loadParametersBuffer(array, trainableOnly = true) { + const paramsSize = await this.getParametersSize(trainableOnly); + if (array.length !== 4 * paramsSize) { + throw new Error("Size of the buffer passed into loadParametersBuffer must match the number of parameters in the model. Please use getParametersSize method to check."); + } + return this.handler.loadParametersBuffer(array, trainableOnly); + } + async getContiguousParameters(trainableOnly = true) { + return this.handler.getContiguousParameters(trainableOnly); + } + async release() { + return this.handler.dispose(); + } + }; + } +}); + +// common/dist/esm/training-session.js +var TrainingSession2; +var init_training_session = __esm({ + "common/dist/esm/training-session.js"() { + "use strict"; + init_training_session_impl(); + TrainingSession2 = TrainingSession; + } +}); + +// 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, + TrainingSession: () => TrainingSession2, + 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(); + init_training_session(); + } +}); + +// nodejs-ignore:node:os +var cpus; +var init_node_os = __esm({ + "nodejs-ignore:node:os"() { + cpus = void 0; + } +}); + +// nodejs-ignore:fs +var fs_exports = {}; +__export(fs_exports, { + createReadStream: () => createReadStream, + readFile: () => readFile, + readFileSync: () => readFileSync +}); +var readFile, readFileSync, createReadStream; +var init_fs = __esm({ + "nodejs-ignore:fs"() { + readFile = void 0; + readFileSync = void 0; + createReadStream = void 0; + } +}); + +// nodejs-ignore:path +var path_exports = {}; +__export(path_exports, { + join: () => join +}); +var join; +var init_path = __esm({ + "nodejs-ignore:path"() { + join = void 0; + } +}); + +// web/lib/wasm/binding/ort-wasm.js +var require_ort_wasm = __commonJS({ + "web/lib/wasm/binding/ort-wasm.js"(exports, module) { + "use strict"; + var ortWasm = (() => { + var _scriptDir = typeof document !== "undefined" && document.currentScript ? document.currentScript.src : void 0; + if (typeof __filename !== "undefined") + _scriptDir = _scriptDir || __filename; + return function(moduleArg = {}) { + var e = moduleArg, k, l; + e.ready = new Promise((a, b) => { + k = a; + l = b; + }); + var q = Object.assign({}, e), v = "./this.program", aa = "object" == typeof window, x = "function" == typeof importScripts, ba = "object" == typeof process && "object" == typeof process.versions && "string" == typeof process.versions.node, y = "", A, B, C; + if (ba) { + var fs = (init_fs(), __toCommonJS(fs_exports)), D = (init_path(), __toCommonJS(path_exports)); + y = x ? D.dirname(y) + "/" : __dirname + "/"; + A = (a, b) => { + a = a.startsWith("file://") ? new URL(a) : D.normalize(a); + return fs.readFileSync(a, b ? void 0 : "utf8"); + }; + C = (a) => { + a = A(a, true); + a.buffer || (a = new Uint8Array(a)); + return a; + }; + B = (a, b, c, f = true) => { + a = a.startsWith("file://") ? new URL(a) : D.normalize(a); + fs.readFile(a, f ? void 0 : "utf8", (g, h) => { + g ? c(g) : b(f ? h.buffer : h); + }); + }; + !e.thisProgram && 1 < process.argv.length && (v = process.argv[1].replace(/\\/g, "/")); + process.argv.slice(2); + e.inspect = () => "[Emscripten Module object]"; + } else if (aa || x) + x ? y = self.location.href : "undefined" != typeof document && document.currentScript && (y = document.currentScript.src), _scriptDir && (y = _scriptDir), 0 !== y.indexOf("blob:") ? y = y.substr(0, y.replace(/[?#].*/, "").lastIndexOf("/") + 1) : y = "", A = (a) => { + var b = new XMLHttpRequest(); + b.open("GET", a, false); + b.send(null); + return b.responseText; + }, x && (C = (a) => { + var b = new XMLHttpRequest(); + b.open("GET", a, false); + b.responseType = "arraybuffer"; + b.send(null); + return new Uint8Array(b.response); + }), B = (a, b, c) => { + var f = new XMLHttpRequest(); + f.open("GET", a, true); + f.responseType = "arraybuffer"; + f.onload = () => { + 200 == f.status || 0 == f.status && f.response ? b(f.response) : c(); + }; + f.onerror = c; + f.send(null); + }; + var ca = e.print || console.log.bind(console), E = e.printErr || console.error.bind(console); + Object.assign(e, q); + q = null; + e.thisProgram && (v = e.thisProgram); + var F; + e.wasmBinary && (F = e.wasmBinary); + var noExitRuntime = e.noExitRuntime || true; + "object" != typeof WebAssembly && G("no native wasm support detected"); + var H, I, da = false, J, K, L, M; + function ea() { + var a = H.buffer; + e.HEAP8 = J = new Int8Array(a); + e.HEAP16 = new Int16Array(a); + e.HEAP32 = L = new Int32Array(a); + e.HEAPU8 = K = new Uint8Array(a); + e.HEAPU16 = new Uint16Array(a); + e.HEAPU32 = M = new Uint32Array(a); + e.HEAPF32 = new Float32Array(a); + e.HEAPF64 = new Float64Array(a); + } + var fa = [], ha = [], ia = []; + function ja() { + var a = e.preRun.shift(); + fa.unshift(a); + } + var N = 0, O = null, P = null; + function G(a) { + if (e.onAbort) + e.onAbort(a); + a = "Aborted(" + a + ")"; + E(a); + da = true; + a = new WebAssembly.RuntimeError(a + ". Build with -sASSERTIONS for more info."); + l(a); + throw a; + } + function ka(a) { + return a.startsWith("data:application/octet-stream;base64,"); + } + var Q; + Q = "ort-wasm.wasm"; + if (!ka(Q)) { + var la = Q; + Q = e.locateFile ? e.locateFile(la, y) : y + la; + } + function ma(a) { + if (a == Q && F) + return new Uint8Array(F); + if (C) + return C(a); + throw "both async and sync fetching of the wasm failed"; + } + function na(a) { + if (!F && (aa || x)) { + if ("function" == typeof fetch && !a.startsWith("file://")) + return fetch(a, { credentials: "same-origin" }).then((b) => { + if (!b.ok) + throw "failed to load wasm binary file at '" + a + "'"; + return b.arrayBuffer(); + }).catch(() => ma(a)); + if (B) + return new Promise((b, c) => { + B(a, (f) => b(new Uint8Array(f)), c); + }); + } + return Promise.resolve().then(() => ma(a)); + } + function oa(a, b, c) { + return na(a).then((f) => WebAssembly.instantiate(f, b)).then((f) => f).then(c, (f) => { + E("failed to asynchronously prepare wasm: " + f); + G(f); + }); + } + function pa(a, b) { + var c = Q; + return F || "function" != typeof WebAssembly.instantiateStreaming || ka(c) || c.startsWith("file://") || ba || "function" != typeof fetch ? oa(c, a, b) : fetch(c, { credentials: "same-origin" }).then((f) => WebAssembly.instantiateStreaming(f, a).then(b, function(g) { + E("wasm streaming compile failed: " + g); + E("falling back to ArrayBuffer instantiation"); + return oa(c, a, b); + })); + } + var R, S = (a) => { + for (; 0 < a.length; ) + a.shift()(e); + }; + function qa(a) { + this.va = a - 24; + this.Ea = function(b) { + M[this.va + 4 >> 2 >>> 0] = b; + }; + this.za = function(b) { + M[this.va + 8 >> 2 >>> 0] = b; + }; + this.xa = function(b, c) { + this.ya(); + this.Ea(b); + this.za(c); + }; + this.ya = function() { + M[this.va + 16 >> 2 >>> 0] = 0; + }; + } + var ra = 0, sa = 0, ta = "undefined" != typeof TextDecoder ? new TextDecoder("utf8") : void 0, ua = (a, b, c) => { + b >>>= 0; + var f = b + c; + for (c = b; a[c] && !(c >= f); ) + ++c; + if (16 < c - b && a.buffer && ta) + return ta.decode(a.subarray(b, c)); + for (f = ""; b < c; ) { + var g = a[b++]; + if (g & 128) { + var h = a[b++] & 63; + if (192 == (g & 224)) + f += String.fromCharCode((g & 31) << 6 | h); + else { + var m = a[b++] & 63; + g = 224 == (g & 240) ? (g & 15) << 12 | h << 6 | m : (g & 7) << 18 | h << 12 | m << 6 | a[b++] & 63; + 65536 > g ? f += String.fromCharCode(g) : (g -= 65536, f += String.fromCharCode(55296 | g >> 10, 56320 | g & 1023)); + } + } else + f += String.fromCharCode(g); + } + return f; + }, T = (a, b) => (a >>>= 0) ? ua(K, a, b) : "", U = (a) => { + for (var b = 0, c = 0; c < a.length; ++c) { + var f = a.charCodeAt(c); + 127 >= f ? b++ : 2047 >= f ? b += 2 : 55296 <= f && 57343 >= f ? (b += 4, ++c) : b += 3; + } + return b; + }, V = (a, b, c, f) => { + c >>>= 0; + if (!(0 < f)) + return 0; + var g = c; + f = c + f - 1; + for (var h = 0; h < a.length; ++h) { + var m = a.charCodeAt(h); + if (55296 <= m && 57343 >= m) { + var r = a.charCodeAt(++h); + m = 65536 + ((m & 1023) << 10) | r & 1023; + } + if (127 >= m) { + if (c >= f) + break; + b[c++ >>> 0] = m; + } else { + if (2047 >= m) { + if (c + 1 >= f) + break; + b[c++ >>> 0] = 192 | m >> 6; + } else { + if (65535 >= m) { + if (c + 2 >= f) + break; + b[c++ >>> 0] = 224 | m >> 12; + } else { + if (c + 3 >= f) + break; + b[c++ >>> 0] = 240 | m >> 18; + b[c++ >>> 0] = 128 | m >> 12 & 63; + } + b[c++ >>> 0] = 128 | m >> 6 & 63; + } + b[c++ >>> 0] = 128 | m & 63; + } + } + b[c >>> 0] = 0; + return c - g; + }, W = (a) => 0 === a % 4 && (0 !== a % 100 || 0 === a % 400), va = [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335], wa = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334], Ba = (a) => { + var b = U(a) + 1, c = Aa(b); + c && V(a, K, c, b); + return c; + }, X = {}, Ca = () => { + if (!Y) { + var a = { USER: "web_user", LOGNAME: "web_user", PATH: "/", PWD: "/", HOME: "/home/web_user", LANG: ("object" == typeof navigator && navigator.languages && navigator.languages[0] || "C").replace( + "-", + "_" + ) + ".UTF-8", _: v || "./this.program" }, b; + for (b in X) + void 0 === X[b] ? delete a[b] : a[b] = X[b]; + var c = []; + for (b in a) + c.push(`${b}=${a[b]}`); + Y = c; + } + return Y; + }, Y, Da = [null, [], []], Ea = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31], Fa = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]; + function Ga(a) { + var b = Array(U(a) + 1); + V(a, b, 0, b.length); + return b; + } + function Ha(a, b, c, f) { + function g(d, n, p) { + for (d = "number" == typeof d ? d.toString() : d || ""; d.length < n; ) + d = p[0] + d; + return d; + } + function h(d, n) { + return g(d, n, "0"); + } + function m(d, n) { + function p(xa) { + return 0 > xa ? -1 : 0 < xa ? 1 : 0; + } + var z; + 0 === (z = p(d.getFullYear() - n.getFullYear())) && 0 === (z = p(d.getMonth() - n.getMonth())) && (z = p(d.getDate() - n.getDate())); + return z; + } + function r(d) { + switch (d.getDay()) { + case 0: + return new Date(d.getFullYear() - 1, 11, 29); + case 1: + return d; + case 2: + return new Date(d.getFullYear(), 0, 3); + case 3: + return new Date( + d.getFullYear(), + 0, + 2 + ); + case 4: + return new Date(d.getFullYear(), 0, 1); + case 5: + return new Date(d.getFullYear() - 1, 11, 31); + case 6: + return new Date(d.getFullYear() - 1, 11, 30); + } + } + function w(d) { + var n = d.ra; + for (d = new Date(new Date(d.sa + 1900, 0, 1).getTime()); 0 < n; ) { + var p = d.getMonth(), z = (W(d.getFullYear()) ? Ea : Fa)[p]; + if (n > z - d.getDate()) + n -= z - d.getDate() + 1, d.setDate(1), 11 > p ? d.setMonth(p + 1) : (d.setMonth(0), d.setFullYear(d.getFullYear() + 1)); + else { + d.setDate(d.getDate() + n); + break; + } + } + p = new Date(d.getFullYear() + 1, 0, 4); + n = r(new Date( + d.getFullYear(), + 0, + 4 + )); + p = r(p); + return 0 >= m(n, d) ? 0 >= m(p, d) ? d.getFullYear() + 1 : d.getFullYear() : d.getFullYear() - 1; + } + a >>>= 0; + b >>>= 0; + c >>>= 0; + f >>>= 0; + var t = L[f + 40 >> 2 >>> 0]; + f = { Ca: L[f >> 2 >>> 0], Ba: L[f + 4 >> 2 >>> 0], ta: L[f + 8 >> 2 >>> 0], wa: L[f + 12 >> 2 >>> 0], ua: L[f + 16 >> 2 >>> 0], sa: L[f + 20 >> 2 >>> 0], ma: L[f + 24 >> 2 >>> 0], ra: L[f + 28 >> 2 >>> 0], Fa: L[f + 32 >> 2 >>> 0], Aa: L[f + 36 >> 2 >>> 0], Da: t ? T(t) : "" }; + c = T(c); + t = { + "%c": "%a %b %d %H:%M:%S %Y", + "%D": "%m/%d/%y", + "%F": "%Y-%m-%d", + "%h": "%b", + "%r": "%I:%M:%S %p", + "%R": "%H:%M", + "%T": "%H:%M:%S", + "%x": "%m/%d/%y", + "%X": "%H:%M:%S", + "%Ec": "%c", + "%EC": "%C", + "%Ex": "%m/%d/%y", + "%EX": "%H:%M:%S", + "%Ey": "%y", + "%EY": "%Y", + "%Od": "%d", + "%Oe": "%e", + "%OH": "%H", + "%OI": "%I", + "%Om": "%m", + "%OM": "%M", + "%OS": "%S", + "%Ou": "%u", + "%OU": "%U", + "%OV": "%V", + "%Ow": "%w", + "%OW": "%W", + "%Oy": "%y" + }; + for (var u in t) + c = c.replace(new RegExp(u, "g"), t[u]); + var ya = "Sunday Monday Tuesday Wednesday Thursday Friday Saturday".split(" "), za = "January February March April May June July August September October November December".split(" "); + t = { "%a": (d) => ya[d.ma].substring(0, 3), "%A": (d) => ya[d.ma], "%b": (d) => za[d.ua].substring(0, 3), "%B": (d) => za[d.ua], "%C": (d) => h((d.sa + 1900) / 100 | 0, 2), "%d": (d) => h(d.wa, 2), "%e": (d) => g(d.wa, 2, " "), "%g": (d) => w(d).toString().substring(2), "%G": (d) => w(d), "%H": (d) => h(d.ta, 2), "%I": (d) => { + d = d.ta; + 0 == d ? d = 12 : 12 < d && (d -= 12); + return h(d, 2); + }, "%j": (d) => { + for (var n = 0, p = 0; p <= d.ua - 1; n += (W(d.sa + 1900) ? Ea : Fa)[p++]) + ; + return h(d.wa + n, 3); + }, "%m": (d) => h(d.ua + 1, 2), "%M": (d) => h(d.Ba, 2), "%n": () => "\n", "%p": (d) => 0 <= d.ta && 12 > d.ta ? "AM" : "PM", "%S": (d) => h(d.Ca, 2), "%t": () => " ", "%u": (d) => d.ma || 7, "%U": (d) => h(Math.floor((d.ra + 7 - d.ma) / 7), 2), "%V": (d) => { + var n = Math.floor((d.ra + 7 - (d.ma + 6) % 7) / 7); + 2 >= (d.ma + 371 - d.ra - 2) % 7 && n++; + if (n) + 53 == n && (p = (d.ma + 371 - d.ra) % 7, 4 == p || 3 == p && W(d.sa) || (n = 1)); + else { + n = 52; + var p = (d.ma + 7 - d.ra - 1) % 7; + (4 == p || 5 == p && W(d.sa % 400 - 1)) && n++; + } + return h(n, 2); + }, "%w": (d) => d.ma, "%W": (d) => h(Math.floor((d.ra + 7 - (d.ma + 6) % 7) / 7), 2), "%y": (d) => (d.sa + 1900).toString().substring(2), "%Y": (d) => d.sa + 1900, "%z": (d) => { + d = d.Aa; + var n = 0 <= d; + d = Math.abs(d) / 60; + return (n ? "+" : "-") + String("0000" + (d / 60 * 100 + d % 60)).slice(-4); + }, "%Z": (d) => d.Da, "%%": () => "%" }; + c = c.replace(/%%/g, "\0\0"); + for (u in t) + c.includes(u) && (c = c.replace(new RegExp(u, "g"), t[u](f))); + c = c.replace(/\0\0/g, "%"); + u = Ga(c); + if (u.length > b) + return 0; + J.set(u, a >>> 0); + return u.length - 1; + } + var Ja = { + a: function(a, b, c) { + a >>>= 0; + new qa(a).xa(b >>> 0, c >>> 0); + ra = a; + sa++; + throw ra; + }, + e: function() { + return 0; + }, + H: function() { + }, + x: function() { + }, + z: function() { + }, + k: function() { + return 0; + }, + F: function() { + }, + B: function() { + }, + E: function() { + }, + g: function() { + }, + y: function() { + }, + v: function() { + }, + G: function() { + }, + w: function() { + }, + l: () => true, + o: function(a, b, c) { + a = b + 2097152 >>> 0 < 4194305 - !!a ? (a >>> 0) + 4294967296 * b : NaN; + c >>>= 0; + a = new Date(1e3 * a); + L[c >> 2 >>> 0] = a.getUTCSeconds(); + L[c + 4 >> 2 >>> 0] = a.getUTCMinutes(); + L[c + 8 >> 2 >>> 0] = a.getUTCHours(); + L[c + 12 >> 2 >>> 0] = a.getUTCDate(); + L[c + 16 >> 2 >>> 0] = a.getUTCMonth(); + L[c + 20 >> 2 >>> 0] = a.getUTCFullYear() - 1900; + L[c + 24 >> 2 >>> 0] = a.getUTCDay(); + L[c + 28 >> 2 >>> 0] = (a.getTime() - Date.UTC(a.getUTCFullYear(), 0, 1, 0, 0, 0, 0)) / 864e5 | 0; + }, + p: function(a, b, c) { + a = b + 2097152 >>> 0 < 4194305 - !!a ? (a >>> 0) + 4294967296 * b : NaN; + c >>>= 0; + a = new Date(1e3 * a); + L[c >> 2 >>> 0] = a.getSeconds(); + L[c + 4 >> 2 >>> 0] = a.getMinutes(); + L[c + 8 >> 2 >>> 0] = a.getHours(); + L[c + 12 >> 2 >>> 0] = a.getDate(); + L[c + 16 >> 2 >>> 0] = a.getMonth(); + L[c + 20 >> 2 >>> 0] = a.getFullYear() - 1900; + L[c + 24 >> 2 >>> 0] = a.getDay(); + L[c + 28 >> 2 >>> 0] = (W(a.getFullYear()) ? va : wa)[a.getMonth()] + a.getDate() - 1 | 0; + L[c + 36 >> 2 >>> 0] = -(60 * a.getTimezoneOffset()); + b = new Date(a.getFullYear(), 6, 1).getTimezoneOffset(); + var f = new Date(a.getFullYear(), 0, 1).getTimezoneOffset(); + L[c + 32 >> 2 >>> 0] = (b != f && a.getTimezoneOffset() == Math.min(f, b)) | 0; + }, + q: function(a) { + a >>>= 0; + var b = new Date(L[a + 20 >> 2 >>> 0] + 1900, L[a + 16 >> 2 >>> 0], L[a + 12 >> 2 >>> 0], L[a + 8 >> 2 >>> 0], L[a + 4 >> 2 >>> 0], L[a >> 2 >>> 0], 0), c = L[a + 32 >> 2 >>> 0], f = b.getTimezoneOffset(), g = new Date(b.getFullYear(), 6, 1).getTimezoneOffset(), h = new Date(b.getFullYear(), 0, 1).getTimezoneOffset(), m = Math.min(h, g); + 0 > c ? L[a + 32 >> 2 >>> 0] = Number(g != h && m == f) : 0 < c != (m == f) && (g = Math.max(h, g), b.setTime(b.getTime() + 6e4 * ((0 < c ? m : g) - f))); + L[a + 24 >> 2 >>> 0] = b.getDay(); + L[a + 28 >> 2 >>> 0] = (W(b.getFullYear()) ? va : wa)[b.getMonth()] + b.getDate() - 1 | 0; + L[a >> 2 >>> 0] = b.getSeconds(); + L[a + 4 >> 2 >>> 0] = b.getMinutes(); + L[a + 8 >> 2 >>> 0] = b.getHours(); + L[a + 12 >> 2 >>> 0] = b.getDate(); + L[a + 16 >> 2 >>> 0] = b.getMonth(); + L[a + 20 >> 2 >>> 0] = b.getYear(); + a = b.getTime() / 1e3; + return Ia((R = a, 1 <= +Math.abs(R) ? 0 < R ? +Math.floor(R / 4294967296) >>> 0 : ~~+Math.ceil((R - +(~~R >>> 0)) / 4294967296) >>> 0 : 0)), a >>> 0; + }, + m: function() { + return -52; + }, + n: function() { + }, + t: function(a, b, c) { + function f(w) { + return (w = w.toTimeString().match(/\(([A-Za-z ]+)\)$/)) ? w[1] : "GMT"; + } + c >>>= 0; + var g = (/* @__PURE__ */ new Date()).getFullYear(), h = new Date(g, 0, 1), m = new Date(g, 6, 1); + g = h.getTimezoneOffset(); + var r = m.getTimezoneOffset(); + M[a >>> 0 >> 2 >>> 0] = 60 * Math.max(g, r); + L[b >>> 0 >> 2 >>> 0] = Number(g != r); + a = f(h); + b = f(m); + a = Ba(a); + b = Ba(b); + r < g ? (M[c >> 2 >>> 0] = a, M[c + 4 >> 2 >>> 0] = b) : (M[c >> 2 >>> 0] = b, M[c + 4 >> 2 >>> 0] = a); + }, + d: () => { + G(""); + }, + h: function() { + return Date.now(); + }, + u: function() { + return 4294901760; + }, + b: () => performance.now(), + I: function(a, b, c) { + b >>>= 0; + return K.copyWithin(a >>> 0 >>> 0, b >>> 0, b + (c >>> 0) >>> 0); + }, + s: function(a) { + a >>>= 0; + var b = K.length; + if (4294901760 < a) + return false; + for (var c = 1; 4 >= c; c *= 2) { + var f = b * (1 + 0.2 / c); + f = Math.min(f, a + 100663296); + var g = Math; + f = Math.max(a, f); + a: { + g = g.min.call(g, 4294901760, f + (65536 - f % 65536) % 65536) - H.buffer.byteLength + 65535 >>> 16; + try { + H.grow(g); + ea(); + var h = 1; + break a; + } catch (m) { + } + h = void 0; + } + if (h) + return true; + } + return false; + }, + C: function(a, b) { + a >>>= 0; + b >>>= 0; + var c = 0; + Ca().forEach(function(f, g) { + var h = b + c; + g = M[a + 4 * g >> 2 >>> 0] = h; + for (h = 0; h < f.length; ++h) + J[g++ >> 0 >>> 0] = f.charCodeAt(h); + J[g >> 0 >>> 0] = 0; + c += f.length + 1; + }); + return 0; + }, + D: function(a, b) { + a >>>= 0; + b >>>= 0; + var c = Ca(); + M[a >> 2 >>> 0] = c.length; + var f = 0; + c.forEach(function(g) { + f += g.length + 1; + }); + M[b >> 2 >>> 0] = f; + return 0; + }, + f: () => 52, + j: function() { + return 52; + }, + r: function() { + return 70; + }, + i: function(a, b, c, f) { + b >>>= 0; + c >>>= 0; + f >>>= 0; + for (var g = 0, h = 0; h < c; h++) { + var m = M[b >> 2 >>> 0], r = M[b + 4 >> 2 >>> 0]; + b += 8; + for (var w = 0; w < r; w++) { + var t = K[m + w >>> 0], u = Da[a]; + 0 === t || 10 === t ? ((1 === a ? ca : E)(ua(u, 0)), u.length = 0) : u.push(t); + } + g += r; + } + M[f >> 2 >>> 0] = g; + return 0; + }, + A: Ha, + c: function(a, b, c, f) { + return Ha(a >>> 0, b >>> 0, c >>> 0, f >>> 0); + } + }; + (function() { + function a(c) { + c = c.exports; + I = c = Ka(c); + H = I.J; + ea(); + ha.unshift(I.K); + N--; + e.monitorRunDependencies && e.monitorRunDependencies(N); + if (0 == N && (null !== O && (clearInterval(O), O = null), P)) { + var f = P; + P = null; + f(); + } + return c; + } + var b = { a: Ja }; + N++; + e.monitorRunDependencies && e.monitorRunDependencies(N); + if (e.instantiateWasm) + try { + return e.instantiateWasm(b, a); + } catch (c) { + E("Module.instantiateWasm callback failed with error: " + c), l(c); + } + pa(b, function(c) { + a(c.instance); + }).catch(l); + return {}; + })(); + e._OrtInit = (a, b) => (e._OrtInit = I.L)(a, b); + e._OrtGetLastError = (a, b) => (e._OrtGetLastError = I.M)(a, b); + e._OrtCreateSessionOptions = (a, b, c, f, g, h, m, r, w, t) => (e._OrtCreateSessionOptions = I.N)(a, b, c, f, g, h, m, r, w, t); + e._OrtAppendExecutionProvider = (a, b) => (e._OrtAppendExecutionProvider = I.O)(a, b); + e._OrtAddFreeDimensionOverride = (a, b, c) => (e._OrtAddFreeDimensionOverride = I.P)(a, b, c); + e._OrtAddSessionConfigEntry = (a, b, c) => (e._OrtAddSessionConfigEntry = I.Q)(a, b, c); + e._OrtReleaseSessionOptions = (a) => (e._OrtReleaseSessionOptions = I.R)(a); + e._OrtCreateSession = (a, b, c) => (e._OrtCreateSession = I.S)(a, b, c); + e._OrtReleaseSession = (a) => (e._OrtReleaseSession = I.T)(a); + e._OrtGetInputOutputCount = (a, b, c) => (e._OrtGetInputOutputCount = I.U)(a, b, c); + e._OrtGetInputName = (a, b) => (e._OrtGetInputName = I.V)(a, b); + e._OrtGetOutputName = (a, b) => (e._OrtGetOutputName = I.W)(a, b); + e._OrtFree = (a) => (e._OrtFree = I.X)(a); + e._OrtCreateTensor = (a, b, c, f, g, h) => (e._OrtCreateTensor = I.Y)(a, b, c, f, g, h); + e._OrtGetTensorData = (a, b, c, f, g) => (e._OrtGetTensorData = I.Z)(a, b, c, f, g); + e._OrtReleaseTensor = (a) => (e._OrtReleaseTensor = I._)(a); + e._OrtCreateRunOptions = (a, b, c, f) => (e._OrtCreateRunOptions = I.$)(a, b, c, f); + e._OrtAddRunConfigEntry = (a, b, c) => (e._OrtAddRunConfigEntry = I.aa)(a, b, c); + e._OrtReleaseRunOptions = (a) => (e._OrtReleaseRunOptions = I.ba)(a); + e._OrtCreateBinding = (a) => (e._OrtCreateBinding = I.ca)(a); + e._OrtBindInput = (a, b, c) => (e._OrtBindInput = I.da)(a, b, c); + e._OrtBindOutput = (a, b, c, f) => (e._OrtBindOutput = I.ea)(a, b, c, f); + e._OrtClearBoundOutputs = (a) => (e._OrtClearBoundOutputs = I.fa)(a); + e._OrtReleaseBinding = (a) => (e._OrtReleaseBinding = I.ga)(a); + e._OrtRunWithBinding = (a, b, c, f, g) => (e._OrtRunWithBinding = I.ha)(a, b, c, f, g); + e._OrtRun = (a, b, c, f, g, h, m, r) => (e._OrtRun = I.ia)(a, b, c, f, g, h, m, r); + e._OrtEndProfiling = (a) => (e._OrtEndProfiling = I.ja)(a); + var Aa = e._malloc = (a) => (Aa = e._malloc = I.ka)(a); + e._free = (a) => (e._free = I.la)(a); + var Ia = (a) => (Ia = I.na)(a), La = () => (La = I.oa)(), Ma = (a) => (Ma = I.pa)(a), Na = (a) => (Na = I.qa)(a); + function Ka(a) { + a = Object.assign({}, a); + var b = (f) => () => f() >>> 0, c = (f) => (g) => f(g) >>> 0; + a.__errno_location = b(a.__errno_location); + a.malloc = c(a.malloc); + a.stackSave = b(a.stackSave); + a.stackAlloc = c(a.stackAlloc); + return a; + } + e.stackAlloc = Na; + e.stackSave = La; + e.stackRestore = Ma; + e.UTF8ToString = T; + e.stringToUTF8 = (a, b, c) => V(a, K, b, c); + e.lengthBytesUTF8 = U; + var Z; + P = function Oa() { + Z || Pa(); + Z || (P = Oa); + }; + function Pa() { + function a() { + if (!Z && (Z = true, e.calledRun = true, !da)) { + S(ha); + k(e); + if (e.onRuntimeInitialized) + e.onRuntimeInitialized(); + if (e.postRun) + for ("function" == typeof e.postRun && (e.postRun = [e.postRun]); e.postRun.length; ) { + var b = e.postRun.shift(); + ia.unshift(b); + } + S(ia); + } + } + if (!(0 < N)) { + if (e.preRun) + for ("function" == typeof e.preRun && (e.preRun = [e.preRun]); e.preRun.length; ) + ja(); + S(fa); + 0 < N || (e.setStatus ? (e.setStatus("Running..."), setTimeout(function() { + setTimeout(function() { + e.setStatus(""); + }, 1); + a(); + }, 1)) : a()); + } + } + if (e.preInit) + for ("function" == typeof e.preInit && (e.preInit = [e.preInit]); 0 < e.preInit.length; ) + e.preInit.pop()(); + Pa(); + return moduleArg.ready; + }; + })(); + if (typeof exports === "object" && typeof module === "object") + module.exports = ortWasm; + else if (typeof define === "function" && define["amd"]) + define([], () => ortWasm); + } +}); + +// web/lib/wasm/wasm-factory.ts +var ortWasmFactory, ortWasmFactoryThreaded, wasm, initialized, initializing, aborted, isMultiThreadSupported, isSimdSupported, getWasmFileName, initializeWebAssembly, getInstance; +var init_wasm_factory = __esm({ + "web/lib/wasm/wasm-factory.ts"() { + "use strict"; + if (false) { + ortWasmFactory = null; + } else { + ortWasmFactory = true ? require_ort_wasm() : null; + } + ortWasmFactoryThreaded = false ? true ? null : null : ortWasmFactory; + initialized = false; + initializing = false; + aborted = false; + isMultiThreadSupported = (numThreads) => { + if (numThreads === 1) { + return false; + } + if (typeof SharedArrayBuffer === "undefined") { + 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." + ); + } + return false; + } + if (typeof process !== "undefined" && process.versions && process.versions.node) { + console.warn( + "env.wasm.numThreads is set to " + numThreads + ", however, currently onnxruntime-web does not support multi-threads in Node.js. Please consider using onnxruntime-node for performance critical scenarios." + ); + } + 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; + } + }; + getWasmFileName = (useSimd, useThreads) => { + if (useSimd) { + if (false) { + return "ort-training-wasm-simd.wasm"; + } + return useThreads ? "ort-wasm-simd-threaded.wasm" : "ort-wasm-simd.wasm"; + } else { + return useThreads ? "ort-wasm-threaded.wasm" : "ort-wasm.wasm"; + } + }; + 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; + const numThreads = flags.numThreads; + const simd = flags.simd; + const useThreads = isMultiThreadSupported(numThreads); + const useSimd = simd && isSimdSupported(); + const wasmPaths = flags.wasmPaths; + const wasmPrefixOverride = typeof wasmPaths === "string" ? wasmPaths : void 0; + const wasmFileName = getWasmFileName(useSimd, useThreads); + const wasmPathOverride = typeof wasmPaths === "object" ? wasmPaths[wasmFileName] : void 0; + 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 factory = useThreads ? ortWasmFactoryThreaded : ortWasmFactory; + const config = { + locateFile: (fileName, scriptDirectory) => { + if (false) { + return URL.createObjectURL(new Blob( + [ + // This require() function is handled by esbuild plugin to load file content as string. + // eslint-disable-next-line @typescript-eslint/no-require-imports + null + ], + { type: "text/javascript" } + )); + } + if (fileName.endsWith(".wasm")) { + if (wasmPathOverride) { + return wasmPathOverride; + } + const prefix = wasmPrefixOverride ?? scriptDirectory; + if (false) { + if (wasmFileName === "ort-wasm-simd.wasm") { + return prefix + "ort-wasm-simd.jsep.wasm"; + } else if (wasmFileName === "ort-wasm-simd-threaded.wasm") { + return prefix + "ort-wasm-simd-threaded.jsep.wasm"; + } + } + return prefix + wasmFileName; + } + return scriptDirectory + fileName; + } + }; + if (false) { + config.numThreads = numThreads; + if (typeof Blob === "undefined") { + config.mainScriptUrlOrBlob = join(__dirname, "ort-wasm-threaded.js"); + } else { + const scriptSourceCode = `var ortWasmThreaded=${factory.toString()};`; + config.mainScriptUrlOrBlob = new Blob([scriptSourceCode], { type: "text/javascript" }); + } + } + factory(config).then( + // wasm module initialized successfully + (module) => { + initializing = false; + initialized = true; + wasm = module; + resolve(); + }, + // 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 paramsOffset = wasm2.stackAlloc(8); + wasm2._OrtGetLastError(paramsOffset, paramsOffset + 4); + const errorCode = wasm2.HEAP32[paramsOffset / 4]; + const errorMessagePointer = wasm2.HEAPU32[paramsOffset / 4 + 1]; + 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, 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; + } + }; + setExecutionProviders = (sessionOptionsHandle, executionProviders, allocs) => { + for (const ep of executionProviders) { + let epName = typeof ep === "string" ? ep : ep.name; + switch (epName) { + case "webnn": + epName = "WEBNN"; + if (typeof ep !== "string") { + const webnnOptions = ep; + if (webnnOptions?.deviceType) { + const keyDataOffset = allocWasmString("deviceType", allocs); + const valueDataOffset = allocWasmString(webnnOptions.deviceType, allocs); + if (getInstance()._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !== 0) { + checkLastError(`Can't set a session config entry: 'deviceType' - ${webnnOptions.deviceType}.`); + } + } + if (webnnOptions?.numThreads) { + let numThreads = webnnOptions.numThreads; + if (typeof numThreads != "number" || !Number.isInteger(numThreads) || numThreads < 0) { + numThreads = 0; + } + const keyDataOffset = allocWasmString("numThreads", allocs); + const valueDataOffset = allocWasmString(numThreads.toString(), allocs); + if (getInstance()._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !== 0) { + checkLastError(`Can't set a session config entry: 'numThreads' - ${webnnOptions.numThreads}.`); + } + } + if (webnnOptions?.powerPreference) { + const keyDataOffset = allocWasmString("powerPreference", allocs); + const valueDataOffset = allocWasmString(webnnOptions.powerPreference, allocs); + if (getInstance()._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !== 0) { + checkLastError( + `Can't set a session config entry: 'powerPreference' - ${webnnOptions.powerPreference}.` + ); + } + } + } + break; + case "webgpu": + 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}`); + } + const keyDataOffset = allocWasmString("preferredLayout", allocs); + const valueDataOffset = allocWasmString(webgpuOptions.preferredLayout, allocs); + if (getInstance()._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !== 0) { + checkLastError( + `Can't set a session config entry: 'preferredLayout' - ${webgpuOptions.preferredLayout}.` + ); + } + } + } + break; + case "wasm": + case "cpu": + continue; + default: + throw new Error(`not supported execution provider: ${epName}`); + } + const epNameDataOffset = allocWasmString(epName, allocs); + if (getInstance()._OrtAppendExecutionProvider(sessionOptionsHandle, epNameDataOffset) !== 0) { + checkLastError(`Can't append execution provider: ${epName}.`); + } + } + }; + setSessionOptions = (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) { + 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}`); + } + const keyDataOffset = allocWasmString("enableGraphCapture", allocs); + const valueDataOffset = allocWasmString(sessionOptions.enableGraphCapture.toString(), allocs); + if (wasm2._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !== 0) { + checkLastError( + `Can't set a session config entry: 'enableGraphCapture' - ${sessionOptions.enableGraphCapture}.` + ); + } + } + 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) => { + const keyDataOffset = allocWasmString(key, allocs); + const valueDataOffset = allocWasmString(value, allocs); + if (wasm2._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !== 0) { + checkLastError(`Can't set a session config entry: ${key} - ${value}.`); + } + }); + } + return [sessionOptionsHandle, allocs]; + } catch (e) { + if (sessionOptionsHandle !== 0) { + wasm2._OrtReleaseSessionOptions(sessionOptionsHandle); + } + allocs.forEach((alloc) => wasm2._free(alloc)); + throw e; + } + }; + } +}); + +// web/lib/wasm/wasm-common.ts +var tensorDataTypeStringToEnum, tensorDataTypeEnumToString, getTensorElementSize, tensorTypeToTypedArrayConstructor, logLevelStringToEnum, isGpuBufferSupportedType, 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 */; + 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"; + default: + throw new Error(`unsupported data type: ${typeProto}`); + } + }; + getTensorElementSize = (dateType) => [void 0, 4, 1, 1, 2, 2, 4, 8, void 0, 1, 2, 8, 4, 8, void 0, void 0, void 0][dateType]; + 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"; + dataLocationStringToEnum = (location) => { + switch (location) { + case "none": + return 0; + case "cpu": + return 1; + case "cpu-pinned": + return 2; + case "texture": + return 3; + case "gpu-buffer": + return 4; + default: + throw new Error(`unsupported data location: ${location}`); + } + }; + } +}); + +// nodejs-ignore:node:fs/promises +var readFile2; +var init_promises = __esm({ + "nodejs-ignore:node:fs/promises"() { + readFile2 = void 0; + } +}); + +// 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_fs(); + init_promises(); + loadFile = async (file) => { + if (typeof file === "string") { + if (typeof process !== "undefined" && process.versions && process.versions.node) { + try { + return new Uint8Array(await readFile2(file)); + } catch (e) { + if (e.code === "ERR_FS_FILE_TOO_LARGE") { + 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, copyFromExternalBuffer, createSession, releaseSession, prepareInputOutputTensor, run, endProfiling; +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) => { + if (false) { + const initJsep = null.init; + if (epName === "webgpu") { + 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."); + } + } + if (!env3.wasm.simd) { + throw new Error( + "Not supported for WebGPU=ON and SIMD=OFF. Please set `env.wasm.simd` to true when using `webgpu` EP" + ); + } + 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 dataOffset = wasm2.stackAlloc(8); + const errorCode = wasm2._OrtGetInputOutputCount(sessionHandle, dataOffset, dataOffset + 4); + if (errorCode !== 0) { + checkLastError("Can't get session input/output count."); + } + return [wasm2.HEAP32[dataOffset / 4], wasm2.HEAP32[dataOffset / 4 + 1]]; + } finally { + wasm2.stackRestore(stack); + } + }; + 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] = 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); + } + sessionHandle = await wasm2._OrtCreateSession(modelDataOffset, modelDataLength, sessionOptionsHandle); + if (sessionHandle === 0) { + checkLastError("Can't create a session."); + } + const [inputCount, outputCount] = getSessionInputOutputCount(sessionHandle); + const enableGraphCapture = !!options?.enableGraphCapture; + const inputNames = []; + const outputNames = []; + const outputPreferredLocations = []; + for (let i = 0; i < inputCount; i++) { + const name = wasm2._OrtGetInputName(sessionHandle, i); + if (name === 0) { + checkLastError("Can't get an input name."); + } + inputNamesUTF8Encoded.push(name); + inputNames.push(wasm2.UTF8ToString(name)); + } + for (let i = 0; i < outputCount; i++) { + const name = wasm2._OrtGetOutputName(sessionHandle, i); + if (name === 0) { + checkLastError("Can't get an output name."); + } + outputNamesUTF8Encoded.push(name); + const nameString = wasm2.UTF8ToString(name); + outputNames.push(nameString); + if (false) { + if (enableGraphCapture && options?.preferredOutputLocation === void 0) { + outputPreferredLocations.push("gpu-buffer"); + continue; + } + const location = typeof options?.preferredOutputLocation === "string" ? options.preferredOutputLocation : options?.preferredOutputLocation?.[nameString] ?? "cpu"; + if (location !== "cpu" && location !== "cpu-pinned" && location !== "gpu-buffer") { + throw new Error(`Not supported preferred output location: ${location}.`); + } + if (enableGraphCapture && location !== "gpu-buffer") { + throw new Error(`Not supported preferred output location: ${location}. Only 'gpu-buffer' location is supported when enableGraphCapture is true.`); + } + outputPreferredLocations.push(location); + } + } + 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) => dataLocationStringToEnum(l)) + }; + } + activeSessions.set( + sessionHandle, + [sessionHandle, inputNamesUTF8Encoded, outputNamesUTF8Encoded, bindingState, enableGraphCapture, false] + ); + return [sessionHandle, inputNames, outputNames]; + } catch (e) { + inputNamesUTF8Encoded.forEach((buf) => wasm2._OrtFree(buf)); + outputNamesUTF8Encoded.forEach((buf) => wasm2._OrtFree(buf)); + if (ioBindingHandle !== 0) { + wasm2._OrtReleaseBinding(ioBindingHandle); + } + if (sessionHandle !== 0) { + wasm2._OrtReleaseSession(sessionHandle); + } + throw e; + } finally { + wasm2._free(modelDataOffset); + if (sessionOptionsHandle !== 0) { + wasm2._OrtReleaseSessionOptions(sessionOptionsHandle); + } + 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) { + wasm2._OrtClearBoundOutputs(ioBindingState.handle); + } + wasm2._OrtReleaseBinding(ioBindingState.handle); + } + wasm2.jsepOnReleaseSession?.(sessionId); + inputNamesUTF8Encoded.forEach((buf) => wasm2._OrtFree(buf)); + outputNamesUTF8Encoded.forEach((buf) => wasm2._OrtFree(buf)); + wasm2._OrtReleaseSession(sessionHandle); + activeSessions.delete(sessionId); + }; + prepareInputOutputTensor = (tensor, tensorHandles, allocs, sessionId, index, enableGraphCapture = false) => { + if (!tensor) { + tensorHandles.push(0); + return; + } + const wasm2 = getInstance(); + const dataType = tensor[0]; + const dims = tensor[1]; + const location = tensor[3]; + let rawData; + let dataByteLength; + if (dataType === "string" && location === "gpu-buffer") { + throw new Error("String tensor is not supported on GPU."); + } + if (enableGraphCapture && location !== "gpu-buffer") { + throw new Error( + `External buffer must be provided for input/output index ${index} when enableGraphCapture is true.` + ); + } + if (location === "gpu-buffer") { + const gpuBuffer = tensor[2].gpuBuffer; + const elementSizeInBytes = getTensorElementSize(tensorDataTypeStringToEnum(dataType)); + dataByteLength = dims.reduce((a, b) => a * b, 1) * elementSizeInBytes; + 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 { + const data = tensor[2]; + if (Array.isArray(data)) { + dataByteLength = 4 * data.length; + rawData = wasm2._malloc(dataByteLength); + allocs.push(rawData); + let dataIndex = rawData / 4; + 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.HEAPU32[dataIndex++] = allocWasmString(data[i], allocs); + } + } 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 { + let dimIndex = dimsOffset / 4; + dims.forEach((d) => wasm2.HEAP32[dimIndex++] = d); + const tensor2 = wasm2._OrtCreateTensor( + tensorDataTypeStringToEnum(dataType), + rawData, + dataByteLength, + dimsOffset, + dims.length, + dataLocationStringToEnum(location) + ); + 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 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 * 4); + const inputNamesOffset = wasm2.stackAlloc(inputCount * 4); + const outputValuesOffset = wasm2.stackAlloc(outputCount * 4); + const outputNamesOffset = wasm2.stackAlloc(outputCount * 4); + try { + [runOptionsHandle, runOptionsAllocs] = setRunOptions(options); + for (let i = 0; i < inputCount; i++) { + prepareInputOutputTensor( + inputTensors[i], + inputTensorHandles, + inputOutputAllocs, + sessionId, + inputIndices[i], + enableGraphCapture + ); + } + for (let i = 0; i < outputCount; i++) { + prepareInputOutputTensor( + outputTensors[i], + outputTensorHandles, + inputOutputAllocs, + sessionId, + inputCount + outputIndices[i], + enableGraphCapture + ); + } + let inputValuesIndex = inputValuesOffset / 4; + let inputNamesIndex = inputNamesOffset / 4; + let outputValuesIndex = outputValuesOffset / 4; + let outputNamesIndex = outputNamesOffset / 4; + for (let i = 0; i < inputCount; i++) { + wasm2.HEAPU32[inputValuesIndex++] = inputTensorHandles[i]; + wasm2.HEAPU32[inputNamesIndex++] = inputNamesUTF8Encoded[inputIndices[i]]; + } + for (let i = 0; i < outputCount; i++) { + wasm2.HEAPU32[outputValuesIndex++] = outputTensorHandles[i]; + wasm2.HEAPU32[outputNamesIndex++] = 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 location = outputTensors[i]?.[3]; + if (location) { + 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); + 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 = []; + for (let i = 0; i < outputCount; i++) { + const tensor = wasm2.HEAPU32[outputValuesOffset / 4 + i]; + if (tensor === outputTensorHandles[i]) { + output.push(outputTensors[i]); + continue; + } + const beforeGetTensorDataStack = wasm2.stackSave(); + const tensorDataOffset = wasm2.stackAlloc(4 * 4); + let keepOutputTensor = false; + let type, dataOffset = 0; + try { + const errorCode2 = wasm2._OrtGetTensorData( + tensor, + tensorDataOffset, + tensorDataOffset + 4, + tensorDataOffset + 8, + tensorDataOffset + 12 + ); + if (errorCode2 !== 0) { + checkLastError(`Can't access output tensor data on index ${i}.`); + } + let tensorDataIndex = tensorDataOffset / 4; + const dataType = wasm2.HEAPU32[tensorDataIndex++]; + dataOffset = wasm2.HEAPU32[tensorDataIndex++]; + const dimsOffset = wasm2.HEAPU32[tensorDataIndex++]; + const dimsLength = wasm2.HEAPU32[tensorDataIndex++]; + const dims = []; + for (let i2 = 0; i2 < dimsLength; i2++) { + dims.push(wasm2.HEAPU32[dimsOffset / 4 + i2]); + } + wasm2._OrtFree(dimsOffset); + 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") { + throw new Error("String tensor is not supported on GPU."); + } + const stringData = []; + let dataIndex = dataOffset / 4; + for (let i2 = 0; i2 < size; i2++) { + const offset = wasm2.HEAPU32[dataIndex++]; + const maxBytesToRead = i2 === size - 1 ? void 0 : wasm2.HEAPU32[dataIndex] - offset; + stringData.push(wasm2.UTF8ToString(offset, maxBytesToRead)); + } + output.push([type, dims, stringData, "cpu"]); + } else { + if (preferredLocation === "gpu-buffer" && size > 0) { + const getBuffer = wasm2.jsepGetBuffer; + if (!getBuffer) { + throw new Error('preferredLocation "gpu-buffer" is not supported without using WebGPU.'); + } + const gpuBuffer = getBuffer(dataOffset); + const elementSize = getTensorElementSize(dataType); + if (elementSize === void 0 || !isGpuBufferSupportedType(type)) { + throw new Error(`Unsupported data type: ${type}`); + } + keepOutputTensor = true; + output.push([ + type, + dims, + { + gpuBuffer, + download: wasm2.jsepCreateDownloader(gpuBuffer, size * elementSize, type), + dispose: () => { + wasm2._OrtReleaseTensor(tensor); + } + }, + "gpu-buffer" + ]); + } 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) { + wasm2._OrtClearBoundOutputs(ioBindingState.handle); + activeSessions.set( + sessionId, + [sessionHandle, inputNamesUTF8Encoded, outputNamesUTF8Encoded, ioBindingState, enableGraphCapture, false] + ); + } + return output; + } finally { + wasm2.stackRestore(beforeRunStack); + 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); + }; + } +}); + +// web/lib/wasm/proxy-wrapper.ts +var initializing2, initialized2, aborted2, scriptSrc, 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(); + initializing2 = false; + initialized2 = false; + aborted2 = false; + scriptSrc = typeof document !== "undefined" ? document?.currentScript?.src : void 0; + 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 (false) { + if (env2.wasm.wasmPaths === void 0) { + if (scriptSrc && scriptSrc.indexOf("blob:") !== 0) { + env2.wasm.wasmPaths = scriptSrc.substr(0, +scriptSrc.lastIndexOf("/") + 1); + } + } + return new Promise((resolve, reject) => { + proxyWorker?.terminate(); + const workerUrl = URL.createObjectURL(new Blob( + [ + // This require() function is handled by esbuild plugin to load file content as string. + // eslint-disable-next-line @typescript-eslint/no-require-imports + null + ], + { type: "text/javascript" } + )); + proxyWorker = new Worker(workerUrl, { name: "ort-wasm-proxy-worker" }); + proxyWorker.onerror = (ev) => reject(ev); + proxyWorker.onmessage = onProxyWorkerMessage; + URL.revokeObjectURL(workerUrl); + initWasmCallbacks = [resolve, reject]; + const message = { type: "init-wasm", in: env2 }; + proxyWorker.postMessage(message); + }); + } else { + try { + await initializeWebAssembly(env2.wasm); + await initRuntime(env2); + initialized2 = true; + } catch (e) { + aborted2 = true; + throw e; + } finally { + initializing2 = false; + } + } + }; + initializeOrtEp = async (epName) => { + if (false) { + 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 (false) { + 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 (false) { + 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 (false) { + 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 (false) { + 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 (false) { + 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_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"]; + 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 }); + } + 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 (typeof process !== "undefined" && process.versions && process.versions.node) { + model = await loadFile(pathOrBuffer); + } else { + model = await this.fetchModelAndCopyToWasmMemory(pathOrBuffer); + } + } else { + model = pathOrBuffer; + } + [this.sessionId, this.inputNames, this.outputNames] = 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 initializeFlags, OnnxruntimeWebAssemblyBackend; +var init_backend_wasm = __esm({ + "web/lib/backend-wasm.ts"() { + "use strict"; + init_node_os(); + init_esm(); + init_proxy_wrapper(); + init_session_handler_inference(); + initializeFlags = () => { + if (typeof env2.wasm.initTimeout !== "number" || env2.wasm.initTimeout < 0) { + env2.wasm.initTimeout = 0; + } + if (typeof env2.wasm.simd !== "boolean") { + env2.wasm.simd = true; + } + 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 || typeof process !== "undefined" && process.versions && process.versions.node) { + env2.wasm.numThreads = 1; + } + const numCpuLogicalCores = typeof navigator === "undefined" ? 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 Promise.resolve(handler); + } + }; + } +}); + +// web/lib/backend-wasm-inference.ts +var backend_wasm_inference_exports = {}; +__export(backend_wasm_inference_exports, { + wasmBackend: () => wasmBackend +}); +var wasmBackend; +var init_backend_wasm_inference = __esm({ + "web/lib/backend-wasm-inference.ts"() { + "use strict"; + init_backend_wasm(); + wasmBackend = new OnnxruntimeWebAssemblyBackend(); + } +}); + +// web/lib/index.ts +init_esm(); +init_esm(); +init_esm(); + +// web/lib/version.ts +var version2 = "1.18.0"; + +// web/lib/index.ts +var lib_default = esm_exports; +if (false) { + const onnxjsBackend = null.onnxjsBackend; + registerBackend("webgl", onnxjsBackend, -10); +} +if (true) { + const wasmBackend2 = true ? (init_backend_wasm_inference(), __toCommonJS(backend_wasm_inference_exports)).wasmBackend : null.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 }); +export { + InferenceSession2 as InferenceSession, + TRACE, + TRACE_FUNC_BEGIN, + TRACE_FUNC_END, + Tensor2 as Tensor, + TrainingSession2 as TrainingSession, + lib_default as default, + env2 as env, + registerBackend +}; +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../common/lib/backend-impl.ts", "../../../common/lib/backend.ts", "../../../common/lib/version.ts", "../../../common/lib/env-impl.ts", "../../../common/lib/env.ts", "../../../common/lib/tensor-conversion-impl.ts", "../../../common/lib/tensor-factory-impl.ts", "../../../common/lib/tensor-impl-type-mapping.ts", "../../../common/lib/tensor-utils-impl.ts", "../../../common/lib/tensor-impl.ts", "../../../common/lib/tensor.ts", "../../../common/lib/trace.ts", "../../../common/lib/inference-session-impl.ts", "../../../common/lib/inference-session.ts", "../../../common/lib/tensor-conversion.ts", "../../../common/lib/tensor-factory.ts", "../../../common/lib/onnx-model.ts", "../../../common/lib/onnx-value.ts", "../../../common/lib/training-session-impl.ts", "../../../common/lib/training-session.ts", "../../../common/lib/index.ts", "nodejs-ignore:node:os", "nodejs-ignore:fs", "nodejs-ignore:path", "../../lib/wasm/binding/ort-wasm.js", "../../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", "nodejs-ignore:node:fs/promises", "../../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/backend-wasm-inference.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(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(`removing requested execution provider \"${\n              name}\" from session options because it is not available: ${err}`);\n        }\n      }\n\n      const filteredEps = eps.filter(i => availableBackendNames.has(typeof i === 'string' ? i : i.name));\n\n      return [\n        backend, 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';\nimport {TrainingSession} from './training-session.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\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(feeds: SessionHandler.FeedsType, fetches: SessionHandler.FetchesType,\n      options: InferenceSession.RunOptions): Promise<SessionHandler.ReturnType>;\n}\n\n/**\n * Represent a handler instance of a training inference session.\n *\n * @ignore\n */\nexport interface TrainingSessionHandler extends SessionHandler {\n  readonly evalInputNames: readonly string[];\n  readonly evalOutputNames: readonly string[];\n\n  lazyResetGrad(): Promise<void>;\n  runTrainStep(\n      feeds: SessionHandler.FeedsType, fetches: SessionHandler.FetchesType,\n      options: InferenceSession.RunOptions): Promise<SessionHandler.ReturnType>;\n  runOptimizerStep(options: InferenceSession.RunOptions): Promise<void>;\n  runEvalStep(\n      feeds: SessionHandler.FeedsType, fetches: SessionHandler.FetchesType,\n      options: InferenceSession.RunOptions): Promise<SessionHandler.ReturnType>;\n\n  getParametersSize(trainableOnly: boolean): Promise<number>;\n  loadParametersBuffer(buffer: Uint8Array, trainableOnly: boolean): Promise<void>;\n  getContiguousParameters(trainableOnly: boolean): Promise<OnnxValue>;\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(uriOrBuffer: string|Uint8Array, options?: InferenceSession.SessionOptions):\n      Promise<InferenceSessionHandler>;\n\n  createTrainingSessionHandler?\n      (checkpointStateUriOrBuffer: TrainingSession.UriOrBuffer, trainModelUriOrBuffer: TrainingSession.UriOrBuffer,\n       evalModelUriOrBuffer: TrainingSession.UriOrBuffer, optimizerModelUriOrBuffer: TrainingSession.UriOrBuffer,\n       options: InferenceSession.SessionOptions): Promise<TrainingSessionHandler>;\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.18.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';\n\nexport declare namespace Env {\n  export type WasmPrefixOrFilePaths = string|{\n    /* eslint-disable @typescript-eslint/naming-convention */\n    'ort-wasm.wasm'?: string;\n    'ort-wasm-threaded.wasm'?: string;\n    'ort-wasm-simd.wasm'?: string;\n    'ort-training-wasm-simd.wasm'?: string;\n    'ort-wasm-simd-threaded.wasm'?: string;\n    /* eslint-enable @typescript-eslint/naming-convention */\n  };\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 or get a boolean value indicating whether to enable SIMD. If set to false, SIMD will be forcely disabled.\n     *\n     * This setting is available only when WebAssembly SIMD feature is available in current context.\n     *\n     * @defaultValue `true`\n     */\n    simd?: boolean;\n\n    /**\n     * set or get a boolean value indicating whether to enable trace.\n     *\n     * @deprecated Use `env.trace` instead. If `env.trace` is set, this property will be ignored.\n     * @defaultValue `false`\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 files or a set of overrides for each .wasm file. The override path should be\n     * an absolute path.\n     */\n    wasmPaths?: WasmPrefixOrFilePaths;\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    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    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     * Use `const adapter = env.webgpu.adapter as GPUAdapter;` in TypeScript to access this property with correct type.\n     *\n     * see comments on {@link Tensor.GpuBufferType}\n     */\n    adapter: unknown;\n    /**\n     * Get the device for WebGPU.\n     *\n     * This property is only available after the first WebGPU inference session is created.\n     *\n     * When use with TypeScript, the type of this property is `GPUDevice` defined in \"@webgpu/types\".\n     * Use `const device = env.webgpu.device as GPUDevice;` in TypeScript to access this property with correct type.\n     *\n     * see comments on {@link Tensor.GpuBufferType} for more details about why not use types defined in \"@webgpu/types\".\n     */\n    readonly device: unknown;\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 =\n      canvas.getContext('2d') as (CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D | 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 {  // 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, gTensorPointer = stride, bTensorPointer = stride * 2, 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 ?\n            255 :\n            ((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 = 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 {  // 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 (options.format !== undefined && (channels === 4 && options.format !== 'RGBA') ||\n          (channels === 3 && (options.format !== 'RGB' && options.format !== 'BGR'))) {\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, gImagePointer = 1, bImagePointer = 2, aImagePointer = 3;\n    let rTensorPointer = 0, gTensorPointer = stride, bTensorPointer = stride * 2, 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 (let i = 0; i < height * width;\n         rImagePointer += step, gImagePointer += step, bImagePointer += step, aImagePointer += step, i++) {\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] = aTensorPointer === -1 ?\n          255 :\n          ((tensor.data[aTensorPointer++] as number) - normBias[3]) * normMean[3];  // A value\n    }\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 {OptionsDimensions, OptionsFormat, OptionsNormalizationParameters, OptionsTensorFormat, OptionsTensorLayout, TensorFromGpuBufferOptions, TensorFromImageBitmapOptions, TensorFromImageDataOptions, TensorFromImageElementOptions, TensorFromTextureOptions, TensorFromUrlOptions} from './tensor-factory.js';\nimport {Tensor} from './tensor-impl.js';\nimport {Tensor as TensorInterface} from './tensor.js';\n\ninterface BufferToTensorOptions extends OptionsDimensions, OptionsTensorLayout, OptionsNormalizationParameters,\n                                        OptionsFormat, 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, rImagePointer = 0, gImagePointer = 1, bImagePointer = 2, aImagePointer = 3;\n  let rTensorPointer = 0, gTensorPointer = stride, bTensorPointer = stride * 2, 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 (let i = 0; i < stride;\n       i++, rImagePointer += step, bImagePointer += step, gImagePointer += step, aImagePointer += step) {\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 = outputformat === 'RGBA' ? 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?: TensorFromImageDataOptions|TensorFromImageElementOptions|TensorFromImageBitmapOptions|\n    TensorFromUrlOptions): 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 (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, options: TensorFromTextureOptions<T>): 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, options: TensorFromGpuBufferOptions<T>): 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.fromPinnedBuffer().\n */\nexport const tensorFromPinnedBuffer = <T extends TensorInterface.CpuPinnedDataTypes>(\n    type: T, buffer: TensorInterface.DataTypeMap[T], dims?: readonly number[]): Tensor =>\n    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 = Float32ArrayConstructor|Uint8ArrayConstructor|Int8ArrayConstructor|\n    Uint16ArrayConstructor|Int16ArrayConstructor|Int32ArrayConstructor|BigInt64ArrayConstructor|Uint8ArrayConstructor|\n    Float64ArrayConstructor|Uint32ArrayConstructor|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]);\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// 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// 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    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 {CpuPinnedConstructorParameters, GpuBufferConstructorParameters, TextureConstructorParameters} 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    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 {tensorFromGpuBuffer, tensorFromImage, tensorFromPinnedBuffer, tensorFromTexture} from './tensor-factory-impl.js';\nimport {CpuPinnedConstructorParameters, GpuBufferConstructorParameters, TensorFromGpuBufferOptions, TensorFromImageBitmapOptions, TensorFromImageDataOptions, TensorFromImageElementOptions, TensorFromTextureOptions, TensorFromUrlOptions, TextureConstructorParameters} from './tensor-factory.js';\nimport {checkTypedArray, NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP, NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP, SupportedTypedArray, SupportedTypedArrayConstructors} 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;\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, data: TensorDataType|readonly string[]|readonly number[]|readonly boolean[],\n      dims?: readonly number[]);\n  /**\n   * Construct a new CPU tensor object from the given data and dims. Type is inferred from data.\n   */\n  constructor(data: TensorDataType|readonly string[]|readonly boolean[], dims?: readonly number[]);\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   * implementation.\n   */\n  constructor(\n      arg0: TensorType|TensorDataType|readonly string[]|readonly boolean[]|CpuPinnedConstructorParameters|\n      TextureConstructorParameters|GpuBufferConstructorParameters,\n      arg1?: TensorDataType|readonly number[]|readonly string[]|readonly boolean[], arg2?: readonly number[]) {\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 ((type !== 'float32' && type !== 'float16' && type !== 'int32' && type !== 'int64' && type !== 'uint32' &&\n               type !== 'uint8' && type !== 'bool')) {\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        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) {\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              throw new TypeError(\n                  'Creating a float16 tensor from number array is not supported. Please use Uint16Array as data.');\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 {\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 {\n          // get tensor type from TypedArray\n          const mappedType =\n              NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.get(arg0.constructor as SupportedTypedArrayConstructors);\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      throw new Error(`Tensor's size(${size}) does not match data length(${this.cpuData.length}).`);\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?: TensorFromImageDataOptions|TensorFromImageElementOptions|TensorFromImageBitmapOptions|\n      TensorFromUrlOptions): Promise<TensorInterface> {\n    return tensorFromImage(image, options);\n  }\n\n  static fromTexture<T extends TensorInterface.TextureDataTypes>(\n      texture: TensorTextureType, options: TensorFromTextureOptions<T>): TensorInterface {\n    return tensorFromTexture(texture, options);\n  }\n\n  static fromGpuBuffer<T extends TensorInterface.GpuBufferDataTypes>(\n      gpuBuffer: TensorGpuBufferType, options: TensorFromGpuBufferOptions<T>): TensorInterface {\n    return tensorFromGpuBuffer(gpuBuffer, options);\n  }\n\n  static fromPinnedBuffer<T extends TensorInterface.CpuPinnedDataTypes>(\n      type: T, buffer: TensorInterface.DataTypeMap[T], dims?: readonly number[]): 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 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    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  // #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        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\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.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';\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 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  }\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  }\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  /**\n   * type alias for WebGPU buffer\n   *\n   * The reason why we don't use type \"GPUBuffer\" defined in webgpu.d.ts from @webgpu/types is because \"@webgpu/types\"\n   * requires \"@types/dom-webcodecs\" as peer dependency when using TypeScript < v5.1 and its version need to be chosen\n   * carefully according to the TypeScript version being used. This means so far there is not a way to keep every\n   * TypeScript version happy. It turns out that we will easily broke users on some TypeScript version.\n   *\n   * for more info see https://github.com/gpuweb/types/issues/127\n   */\n  export type GpuBufferType = {size: number; mapState: 'unmapped' | 'pending' | 'mapped'};\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   * represent where the tensor data is stored\n   */\n  export type DataLocation = 'none'|'cpu'|'cpu-pinned'|'texture'|'gpu-buffer';\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(type: 'string', data: Tensor.DataTypeMap['string']|readonly string[],\n      dims?: readonly number[]): 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(type: 'bool', data: Tensor.DataTypeMap['bool']|readonly boolean[], dims?: readonly number[]): TypedTensor<'bool'>;\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, data: Tensor.DataTypeMap[T]|readonly bigint[]|readonly number[],\n      dims?: readonly number[]): 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, data: Tensor.DataTypeMap[T]|readonly number[], dims?: readonly number[]): 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 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(type: Tensor.Type, data: Tensor.DataType|readonly number[]|readonly string[]|readonly bigint[]|readonly boolean[],\n      dims?: readonly number[]): 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    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(buffer: ArrayBufferLike, byteOffset: number, byteLength?: number, options?: SessionOptions):\n      Promise<InferenceSessionInterface>;\n  static create(buffer: Uint8Array, options?: SessionOptions): Promise<InferenceSessionInterface>;\n  static async create(\n      arg0: string|ArrayBufferLike|Uint8Array, arg1?: SessionOptions|number, arg2?: number,\n      arg3?: SessionOptions): 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      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  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';\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    xnnpack: XnnpackExecutionProviderOption;\n  }\n\n  type ExecutionProviderName = keyof ExecutionProviderOptionMap;\n  type ExecutionProviderConfig =\n      ExecutionProviderOptionMap[ExecutionProviderName]|ExecutionProviderOption|ExecutionProviderName|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  export interface WebNNExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'webnn';\n    deviceType?: 'cpu'|'gpu'|'npu';\n    numThreads?: number;\n    powerPreference?: 'default'|'low-power'|'high-performance';\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     * ```\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    /**\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  // eslint-disable-next-line @typescript-eslint/no-empty-interface\n  interface ValueMetadata {\n    // TBD\n  }\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(feeds: InferenceSession.FeedsType, fetches: InferenceSession.FetchesType,\n      options?: InferenceSession.RunOptions): 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: ReadonlyArray<Readonly<InferenceSession.ValueMetadata>>;\n\n  // /**\n  //  * Get output metadata of the loaded model.\n  //  */\n  // readonly outputMetadata: ReadonlyArray<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(buffer: ArrayBufferLike, byteOffset: number, byteLength?: number, 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> extends\n    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> extends\n    CommonConstructorParameters<T>, 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> extends\n    CommonConstructorParameters<T>, 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\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 extends OptionResizedDimensions, OptionsTensorFormat, OptionsTensorLayout,\n                                                    OptionsTensorDataType, OptionsNormalizationParameters {}\n\nexport interface TensorFromImageElementOptions extends OptionResizedDimensions, OptionsTensorFormat,\n                                                       OptionsTensorLayout, OptionsTensorDataType,\n                                                       OptionsNormalizationParameters {}\n\nexport interface TensorFromUrlOptions extends OptionsDimensions, OptionResizedDimensions, OptionsTensorFormat,\n                                              OptionsTensorLayout, OptionsTensorDataType,\n                                              OptionsNormalizationParameters {}\n\nexport interface TensorFromImageBitmapOptions extends OptionResizedDimensions, OptionsTensorFormat, OptionsTensorLayout,\n                                                      OptionsTensorDataType, OptionsNormalizationParameters {}\n\nexport interface TensorFromTextureOptions<T extends Tensor.TextureDataTypes> extends\n    Required<OptionsDimensions>, OptionsFormat, GpuResourceConstructorParameters<T>/* TODO: add more */ {}\n\nexport interface TensorFromGpuBufferOptions<T extends Tensor.GpuBufferDataTypes> extends\n    Pick<Tensor, 'dims'>, 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(imageData: ImageData, 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(imageElement: HTMLImageElement, 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(bitmap: ImageBitmap, 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, options: TensorFromTextureOptions<T>): 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, options: TensorFromGpuBufferOptions<T>): 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, buffer: Tensor.DataTypeMap[T], dims?: readonly number[]): 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\nimport {resolveBackendAndExecutionProviders} from './backend-impl.js';\nimport {SessionHandler, TrainingSessionHandler} from './backend.js';\nimport {InferenceSession as InferenceSession} from './inference-session.js';\nimport {OnnxValue} from './onnx-value.js';\nimport {Tensor} from './tensor.js';\nimport {TrainingSession as TrainingSessionInterface, TrainingSessionCreateOptions} from './training-session.js';\n\ntype SessionOptions = InferenceSession.SessionOptions;\ntype FeedsType = InferenceSession.FeedsType;\ntype FetchesType = InferenceSession.FetchesType;\ntype ReturnType = InferenceSession.ReturnType;\ntype RunOptions = InferenceSession.RunOptions;\n\nconst noBackendErrMsg: string = 'Training backend could not be resolved. ' +\n    'Make sure you\\'re using the correct configuration & WebAssembly files.';\n\nexport class TrainingSession implements TrainingSessionInterface {\n  private constructor(handler: TrainingSessionHandler, hasOptimizerModel: boolean, hasEvalModel: boolean) {\n    this.handler = handler;\n    this.hasOptimizerModel = hasOptimizerModel;\n    this.hasEvalModel = hasEvalModel;\n  }\n  private handler: TrainingSessionHandler;\n  private hasOptimizerModel: boolean;\n  private hasEvalModel: boolean;\n\n  get trainingInputNames(): readonly string[] {\n    return this.handler.inputNames;\n  }\n  get trainingOutputNames(): readonly string[] {\n    return this.handler.outputNames;\n  }\n\n  get evalInputNames(): readonly string[] {\n    if (this.hasEvalModel) {\n      return this.handler.evalInputNames;\n    } else {\n      throw new Error('This training session has no evalModel loaded.');\n    }\n  }\n  get evalOutputNames(): readonly string[] {\n    if (this.hasEvalModel) {\n      return this.handler.evalOutputNames;\n    } else {\n      throw new Error('This training session has no evalModel loaded.');\n    }\n  }\n\n  static async create(trainingOptions: TrainingSessionCreateOptions, sessionOptions?: SessionOptions):\n      Promise<TrainingSession> {\n    const evalModel: string|Uint8Array = trainingOptions.evalModel || '';\n    const optimizerModel: string|Uint8Array = trainingOptions.optimizerModel || '';\n    const options: SessionOptions = sessionOptions || {};\n\n    // resolve backend, update session options with validated EPs, and create session handler\n    const [backend, optionsWithValidatedEPs] = await resolveBackendAndExecutionProviders(options);\n    if (backend.createTrainingSessionHandler) {\n      const handler = await backend.createTrainingSessionHandler(\n          trainingOptions.checkpointState, trainingOptions.trainModel, evalModel, optimizerModel,\n          optionsWithValidatedEPs);\n      return new TrainingSession(handler, !!trainingOptions.optimizerModel, !!trainingOptions.evalModel);\n    } else {\n      throw new Error(noBackendErrMsg);\n    }\n  }\n\n  /**\n   * Helper function for runTrainStep and future runStep methods that handles the type-narrowing conversion from\n   * the given parameters to SessionHandler.FetchesType and RunOptions.\n   *\n   * @param inputNames the feeds object is checked that they contain all input names in the provided list of input\n   * names.\n   * @param outputNames the fetches object is checked that their keys match up with valid names in the list of output\n   * names.\n   * @param feeds the required input\n   * @param arg1 narrowed & converted into the SessionHandler.FetchesType or RunOptions object\n   * @param arg2 optional RunOptions object.\n   * @returns\n   */\n  typeNarrowingForRunStep(\n      inputNames: readonly string[], outputNames: readonly string[], feeds: FeedsType, arg1?: FetchesType|RunOptions,\n      arg2?: RunOptions): [SessionHandler.FetchesType, RunOptions] {\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    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 (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 outputNames) {\n          if (arg1Keys.indexOf(name) !== -1) {\n            const v = (arg1 as InferenceSession.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 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 outputNames) {\n        fetches[name] = null;\n      }\n    }\n\n    return [fetches, options];\n  }\n\n  /**\n   * Helper method for runTrainStep and any other runStep methods. Takes the ReturnType result from the SessionHandler\n   * and changes it into a map of Tensors.\n   *\n   * @param results\n   * @returns\n   */\n  convertHandlerReturnTypeToMapOfTensors(results: SessionHandler.ReturnType): ReturnType {\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    return returnValue;\n  }\n\n  async lazyResetGrad(): Promise<void> {\n    await this.handler.lazyResetGrad();\n  }\n\n  runTrainStep(feeds: FeedsType, options?: RunOptions): Promise<ReturnType>;\n  runTrainStep(feeds: FeedsType, fetches: FetchesType, options?: RunOptions): Promise<ReturnType>;\n  async runTrainStep(feeds: FeedsType, arg1?: FetchesType|RunOptions, arg2?: RunOptions): Promise<ReturnType> {\n    const [fetches, options] =\n        this.typeNarrowingForRunStep(this.trainingInputNames, this.trainingOutputNames, feeds, arg1, arg2);\n    const results = await this.handler.runTrainStep(feeds, fetches, options);\n    return this.convertHandlerReturnTypeToMapOfTensors(results);\n  }\n\n  async runOptimizerStep(options?: InferenceSession.RunOptions|undefined): Promise<void> {\n    if (this.hasOptimizerModel) {\n      await this.handler.runOptimizerStep(options || {});\n    } else {\n      throw new Error('This TrainingSession has no OptimizerModel loaded.');\n    }\n  }\n\n  runEvalStep(feeds: FeedsType, options?: RunOptions|undefined): Promise<ReturnType>;\n  runEvalStep(feeds: FeedsType, fetches: FetchesType, options?: RunOptions|undefined): Promise<ReturnType>;\n  async runEvalStep(feeds: FeedsType, arg1?: FetchesType|RunOptions, arg2?: RunOptions): Promise<ReturnType> {\n    if (this.hasEvalModel) {\n      const [fetches, options] =\n          this.typeNarrowingForRunStep(this.evalInputNames, this.evalOutputNames, feeds, arg1, arg2);\n      const results = await this.handler.runEvalStep(feeds, fetches, options);\n      return this.convertHandlerReturnTypeToMapOfTensors(results);\n    } else {\n      throw new Error('This TrainingSession has no EvalModel loaded.');\n    }\n  }\n\n  async getParametersSize(trainableOnly = true): Promise<number> {\n    return this.handler.getParametersSize(trainableOnly);\n  }\n\n  async loadParametersBuffer(array: Uint8Array, trainableOnly = true): Promise<void> {\n    const paramsSize = await this.getParametersSize(trainableOnly);\n    // checking that the size of the Uint8Array is equivalent to the byte length of a Float32Array of the number\n    // of parameters\n    if (array.length !== 4 * paramsSize) {\n      throw new Error(\n          'Size of the buffer passed into loadParametersBuffer must match the number of parameters in ' +\n          'the model. Please use getParametersSize method to check.');\n    }\n    return this.handler.loadParametersBuffer(array, trainableOnly);\n  }\n\n  async getContiguousParameters(trainableOnly = true): Promise<OnnxValue> {\n    return this.handler.getContiguousParameters(trainableOnly);\n  }\n\n  async release(): Promise<void> {\n    return this.handler.dispose();\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';\nimport {TrainingSession as TrainingSessionImpl} from './training-session-impl.js';\n\n/* eslint-disable @typescript-eslint/no-redeclare */\n\nexport declare namespace TrainingSession {\n  /**\n   * Either URI file path (string) or Uint8Array containing model or checkpoint information.\n   */\n  type UriOrBuffer = string|Uint8Array;\n}\n\n/**\n * Represent a runtime instance of an ONNX training session,\n * which contains a model that can be trained, and, optionally,\n * an eval and optimizer model.\n */\nexport interface TrainingSession {\n  // #region run()\n\n  /**\n   * Lazily resets the gradients of all trainable parameters to zero. Should happen after the invocation of\n   * runOptimizerStep.\n   */\n  lazyResetGrad(): Promise<void>;\n\n  /**\n   * Run TrainStep asynchronously with the given feeds and options.\n   *\n   * @param feeds - Representation of the model input. See type description of `InferenceSession.InputType` for\n   detail.\n   * @param options - Optional. A set of options that controls the behavior of model training.\n   * @returns A promise that resolves to a map, which uses output names as keys and OnnxValue as corresponding values.\n   */\n  runTrainStep(feeds: InferenceSession.FeedsType, options?: InferenceSession.RunOptions):\n      Promise<InferenceSession.ReturnType>;\n\n  /**\n   * Run a single train step with the given inputs and options.\n   *\n   * @param feeds - Representation of the model input.\n   * @param fetches - Representation of the model output.\n   * detail.\n   * @param options - Optional. A set of options that controls the behavior of model training.\n   * @returns A promise that resolves to a map, which uses output names as keys and OnnxValue as corresponding\n   values.\n   */\n  runTrainStep(\n      feeds: InferenceSession.FeedsType, fetches: InferenceSession.FetchesType,\n      options?: InferenceSession.RunOptions): Promise<InferenceSession.ReturnType>;\n\n  /**\n   * Runs a single optimizer step, which performs weight updates for the trainable parameters using the optimizer model.\n   *\n   * @param options - Optional. A set of options that controls the behavior of model optimizing.\n   */\n  runOptimizerStep(options?: InferenceSession.RunOptions): Promise<void>;\n\n  /**\n   * Run a single eval step with the given inputs and options using the eval model.\n   *\n   * @param feeds - Representation of the model input.\n   * @param options - Optional. A set of options that controls the behavior of model eval step.\n   * @returns A promise that resolves to a map, which uses output names as keys and OnnxValue as corresponding\n   values.\n   */\n  runEvalStep(feeds: InferenceSession.FeedsType, options?: InferenceSession.RunOptions):\n      Promise<InferenceSession.ReturnType>;\n\n  /**\n   * Run a single eval step with the given inputs and options using the eval model.\n   *\n   * @param feeds - Representation of the model input.\n   * @param fetches - Representation of the model output.\n   * detail.\n   * @param options - Optional. A set of options that controls the behavior of model eval step.\n   * @returns A promise that resolves to a map, which uses output names as keys and OnnxValue as corresponding\n   values.\n   */\n  runEvalStep(\n      feeds: InferenceSession.FeedsType, fetches: InferenceSession.FetchesType,\n      options?: InferenceSession.RunOptions): Promise<InferenceSession.ReturnType>;\n\n  // #endregion\n\n  // #region copy parameters\n\n  /**\n   * Retrieves the size of all parameters for the training state. Calculates the total number of primitive (datatype of\n   * the parameters) elements of all the parameters in the training state.\n   *\n   * @param trainableOnly - When set to true, the size is calculated for trainable params only. Default value is true.\n   */\n  getParametersSize(trainableOnly: boolean): Promise<number>;\n\n  /**\n   * Copies parameter values from the given buffer to the training state. Currently, only supporting models with\n   * parameters of type Float32.\n   *\n   * @param buffer - A Uint8Array representation of Float32 parameters.\n   * @param trainableOnly - True if trainable parameters only to be modified, false otherwise. Default value is true.\n   */\n  loadParametersBuffer(buffer: Uint8Array, trainableOnly: boolean): Promise<void>;\n\n  /**\n   * Copies the model parameters to a contiguous buffer. Usually used in the context of Federated Learning.\n   * Currently, only supporting models with parameters of type Float32.\n   *\n   * @param trainableOnly - When set to true, only trainable parameters are copied. Trainable parameters are parameters\n   * for which requires_grad is set to true. Default value is true.\n   * @returns A promise that resolves to a Float32 OnnxValue of the requested parameters.\n   */\n  getContiguousParameters(trainableOnly: boolean): Promise<OnnxValue>;\n  // #endregion\n\n  // #region release()\n\n  /**\n   * Release the inference session and the underlying resources.\n   */\n  release(): Promise<void>;\n  // #endregion\n\n  // #region metadata\n\n  /**\n   * Get input names of the loaded training model.\n   */\n  readonly trainingInputNames: readonly string[];\n\n  /**\n   * Get output names of the loaded training model.\n   */\n  readonly trainingOutputNames: readonly string[];\n\n  /**\n   * Get input names of the loaded eval model. Is an empty array if no eval model is loaded.\n   */\n  readonly evalInputNames: readonly string[];\n\n  /**\n   * Get output names of the loaded eval model. Is an empty array if no eval model is loaded.\n   */\n  readonly evalOutputNames: readonly string[];\n\n  // #endregion\n}\n\n/**\n * Represents the optional parameters that can be passed into the TrainingSessionFactory.\n */\nexport interface TrainingSessionCreateOptions {\n  /**\n   * URI or buffer for a .ckpt file that contains the checkpoint for the training model.\n   */\n  checkpointState: TrainingSession.UriOrBuffer;\n  /**\n   * URI or buffer for the .onnx training file.\n   */\n  trainModel: TrainingSession.UriOrBuffer;\n  /**\n   * Optional. URI or buffer for the .onnx optimizer model file.\n   */\n  optimizerModel?: TrainingSession.UriOrBuffer;\n  /**\n   * Optional. URI or buffer for the .onnx eval model file.\n   */\n  evalModel?: TrainingSession.UriOrBuffer;\n}\n\n/**\n * Defines method overload possibilities for creating a TrainingSession.\n */\nexport interface TrainingSessionFactory {\n  // #region create()\n\n  /**\n   * Creates a new TrainingSession and asynchronously loads any models passed in through trainingOptions\n   *\n   * @param trainingOptions specify models and checkpoints to load into the Training Session\n   * @param sessionOptions specify configuration for training session behavior\n   *\n   * @returns Promise that resolves to a TrainingSession object\n   */\n  create(trainingOptions: TrainingSessionCreateOptions, sessionOptions?: InferenceSession.SessionOptions):\n      Promise<TrainingSession>;\n\n  // #endregion\n}\n\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const TrainingSession: TrainingSessionFactory = TrainingSessionImpl;\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';\nexport * from './training-session.js';\n", "export const cpus = undefined;", "export const readFile = undefined;export const readFileSync = undefined;export const createReadStream = undefined;", "export const join = undefined;", "\nvar ortWasm = (() => {\n  var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined;\n  if (typeof __filename !== 'undefined') _scriptDir = _scriptDir || __filename;\n  return (\nfunction(moduleArg = {}) {\n\nvar e=moduleArg,k,l;e.ready=new Promise((a,b)=>{k=a;l=b});var q=Object.assign({},e),v=\"./this.program\",aa=\"object\"==typeof window,x=\"function\"==typeof importScripts,ba=\"object\"==typeof process&&\"object\"==typeof process.versions&&\"string\"==typeof process.versions.node,y=\"\",A,B,C;\nif(ba){var fs=require(\"fs\"),D=require(\"path\");y=x?D.dirname(y)+\"/\":__dirname+\"/\";A=(a,b)=>{a=a.startsWith(\"file://\")?new URL(a):D.normalize(a);return fs.readFileSync(a,b?void 0:\"utf8\")};C=a=>{a=A(a,!0);a.buffer||(a=new Uint8Array(a));return a};B=(a,b,c,f=!0)=>{a=a.startsWith(\"file://\")?new URL(a):D.normalize(a);fs.readFile(a,f?void 0:\"utf8\",(g,h)=>{g?c(g):b(f?h.buffer:h)})};!e.thisProgram&&1<process.argv.length&&(v=process.argv[1].replace(/\\\\/g,\"/\"));process.argv.slice(2);e.inspect=()=>\"[Emscripten Module object]\"}else if(aa||\nx)x?y=self.location.href:\"undefined\"!=typeof document&&document.currentScript&&(y=document.currentScript.src),_scriptDir&&(y=_scriptDir),0!==y.indexOf(\"blob:\")?y=y.substr(0,y.replace(/[?#].*/,\"\").lastIndexOf(\"/\")+1):y=\"\",A=a=>{var b=new XMLHttpRequest;b.open(\"GET\",a,!1);b.send(null);return b.responseText},x&&(C=a=>{var b=new XMLHttpRequest;b.open(\"GET\",a,!1);b.responseType=\"arraybuffer\";b.send(null);return new Uint8Array(b.response)}),B=(a,b,c)=>{var f=new XMLHttpRequest;f.open(\"GET\",a,!0);f.responseType=\n\"arraybuffer\";f.onload=()=>{200==f.status||0==f.status&&f.response?b(f.response):c()};f.onerror=c;f.send(null)};var ca=e.print||console.log.bind(console),E=e.printErr||console.error.bind(console);Object.assign(e,q);q=null;e.thisProgram&&(v=e.thisProgram);var F;e.wasmBinary&&(F=e.wasmBinary);var noExitRuntime=e.noExitRuntime||!0;\"object\"!=typeof WebAssembly&&G(\"no native wasm support detected\");var H,I,da=!1,J,K,L,M;\nfunction ea(){var a=H.buffer;e.HEAP8=J=new Int8Array(a);e.HEAP16=new Int16Array(a);e.HEAP32=L=new Int32Array(a);e.HEAPU8=K=new Uint8Array(a);e.HEAPU16=new Uint16Array(a);e.HEAPU32=M=new Uint32Array(a);e.HEAPF32=new Float32Array(a);e.HEAPF64=new Float64Array(a)}var fa=[],ha=[],ia=[];function ja(){var a=e.preRun.shift();fa.unshift(a)}var N=0,O=null,P=null;\nfunction G(a){if(e.onAbort)e.onAbort(a);a=\"Aborted(\"+a+\")\";E(a);da=!0;a=new WebAssembly.RuntimeError(a+\". Build with -sASSERTIONS for more info.\");l(a);throw a;}function ka(a){return a.startsWith(\"data:application/octet-stream;base64,\")}var Q;Q=\"ort-wasm.wasm\";if(!ka(Q)){var la=Q;Q=e.locateFile?e.locateFile(la,y):y+la}function ma(a){if(a==Q&&F)return new Uint8Array(F);if(C)return C(a);throw\"both async and sync fetching of the wasm failed\";}\nfunction na(a){if(!F&&(aa||x)){if(\"function\"==typeof fetch&&!a.startsWith(\"file://\"))return fetch(a,{credentials:\"same-origin\"}).then(b=>{if(!b.ok)throw\"failed to load wasm binary file at '\"+a+\"'\";return b.arrayBuffer()}).catch(()=>ma(a));if(B)return new Promise((b,c)=>{B(a,f=>b(new Uint8Array(f)),c)})}return Promise.resolve().then(()=>ma(a))}function oa(a,b,c){return na(a).then(f=>WebAssembly.instantiate(f,b)).then(f=>f).then(c,f=>{E(\"failed to asynchronously prepare wasm: \"+f);G(f)})}\nfunction pa(a,b){var c=Q;return F||\"function\"!=typeof WebAssembly.instantiateStreaming||ka(c)||c.startsWith(\"file://\")||ba||\"function\"!=typeof fetch?oa(c,a,b):fetch(c,{credentials:\"same-origin\"}).then(f=>WebAssembly.instantiateStreaming(f,a).then(b,function(g){E(\"wasm streaming compile failed: \"+g);E(\"falling back to ArrayBuffer instantiation\");return oa(c,a,b)}))}var R,S=a=>{for(;0<a.length;)a.shift()(e)};\nfunction qa(a){this.va=a-24;this.Ea=function(b){M[this.va+4>>2>>>0]=b};this.za=function(b){M[this.va+8>>2>>>0]=b};this.xa=function(b,c){this.ya();this.Ea(b);this.za(c)};this.ya=function(){M[this.va+16>>2>>>0]=0}}\nvar ra=0,sa=0,ta=\"undefined\"!=typeof TextDecoder?new TextDecoder(\"utf8\"):void 0,ua=(a,b,c)=>{b>>>=0;var f=b+c;for(c=b;a[c]&&!(c>=f);)++c;if(16<c-b&&a.buffer&&ta)return ta.decode(a.subarray(b,c));for(f=\"\";b<c;){var g=a[b++];if(g&128){var h=a[b++]&63;if(192==(g&224))f+=String.fromCharCode((g&31)<<6|h);else{var m=a[b++]&63;g=224==(g&240)?(g&15)<<12|h<<6|m:(g&7)<<18|h<<12|m<<6|a[b++]&63;65536>g?f+=String.fromCharCode(g):(g-=65536,f+=String.fromCharCode(55296|g>>10,56320|g&1023))}}else f+=String.fromCharCode(g)}return f},\nT=(a,b)=>(a>>>=0)?ua(K,a,b):\"\",U=a=>{for(var b=0,c=0;c<a.length;++c){var f=a.charCodeAt(c);127>=f?b++:2047>=f?b+=2:55296<=f&&57343>=f?(b+=4,++c):b+=3}return b},V=(a,b,c,f)=>{c>>>=0;if(!(0<f))return 0;var g=c;f=c+f-1;for(var h=0;h<a.length;++h){var m=a.charCodeAt(h);if(55296<=m&&57343>=m){var r=a.charCodeAt(++h);m=65536+((m&1023)<<10)|r&1023}if(127>=m){if(c>=f)break;b[c++>>>0]=m}else{if(2047>=m){if(c+1>=f)break;b[c++>>>0]=192|m>>6}else{if(65535>=m){if(c+2>=f)break;b[c++>>>0]=224|m>>12}else{if(c+3>=\nf)break;b[c++>>>0]=240|m>>18;b[c++>>>0]=128|m>>12&63}b[c++>>>0]=128|m>>6&63}b[c++>>>0]=128|m&63}}b[c>>>0]=0;return c-g},W=a=>0===a%4&&(0!==a%100||0===a%400),va=[0,31,60,91,121,152,182,213,244,274,305,335],wa=[0,31,59,90,120,151,181,212,243,273,304,334],Ba=a=>{var b=U(a)+1,c=Aa(b);c&&V(a,K,c,b);return c},X={},Ca=()=>{if(!Y){var a={USER:\"web_user\",LOGNAME:\"web_user\",PATH:\"/\",PWD:\"/\",HOME:\"/home/web_user\",LANG:(\"object\"==typeof navigator&&navigator.languages&&navigator.languages[0]||\"C\").replace(\"-\",\n\"_\")+\".UTF-8\",_:v||\"./this.program\"},b;for(b in X)void 0===X[b]?delete a[b]:a[b]=X[b];var c=[];for(b in a)c.push(`${b}=${a[b]}`);Y=c}return Y},Y,Da=[null,[],[]],Ea=[31,29,31,30,31,30,31,31,30,31,30,31],Fa=[31,28,31,30,31,30,31,31,30,31,30,31];function Ga(a){var b=Array(U(a)+1);V(a,b,0,b.length);return b}\nfunction Ha(a,b,c,f){function g(d,n,p){for(d=\"number\"==typeof d?d.toString():d||\"\";d.length<n;)d=p[0]+d;return d}function h(d,n){return g(d,n,\"0\")}function m(d,n){function p(xa){return 0>xa?-1:0<xa?1:0}var z;0===(z=p(d.getFullYear()-n.getFullYear()))&&0===(z=p(d.getMonth()-n.getMonth()))&&(z=p(d.getDate()-n.getDate()));return z}function r(d){switch(d.getDay()){case 0:return new Date(d.getFullYear()-1,11,29);case 1:return d;case 2:return new Date(d.getFullYear(),0,3);case 3:return new Date(d.getFullYear(),\n0,2);case 4:return new Date(d.getFullYear(),0,1);case 5:return new Date(d.getFullYear()-1,11,31);case 6:return new Date(d.getFullYear()-1,11,30)}}function w(d){var n=d.ra;for(d=new Date((new Date(d.sa+1900,0,1)).getTime());0<n;){var p=d.getMonth(),z=(W(d.getFullYear())?Ea:Fa)[p];if(n>z-d.getDate())n-=z-d.getDate()+1,d.setDate(1),11>p?d.setMonth(p+1):(d.setMonth(0),d.setFullYear(d.getFullYear()+1));else{d.setDate(d.getDate()+n);break}}p=new Date(d.getFullYear()+1,0,4);n=r(new Date(d.getFullYear(),\n0,4));p=r(p);return 0>=m(n,d)?0>=m(p,d)?d.getFullYear()+1:d.getFullYear():d.getFullYear()-1}a>>>=0;b>>>=0;c>>>=0;f>>>=0;var t=L[f+40>>2>>>0];f={Ca:L[f>>2>>>0],Ba:L[f+4>>2>>>0],ta:L[f+8>>2>>>0],wa:L[f+12>>2>>>0],ua:L[f+16>>2>>>0],sa:L[f+20>>2>>>0],ma:L[f+24>>2>>>0],ra:L[f+28>>2>>>0],Fa:L[f+32>>2>>>0],Aa:L[f+36>>2>>>0],Da:t?T(t):\"\"};c=T(c);t={\"%c\":\"%a %b %d %H:%M:%S %Y\",\"%D\":\"%m/%d/%y\",\"%F\":\"%Y-%m-%d\",\"%h\":\"%b\",\"%r\":\"%I:%M:%S %p\",\"%R\":\"%H:%M\",\"%T\":\"%H:%M:%S\",\"%x\":\"%m/%d/%y\",\"%X\":\"%H:%M:%S\",\"%Ec\":\"%c\",\n\"%EC\":\"%C\",\"%Ex\":\"%m/%d/%y\",\"%EX\":\"%H:%M:%S\",\"%Ey\":\"%y\",\"%EY\":\"%Y\",\"%Od\":\"%d\",\"%Oe\":\"%e\",\"%OH\":\"%H\",\"%OI\":\"%I\",\"%Om\":\"%m\",\"%OM\":\"%M\",\"%OS\":\"%S\",\"%Ou\":\"%u\",\"%OU\":\"%U\",\"%OV\":\"%V\",\"%Ow\":\"%w\",\"%OW\":\"%W\",\"%Oy\":\"%y\"};for(var u in t)c=c.replace(new RegExp(u,\"g\"),t[u]);var ya=\"Sunday Monday Tuesday Wednesday Thursday Friday Saturday\".split(\" \"),za=\"January February March April May June July August September October November December\".split(\" \");t={\"%a\":d=>ya[d.ma].substring(0,3),\"%A\":d=>ya[d.ma],\"%b\":d=>\nza[d.ua].substring(0,3),\"%B\":d=>za[d.ua],\"%C\":d=>h((d.sa+1900)/100|0,2),\"%d\":d=>h(d.wa,2),\"%e\":d=>g(d.wa,2,\" \"),\"%g\":d=>w(d).toString().substring(2),\"%G\":d=>w(d),\"%H\":d=>h(d.ta,2),\"%I\":d=>{d=d.ta;0==d?d=12:12<d&&(d-=12);return h(d,2)},\"%j\":d=>{for(var n=0,p=0;p<=d.ua-1;n+=(W(d.sa+1900)?Ea:Fa)[p++]);return h(d.wa+n,3)},\"%m\":d=>h(d.ua+1,2),\"%M\":d=>h(d.Ba,2),\"%n\":()=>\"\\n\",\"%p\":d=>0<=d.ta&&12>d.ta?\"AM\":\"PM\",\"%S\":d=>h(d.Ca,2),\"%t\":()=>\"\\t\",\"%u\":d=>d.ma||7,\"%U\":d=>h(Math.floor((d.ra+7-d.ma)/7),2),\"%V\":d=>\n{var n=Math.floor((d.ra+7-(d.ma+6)%7)/7);2>=(d.ma+371-d.ra-2)%7&&n++;if(n)53==n&&(p=(d.ma+371-d.ra)%7,4==p||3==p&&W(d.sa)||(n=1));else{n=52;var p=(d.ma+7-d.ra-1)%7;(4==p||5==p&&W(d.sa%400-1))&&n++}return h(n,2)},\"%w\":d=>d.ma,\"%W\":d=>h(Math.floor((d.ra+7-(d.ma+6)%7)/7),2),\"%y\":d=>(d.sa+1900).toString().substring(2),\"%Y\":d=>d.sa+1900,\"%z\":d=>{d=d.Aa;var n=0<=d;d=Math.abs(d)/60;return(n?\"+\":\"-\")+String(\"0000\"+(d/60*100+d%60)).slice(-4)},\"%Z\":d=>d.Da,\"%%\":()=>\"%\"};c=c.replace(/%%/g,\"\\x00\\x00\");for(u in t)c.includes(u)&&\n(c=c.replace(new RegExp(u,\"g\"),t[u](f)));c=c.replace(/\\0\\0/g,\"%\");u=Ga(c);if(u.length>b)return 0;J.set(u,a>>>0);return u.length-1}\nvar Ja={a:function(a,b,c){a>>>=0;(new qa(a)).xa(b>>>0,c>>>0);ra=a;sa++;throw ra;},e:function(){return 0},H:function(){},x:function(){},z:function(){},k:function(){return 0},F:function(){},B:function(){},E:function(){},g:function(){},y:function(){},v:function(){},G:function(){},w:function(){},l:()=>!0,o:function(a,b,c){a=b+2097152>>>0<4194305-!!a?(a>>>0)+4294967296*b:NaN;c>>>=0;a=new Date(1E3*a);L[c>>2>>>0]=a.getUTCSeconds();L[c+4>>2>>>0]=a.getUTCMinutes();L[c+8>>2>>>0]=a.getUTCHours();L[c+12>>2>>>\n0]=a.getUTCDate();L[c+16>>2>>>0]=a.getUTCMonth();L[c+20>>2>>>0]=a.getUTCFullYear()-1900;L[c+24>>2>>>0]=a.getUTCDay();L[c+28>>2>>>0]=(a.getTime()-Date.UTC(a.getUTCFullYear(),0,1,0,0,0,0))/864E5|0},p:function(a,b,c){a=b+2097152>>>0<4194305-!!a?(a>>>0)+4294967296*b:NaN;c>>>=0;a=new Date(1E3*a);L[c>>2>>>0]=a.getSeconds();L[c+4>>2>>>0]=a.getMinutes();L[c+8>>2>>>0]=a.getHours();L[c+12>>2>>>0]=a.getDate();L[c+16>>2>>>0]=a.getMonth();L[c+20>>2>>>0]=a.getFullYear()-1900;L[c+24>>2>>>0]=a.getDay();L[c+28>>2>>>\n0]=(W(a.getFullYear())?va:wa)[a.getMonth()]+a.getDate()-1|0;L[c+36>>2>>>0]=-(60*a.getTimezoneOffset());b=(new Date(a.getFullYear(),6,1)).getTimezoneOffset();var f=(new Date(a.getFullYear(),0,1)).getTimezoneOffset();L[c+32>>2>>>0]=(b!=f&&a.getTimezoneOffset()==Math.min(f,b))|0},q:function(a){a>>>=0;var b=new Date(L[a+20>>2>>>0]+1900,L[a+16>>2>>>0],L[a+12>>2>>>0],L[a+8>>2>>>0],L[a+4>>2>>>0],L[a>>2>>>0],0),c=L[a+32>>2>>>0],f=b.getTimezoneOffset(),g=(new Date(b.getFullYear(),6,1)).getTimezoneOffset(),\nh=(new Date(b.getFullYear(),0,1)).getTimezoneOffset(),m=Math.min(h,g);0>c?L[a+32>>2>>>0]=Number(g!=h&&m==f):0<c!=(m==f)&&(g=Math.max(h,g),b.setTime(b.getTime()+6E4*((0<c?m:g)-f)));L[a+24>>2>>>0]=b.getDay();L[a+28>>2>>>0]=(W(b.getFullYear())?va:wa)[b.getMonth()]+b.getDate()-1|0;L[a>>2>>>0]=b.getSeconds();L[a+4>>2>>>0]=b.getMinutes();L[a+8>>2>>>0]=b.getHours();L[a+12>>2>>>0]=b.getDate();L[a+16>>2>>>0]=b.getMonth();L[a+20>>2>>>0]=b.getYear();a=b.getTime()/1E3;return Ia((R=a,1<=+Math.abs(R)?0<R?+Math.floor(R/\n4294967296)>>>0:~~+Math.ceil((R-+(~~R>>>0))/4294967296)>>>0:0)),a>>>0},m:function(){return-52},n:function(){},t:function(a,b,c){function f(w){return(w=w.toTimeString().match(/\\(([A-Za-z ]+)\\)$/))?w[1]:\"GMT\"}c>>>=0;var g=(new Date).getFullYear(),h=new Date(g,0,1),m=new Date(g,6,1);g=h.getTimezoneOffset();var r=m.getTimezoneOffset();M[a>>>0>>2>>>0]=60*Math.max(g,r);L[b>>>0>>2>>>0]=Number(g!=r);a=f(h);b=f(m);a=Ba(a);b=Ba(b);r<g?(M[c>>2>>>0]=a,M[c+4>>2>>>0]=b):(M[c>>2>>>0]=b,M[c+4>>2>>>0]=a)},d:()=>{G(\"\")},\nh:function(){return Date.now()},u:function(){return 4294901760},b:()=>performance.now(),I:function(a,b,c){b>>>=0;return K.copyWithin(a>>>0>>>0,b>>>0,b+(c>>>0)>>>0)},s:function(a){a>>>=0;var b=K.length;if(4294901760<a)return!1;for(var c=1;4>=c;c*=2){var f=b*(1+.2/c);f=Math.min(f,a+100663296);var g=Math;f=Math.max(a,f);a:{g=g.min.call(g,4294901760,f+(65536-f%65536)%65536)-H.buffer.byteLength+65535>>>16;try{H.grow(g);ea();var h=1;break a}catch(m){}h=void 0}if(h)return!0}return!1},C:function(a,b){a>>>=\n0;b>>>=0;var c=0;Ca().forEach(function(f,g){var h=b+c;g=M[a+4*g>>2>>>0]=h;for(h=0;h<f.length;++h)J[g++>>0>>>0]=f.charCodeAt(h);J[g>>0>>>0]=0;c+=f.length+1});return 0},D:function(a,b){a>>>=0;b>>>=0;var c=Ca();M[a>>2>>>0]=c.length;var f=0;c.forEach(function(g){f+=g.length+1});M[b>>2>>>0]=f;return 0},f:()=>52,j:function(){return 52},r:function(){return 70},i:function(a,b,c,f){b>>>=0;c>>>=0;f>>>=0;for(var g=0,h=0;h<c;h++){var m=M[b>>2>>>0],r=M[b+4>>2>>>0];b+=8;for(var w=0;w<r;w++){var t=K[m+w>>>0],u=\nDa[a];0===t||10===t?((1===a?ca:E)(ua(u,0)),u.length=0):u.push(t)}g+=r}M[f>>2>>>0]=g;return 0},A:Ha,c:function(a,b,c,f){return Ha(a>>>0,b>>>0,c>>>0,f>>>0)}};\n(function(){function a(c){c=c.exports;I=c=Ka(c);H=I.J;ea();ha.unshift(I.K);N--;e.monitorRunDependencies&&e.monitorRunDependencies(N);if(0==N&&(null!==O&&(clearInterval(O),O=null),P)){var f=P;P=null;f()}return c}var b={a:Ja};N++;e.monitorRunDependencies&&e.monitorRunDependencies(N);if(e.instantiateWasm)try{return e.instantiateWasm(b,a)}catch(c){E(\"Module.instantiateWasm callback failed with error: \"+c),l(c)}pa(b,function(c){a(c.instance)}).catch(l);return{}})();\ne._OrtInit=(a,b)=>(e._OrtInit=I.L)(a,b);e._OrtGetLastError=(a,b)=>(e._OrtGetLastError=I.M)(a,b);e._OrtCreateSessionOptions=(a,b,c,f,g,h,m,r,w,t)=>(e._OrtCreateSessionOptions=I.N)(a,b,c,f,g,h,m,r,w,t);e._OrtAppendExecutionProvider=(a,b)=>(e._OrtAppendExecutionProvider=I.O)(a,b);e._OrtAddFreeDimensionOverride=(a,b,c)=>(e._OrtAddFreeDimensionOverride=I.P)(a,b,c);e._OrtAddSessionConfigEntry=(a,b,c)=>(e._OrtAddSessionConfigEntry=I.Q)(a,b,c);e._OrtReleaseSessionOptions=a=>(e._OrtReleaseSessionOptions=I.R)(a);\ne._OrtCreateSession=(a,b,c)=>(e._OrtCreateSession=I.S)(a,b,c);e._OrtReleaseSession=a=>(e._OrtReleaseSession=I.T)(a);e._OrtGetInputOutputCount=(a,b,c)=>(e._OrtGetInputOutputCount=I.U)(a,b,c);e._OrtGetInputName=(a,b)=>(e._OrtGetInputName=I.V)(a,b);e._OrtGetOutputName=(a,b)=>(e._OrtGetOutputName=I.W)(a,b);e._OrtFree=a=>(e._OrtFree=I.X)(a);e._OrtCreateTensor=(a,b,c,f,g,h)=>(e._OrtCreateTensor=I.Y)(a,b,c,f,g,h);e._OrtGetTensorData=(a,b,c,f,g)=>(e._OrtGetTensorData=I.Z)(a,b,c,f,g);\ne._OrtReleaseTensor=a=>(e._OrtReleaseTensor=I._)(a);e._OrtCreateRunOptions=(a,b,c,f)=>(e._OrtCreateRunOptions=I.$)(a,b,c,f);e._OrtAddRunConfigEntry=(a,b,c)=>(e._OrtAddRunConfigEntry=I.aa)(a,b,c);e._OrtReleaseRunOptions=a=>(e._OrtReleaseRunOptions=I.ba)(a);e._OrtCreateBinding=a=>(e._OrtCreateBinding=I.ca)(a);e._OrtBindInput=(a,b,c)=>(e._OrtBindInput=I.da)(a,b,c);e._OrtBindOutput=(a,b,c,f)=>(e._OrtBindOutput=I.ea)(a,b,c,f);e._OrtClearBoundOutputs=a=>(e._OrtClearBoundOutputs=I.fa)(a);\ne._OrtReleaseBinding=a=>(e._OrtReleaseBinding=I.ga)(a);e._OrtRunWithBinding=(a,b,c,f,g)=>(e._OrtRunWithBinding=I.ha)(a,b,c,f,g);e._OrtRun=(a,b,c,f,g,h,m,r)=>(e._OrtRun=I.ia)(a,b,c,f,g,h,m,r);e._OrtEndProfiling=a=>(e._OrtEndProfiling=I.ja)(a);var Aa=e._malloc=a=>(Aa=e._malloc=I.ka)(a);e._free=a=>(e._free=I.la)(a);var Ia=a=>(Ia=I.na)(a),La=()=>(La=I.oa)(),Ma=a=>(Ma=I.pa)(a),Na=a=>(Na=I.qa)(a);\nfunction Ka(a){a=Object.assign({},a);var b=f=>()=>f()>>>0,c=f=>g=>f(g)>>>0;a.__errno_location=b(a.__errno_location);a.malloc=c(a.malloc);a.stackSave=b(a.stackSave);a.stackAlloc=c(a.stackAlloc);return a}e.stackAlloc=Na;e.stackSave=La;e.stackRestore=Ma;e.UTF8ToString=T;e.stringToUTF8=(a,b,c)=>V(a,K,b,c);e.lengthBytesUTF8=U;var Z;P=function Oa(){Z||Pa();Z||(P=Oa)};\nfunction Pa(){function a(){if(!Z&&(Z=!0,e.calledRun=!0,!da)){S(ha);k(e);if(e.onRuntimeInitialized)e.onRuntimeInitialized();if(e.postRun)for(\"function\"==typeof e.postRun&&(e.postRun=[e.postRun]);e.postRun.length;){var b=e.postRun.shift();ia.unshift(b)}S(ia)}}if(!(0<N)){if(e.preRun)for(\"function\"==typeof e.preRun&&(e.preRun=[e.preRun]);e.preRun.length;)ja();S(fa);0<N||(e.setStatus?(e.setStatus(\"Running...\"),setTimeout(function(){setTimeout(function(){e.setStatus(\"\")},1);a()},1)):a())}}\nif(e.preInit)for(\"function\"==typeof e.preInit&&(e.preInit=[e.preInit]);0<e.preInit.length;)e.preInit.pop()();Pa();\n\n\n  return moduleArg.ready\n}\n\n);\n})();\nif (typeof exports === 'object' && typeof module === 'object')\n  module.exports = ortWasm;\nelse if (typeof define === 'function' && define['amd'])\n  define([], () => ortWasm);\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport * as path from 'node:path';\nimport {Env} from 'onnxruntime-common';\n\nimport {OrtWasmModule} from './binding/ort-wasm';\nimport {OrtWasmThreadedModule} from './binding/ort-wasm-threaded';\n\n/* eslint-disable @typescript-eslint/no-require-imports */\nlet ortWasmFactory: EmscriptenModuleFactory<OrtWasmModule>;\n\nif (!BUILD_DEFS.DISABLE_TRAINING) {\n  ortWasmFactory = require('./binding/ort-training-wasm-simd.js');\n} else {\n  ortWasmFactory =\n      BUILD_DEFS.DISABLE_WEBGPU ? require('./binding/ort-wasm.js') : require('./binding/ort-wasm-simd.jsep.js');\n}\n\nconst ortWasmFactoryThreaded: EmscriptenModuleFactory<OrtWasmModule> = !BUILD_DEFS.DISABLE_WASM_THREAD ?\n    (BUILD_DEFS.DISABLE_WEBGPU ? require('./binding/ort-wasm-threaded.js') :\n                                 require('./binding/ort-wasm-simd-threaded.jsep.js')) :\n    ortWasmFactory;\n/* eslint-enable @typescript-eslint/no-require-imports */\n\nlet wasm: OrtWasmModule|undefined;\nlet initialized = false;\nlet initializing = false;\nlet aborted = false;\n\nconst isMultiThreadSupported = (numThreads: number): boolean => {\n  // WebAssembly threads are set to 1 (single thread).\n  if (numThreads === 1) {\n    return false;\n  }\n\n  // If 'SharedArrayBuffer' is not available, WebAssembly threads will not work.\n  if (typeof SharedArrayBuffer === 'undefined') {\n    if (typeof self !== 'undefined' && !self.crossOriginIsolated) {\n      // eslint-disable-next-line no-console\n      console.warn(\n          'env.wasm.numThreads is set to ' + 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    return false;\n  }\n\n  // onnxruntime-web does not support multi-threads in Node.js.\n  if (typeof process !== 'undefined' && process.versions && process.versions.node) {\n    // eslint-disable-next-line no-console\n    console.warn(\n        'env.wasm.numThreads is set to ' + numThreads +\n        ', however, currently onnxruntime-web does not support multi-threads in Node.js. ' +\n        'Please consider using onnxruntime-node for performance critical scenarios.');\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(new Uint8Array([\n      0, 97, 115, 109, 1, 0,  0,  0, 1, 4, 1,  96, 0,   0,  3, 2, 1,  0, 5,\n      4, 1,  3,   1,   1, 10, 11, 1, 9, 0, 65, 0,  254, 16, 2, 0, 26, 11\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(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,\n      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\n    ]));\n  } catch (e) {\n    return false;\n  }\n};\n\nconst getWasmFileName = (useSimd: boolean, useThreads: boolean) => {\n  if (useSimd) {\n    if (!BUILD_DEFS.DISABLE_TRAINING) {\n      return 'ort-training-wasm-simd.wasm';\n    }\n    return useThreads ? 'ort-wasm-simd-threaded.wasm' : 'ort-wasm-simd.wasm';\n  } else {\n    return useThreads ? 'ort-wasm-threaded.wasm' : 'ort-wasm.wasm';\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  const numThreads = flags.numThreads!;\n  const simd = flags.simd!;\n\n  const useThreads = isMultiThreadSupported(numThreads);\n  const useSimd = simd && isSimdSupported();\n\n  const wasmPaths = flags.wasmPaths;\n  const wasmPrefixOverride = typeof wasmPaths === 'string' ? wasmPaths : undefined;\n  const wasmFileName = getWasmFileName(useSimd, useThreads);\n  const wasmPathOverride = typeof wasmPaths === 'object' ? wasmPaths[wasmFileName] : undefined;\n\n  let isTimeout = false;\n\n  const tasks: Array<Promise<void>> = [];\n\n  // promise for timeout\n  if (timeout > 0) {\n    tasks.push(new Promise((resolve) => {\n      setTimeout(() => {\n        isTimeout = true;\n        resolve();\n      }, timeout);\n    }));\n  }\n\n  // promise for module initialization\n  tasks.push(new Promise((resolve, reject) => {\n    const factory = useThreads ? ortWasmFactoryThreaded : ortWasmFactory;\n    const config: Partial<OrtWasmModule> = {\n      locateFile: (fileName: string, scriptDirectory: string) => {\n        if (!BUILD_DEFS.DISABLE_WASM_THREAD && useThreads && fileName.endsWith('.worker.js') &&\n            typeof Blob !== 'undefined') {\n          return URL.createObjectURL(new Blob(\n              [\n                // This require() function is handled by esbuild plugin to load file content as string.\n                // eslint-disable-next-line @typescript-eslint/no-require-imports\n                require('./binding/ort-wasm-threaded.worker.js')\n              ],\n              {type: 'text/javascript'}));\n        }\n\n        if (fileName.endsWith('.wasm')) {\n          if (wasmPathOverride) {\n            return wasmPathOverride;\n          }\n\n          const prefix = wasmPrefixOverride ?? scriptDirectory;\n\n          if (!BUILD_DEFS.DISABLE_WEBGPU) {\n            if (wasmFileName === 'ort-wasm-simd.wasm') {\n              return prefix + 'ort-wasm-simd.jsep.wasm';\n            } else if (wasmFileName === 'ort-wasm-simd-threaded.wasm') {\n              return prefix + 'ort-wasm-simd-threaded.jsep.wasm';\n            }\n          }\n\n          return prefix + wasmFileName;\n        }\n\n        return scriptDirectory + fileName;\n      }\n    };\n\n    if (!BUILD_DEFS.DISABLE_WASM_THREAD && useThreads) {\n      config.numThreads = numThreads;\n      if (typeof Blob === 'undefined') {\n        config.mainScriptUrlOrBlob = path.join(__dirname, 'ort-wasm-threaded.js');\n      } else {\n        const scriptSourceCode = `var ortWasmThreaded=${factory.toString()};`;\n        config.mainScriptUrlOrBlob = new Blob([scriptSourceCode], {type: 'text/javascript'});\n      }\n    }\n\n    factory(config).then(\n        // wasm module initialized successfully\n        module => {\n          initializing = false;\n          initialized = true;\n          wasm = module;\n          resolve();\n        },\n        // wasm module failed to initialize\n        (what) => {\n          initializing = false;\n          aborted = true;\n          reject(what);\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    initializing = true;\n\n    (wasm as OrtWasmThreadedModule).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>, prefix: string, seen: WeakSet<Record<string, unknown>>,\n     handler: ExtraOptionsHandler): 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 paramsOffset = wasm.stackAlloc(8);\n    wasm._OrtGetLastError(paramsOffset, paramsOffset + 4);\n    const errorCode = wasm.HEAP32[paramsOffset / 4];\n    const errorMessagePointer = wasm.HEAPU32[paramsOffset / 4 + 1];\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' || !Number.isInteger(options.logSeverityLevel) ||\n        options.logSeverityLevel < 0 || options.logSeverityLevel > 4) {\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!, runOptions.logVerbosityLevel!, !!runOptions.terminate!, tagDataOffset);\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 {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 (options.executionProviders &&\n      options.executionProviders.some(ep => (typeof ep === 'string' ? ep : ep.name) === 'webgpu')) {\n    options.enableMemPattern = false;\n  }\n};\n\nconst setExecutionProviders =\n    (sessionOptionsHandle: number, executionProviders: readonly InferenceSession.ExecutionProviderConfig[],\n     allocs: number[]): void => {\n      for (const ep of executionProviders) {\n        let epName = typeof ep === 'string' ? ep : ep.name;\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              if (webnnOptions?.deviceType) {\n                const keyDataOffset = allocWasmString('deviceType', allocs);\n                const valueDataOffset = allocWasmString(webnnOptions.deviceType, allocs);\n                if (getInstance()._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !==\n                    0) {\n                  checkLastError(`Can't set a session config entry: 'deviceType' - ${webnnOptions.deviceType}.`);\n                }\n              }\n              if (webnnOptions?.numThreads) {\n                let numThreads = webnnOptions.numThreads;\n                // Just ignore invalid webnnOptions.numThreads.\n                if (typeof numThreads != 'number' || !Number.isInteger(numThreads) || numThreads < 0) {\n                  numThreads = 0;\n                }\n                const keyDataOffset = allocWasmString('numThreads', allocs);\n                const valueDataOffset = allocWasmString(numThreads.toString(), allocs);\n                if (getInstance()._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !==\n                    0) {\n                  checkLastError(`Can't set a session config entry: 'numThreads' - ${webnnOptions.numThreads}.`);\n                }\n              }\n              if (webnnOptions?.powerPreference) {\n                const keyDataOffset = allocWasmString('powerPreference', allocs);\n                const valueDataOffset = allocWasmString(webnnOptions.powerPreference, allocs);\n                if (getInstance()._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !==\n                    0) {\n                  checkLastError(\n                      `Can't set a session config entry: 'powerPreference' - ${webnnOptions.powerPreference}.`);\n                }\n              }\n            }\n            break;\n          case 'webgpu':\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                const keyDataOffset = allocWasmString('preferredLayout', allocs);\n                const valueDataOffset = allocWasmString(webgpuOptions.preferredLayout, allocs);\n                if (getInstance()._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !==\n                    0) {\n                  checkLastError(\n                      `Can't set a session config entry: 'preferredLayout' - ${webgpuOptions.preferredLayout}.`);\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        if (getInstance()._OrtAppendExecutionProvider(sessionOptionsHandle, epNameDataOffset) !== 0) {\n          checkLastError(`Can't append execution provider: ${epName}.`);\n        }\n      }\n    };\n\nexport const setSessionOptions = (options?: InferenceSession.SessionOptions): [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 = typeof sessionOptions.optimizedModelFilePath === 'string' ?\n        allocWasmString(sessionOptions.optimizedModelFilePath, allocs) :\n        0;\n\n    sessionOptionsHandle = wasm._OrtCreateSessionOptions(\n        graphOptimizationLevel, !!sessionOptions.enableCpuMemArena, !!sessionOptions.enableMemPattern, executionMode,\n        !!sessionOptions.enableProfiling, 0, logIdDataOffset, logSeverityLevel, logVerbosityLevel,\n        optimizedModelFilePathOffset);\n    if (sessionOptionsHandle === 0) {\n      checkLastError('Can\\'t create session options.');\n    }\n\n    if (sessionOptions.executionProviders) {\n      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      const keyDataOffset = allocWasmString('enableGraphCapture', allocs);\n      const valueDataOffset = allocWasmString(sessionOptions.enableGraphCapture.toString(), allocs);\n      if (wasm._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !== 0) {\n        checkLastError(\n            `Can't set a session config entry: 'enableGraphCapture' - ${sessionOptions.enableGraphCapture}.`);\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        const keyDataOffset = allocWasmString(key, allocs);\n        const valueDataOffset = allocWasmString(value, allocs);\n\n        if (wasm._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !== 0) {\n          checkLastError(`Can't set a session config entry: ${key} - ${value}.`);\n        }\n      });\n    }\n\n    return [sessionOptionsHandle, allocs];\n  } catch (e) {\n    if (sessionOptionsHandle !== 0) {\n      wasm._OrtReleaseSessionOptions(sessionOptionsHandle);\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\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\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\n    default:\n      throw new Error(`unsupported data type: ${typeProto}`);\n  }\n};\n\n/**\n * get tensor element size in bytes by the given data type\n * @returns size in integer or undefined if the data type is not supported\n */\nexport const getTensorElementSize = (dateType: number): number|\n    undefined => [undefined, 4, 1, 1, 2, 2, 4, 8, undefined, 1, 2, 8, 4, 8, undefined, undefined, undefined][dateType];\n\n/**\n * get typed array constructor by the given tensor type\n */\nexport const tensorTypeToTypedArrayConstructor = (type: Tensor.Type): Float32ArrayConstructor|Uint8ArrayConstructor|\n    Int8ArrayConstructor|Uint16ArrayConstructor|Int16ArrayConstructor|Int32ArrayConstructor|BigInt64ArrayConstructor|\n    Uint8ArrayConstructor|Float64ArrayConstructor|Uint32ArrayConstructor|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 => type === 'float32' ||\n    type === 'float16' || type === 'int32' || type === 'int64' || type === 'uint32' || type === 'uint8' ||\n    type === 'bool';\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    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'] as const)[location];\n", "export const readFile = undefined;export const readFileSync = undefined;export const createReadStream = undefined;", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport * as fs from 'fs';\nimport {readFile} from 'node:fs/promises';\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 (typeof process !== 'undefined' && process.versions && process.versions.node) {\n      // load file into ArrayBuffer in Node.js\n      try {\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 stream = fs.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\n  } else if (file instanceof Blob) {\n    return new Uint8Array(await file.arrayBuffer());\n  } else if (file instanceof Uint8Array) {\n    return file;\n  } else {\n    return new Uint8Array(file);\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {Env, InferenceSession, Tensor} from 'onnxruntime-common';\n\nimport {SerializableInternalBuffer, SerializableSessionMetadata, SerializableTensorMetadata, TensorMetadata} from './proxy-messages';\nimport {setRunOptions} from './run-options';\nimport {setSessionOptions} from './session-options';\nimport {dataLocationStringToEnum, getTensorElementSize, isGpuBufferSupportedType, logLevelStringToEnum, tensorDataTypeEnumToString, tensorDataTypeStringToEnum, tensorTypeToTypedArrayConstructor} 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()` or\n * `ort.TrainingSession.create()` is 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()` or `ort.TrainingSession.create()` is called. Unlike the first 3\n * steps (they only called once), this step will be done for each session. In this step, onnxruntime-web does the\n * 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 * intialize 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  if (!BUILD_DEFS.DISABLE_WEBGPU) {\n    // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires\n    const initJsep = require('./jsep/init').init;\n\n    if (epName === 'webgpu') {\n      // 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 (powerPreference !== undefined && powerPreference !== 'low-power' &&\n            powerPreference !== 'high-performance') {\n          throw new Error(`Invalid powerPreference setting: \"${powerPreference}\"`);\n        }\n        const forceFallbackAdapter = env.webgpu.forceFallbackAdapter;\n        if (forceFallbackAdapter !== undefined && typeof forceFallbackAdapter !== 'boolean') {\n          throw new Error(`Invalid forceFallbackAdapter setting: \"${forceFallbackAdapter}\"`);\n        }\n        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      } else {\n        // if adapter is set, validate it.\n        if (typeof adapter.limits !== 'object' || typeof adapter.features !== 'object' ||\n            typeof adapter.requestDevice !== 'function') {\n          throw new Error('Invalid GPU adapter set in `env.webgpu.adapter`. It must be a GPUAdapter object.');\n        }\n      }\n\n      if (!env.wasm.simd) {\n        throw new Error(\n            'Not supported for WebGPU=ON and SIMD=OFF. Please set `env.wasm.simd` to true when using `webgpu` EP');\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 = 'cpu'|'cpu-pinned'|'gpu-buffer';\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'.\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, inputNamesUTF8Encoded: number[], outputNamesUTF8Encoded: number[],\n  bindingState: IOBindingState|null, enableGraphCapture: boolean, 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 dataOffset = wasm.stackAlloc(8);\n    const errorCode = wasm._OrtGetInputOutputCount(sessionHandle, dataOffset, dataOffset + 4);\n    if (errorCode !== 0) {\n      checkLastError('Can\\'t get session input/output count.');\n    }\n    return [wasm.HEAP32[dataOffset / 4], wasm.HEAP32[dataOffset / 4 + 1]];\n  } finally {\n    wasm.stackRestore(stack);\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): 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] = 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(loadFile(typeof file === 'string' ? file : file.data).then(data => {\n          wasm.mountExternalData!(path, data);\n        }));\n      }\n\n      // wait for all external data files to be loaded\n      await Promise.all(loadingPromises);\n    }\n\n    sessionHandle = await wasm._OrtCreateSession(modelDataOffset, modelDataLength, sessionOptionsHandle);\n    if (sessionHandle === 0) {\n      checkLastError('Can\\'t create a session.');\n    }\n\n    const [inputCount, outputCount] = getSessionInputOutputCount(sessionHandle);\n\n    const enableGraphCapture = !!options?.enableGraphCapture;\n\n    const inputNames = [];\n    const outputNames = [];\n    const outputPreferredLocations: SupportedTensorDataLocationForInputOutput[] = [];\n    for (let i = 0; i < inputCount; i++) {\n      const name = wasm._OrtGetInputName(sessionHandle, i);\n      if (name === 0) {\n        checkLastError('Can\\'t get an input name.');\n      }\n      inputNamesUTF8Encoded.push(name);\n      inputNames.push(wasm.UTF8ToString(name));\n    }\n    for (let i = 0; i < outputCount; i++) {\n      const name = wasm._OrtGetOutputName(sessionHandle, i);\n      if (name === 0) {\n        checkLastError('Can\\'t get an output name.');\n      }\n      outputNamesUTF8Encoded.push(name);\n      const nameString = wasm.UTF8ToString(name);\n      outputNames.push(nameString);\n\n      if (!BUILD_DEFS.DISABLE_WEBGPU) {\n        if (enableGraphCapture && options?.preferredOutputLocation === undefined) {\n          outputPreferredLocations.push('gpu-buffer');\n          continue;\n        }\n        const location = typeof options?.preferredOutputLocation === 'string' ?\n            options.preferredOutputLocation :\n            options?.preferredOutputLocation?.[nameString] ?? 'cpu';\n        if (location !== 'cpu' && location !== 'cpu-pinned' && location !== 'gpu-buffer') {\n          throw new Error(`Not supported preferred output location: ${location}.`);\n        }\n        if (enableGraphCapture && location !== 'gpu-buffer') {\n          throw new Error(`Not supported preferred output location: ${\n              location}. Only 'gpu-buffer' location is supported when enableGraphCapture is true.`);\n        }\n        outputPreferredLocations.push(location);\n      }\n    }\n\n    // use IO binding only when at least one output is preffered to be on GPU.\n    let bindingState: IOBindingState|null = null;\n    if (!BUILD_DEFS.DISABLE_WEBGPU && outputPreferredLocations.some(l => l === 'gpu-buffer')) {\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.map(l => dataLocationStringToEnum(l)),\n      };\n    }\n\n    activeSessions.set(\n        sessionHandle,\n        [sessionHandle, inputNamesUTF8Encoded, outputNamesUTF8Encoded, bindingState, enableGraphCapture, false]);\n    return [sessionHandle, inputNames, outputNames];\n  } catch (e) {\n    inputNamesUTF8Encoded.forEach(buf => wasm._OrtFree(buf));\n    outputNamesUTF8Encoded.forEach(buf => wasm._OrtFree(buf));\n\n    if (ioBindingHandle !== 0) {\n      wasm._OrtReleaseBinding(ioBindingHandle);\n    }\n\n    if (sessionHandle !== 0) {\n      wasm._OrtReleaseSession(sessionHandle);\n    }\n    throw e;\n  } finally {\n    wasm._free(modelDataOffset);\n    if (sessionOptionsHandle !== 0) {\n      wasm._OrtReleaseSessionOptions(sessionOptionsHandle);\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      wasm._OrtClearBoundOutputs(ioBindingState.handle);\n    }\n    wasm._OrtReleaseBinding(ioBindingState.handle);\n  }\n\n  wasm.jsepOnReleaseSession?.(sessionId);\n\n  inputNamesUTF8Encoded.forEach(buf => wasm._OrtFree(buf));\n  outputNamesUTF8Encoded.forEach(buf => wasm._OrtFree(buf));\n  wasm._OrtReleaseSession(sessionHandle);\n  activeSessions.delete(sessionId);\n};\n\nexport const prepareInputOutputTensor =\n    (tensor: TensorMetadata|null, tensorHandles: number[], allocs: number[], sessionId: number, index: number,\n     enableGraphCapture = false): void => {\n      if (!tensor) {\n        tensorHandles.push(0);\n        return;\n      }\n\n      const wasm = getInstance();\n\n      const dataType = tensor[0];\n      const dims = tensor[1];\n      const location = tensor[3];\n\n      let rawData: number;\n      let dataByteLength: number;\n\n      if (dataType === 'string' && location === 'gpu-buffer') {\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      if (location === 'gpu-buffer') {\n        const gpuBuffer = tensor[2].gpuBuffer as GPUBuffer;\n        const elementSizeInBytes = getTensorElementSize(tensorDataTypeStringToEnum(dataType))!;\n        dataByteLength = dims.reduce((a, b) => a * b, 1) * elementSizeInBytes;\n\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      } else {\n        const data = tensor[2];\n\n        if (Array.isArray(data)) {\n          // string tensor\n          dataByteLength = 4 * data.length;\n          rawData = wasm._malloc(dataByteLength);\n          allocs.push(rawData);\n          let dataIndex = rawData / 4;\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.HEAPU32[dataIndex++] = allocWasmString(data[i], allocs);\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      const stack = wasm.stackSave();\n      const dimsOffset = wasm.stackAlloc(4 * dims.length);\n      try {\n        let dimIndex = dimsOffset / 4;\n        dims.forEach(d => wasm.HEAP32[dimIndex++] = d);\n        const tensor = wasm._OrtCreateTensor(\n            tensorDataTypeStringToEnum(dataType), rawData, dataByteLength, dimsOffset, dims.length,\n            dataLocationStringToEnum(location));\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, inputIndices: number[], inputTensors: TensorMetadata[], outputIndices: number[],\n    outputTensors: Array<TensorMetadata|null>, options: InferenceSession.RunOptions): Promise<TensorMetadata[]> => {\n  const wasm = getInstance();\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 * 4);\n  const inputNamesOffset = wasm.stackAlloc(inputCount * 4);\n  const outputValuesOffset = wasm.stackAlloc(outputCount * 4);\n  const outputNamesOffset = wasm.stackAlloc(outputCount * 4);\n\n  try {\n    [runOptionsHandle, runOptionsAllocs] = setRunOptions(options);\n\n    // create input tensors\n    for (let i = 0; i < inputCount; i++) {\n      prepareInputOutputTensor(\n          inputTensors[i], inputTensorHandles, inputOutputAllocs, sessionId, inputIndices[i], enableGraphCapture);\n    }\n\n    // create output tensors\n    for (let i = 0; i < outputCount; i++) {\n      prepareInputOutputTensor(\n          outputTensors[i], outputTensorHandles, inputOutputAllocs, sessionId, inputCount + outputIndices[i],\n          enableGraphCapture);\n    }\n\n    let inputValuesIndex = inputValuesOffset / 4;\n    let inputNamesIndex = inputNamesOffset / 4;\n    let outputValuesIndex = outputValuesOffset / 4;\n    let outputNamesIndex = outputNamesOffset / 4;\n    for (let i = 0; i < inputCount; i++) {\n      wasm.HEAPU32[inputValuesIndex++] = inputTensorHandles[i];\n      wasm.HEAPU32[inputNamesIndex++] = inputNamesUTF8Encoded[inputIndices[i]];\n    }\n    for (let i = 0; i < outputCount; i++) {\n      wasm.HEAPU32[outputValuesIndex++] = outputTensorHandles[i];\n      wasm.HEAPU32[outputNamesIndex++] = outputNamesUTF8Encoded[outputIndices[i]];\n    }\n\n    if (!BUILD_DEFS.DISABLE_WEBGPU && ioBindingState && !inputOutputBound) {\n      const {handle, outputPreferredLocations, outputPreferredLocationsEncoded} = ioBindingState;\n\n      if (inputNamesUTF8Encoded.length !== inputCount) {\n        throw new Error(`input count from feeds (${\n            inputCount}) is expected to be always equal to model's input count (${inputNamesUTF8Encoded.length}).`);\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 =\n              wasm._OrtBindOutput(handle, outputNamesUTF8Encoded[index], 0, outputPreferredLocationsEncoded[index]);\n          if (errorCode !== 0) {\n            checkLastError(`Can't bind output[${i}] to ${outputPreferredLocations[i]} for session=${sessionId}.`);\n          }\n        }\n      }\n      activeSessions.set(\n          sessionId,\n          [sessionHandle, inputNamesUTF8Encoded, outputNamesUTF8Encoded, ioBindingState, enableGraphCapture, true]);\n    }\n\n    wasm.jsepOnRunStart?.(sessionHandle);\n    let errorCode: number;\n    if (!BUILD_DEFS.DISABLE_WEBGPU && ioBindingState) {\n      errorCode = await wasm._OrtRunWithBinding(\n          sessionHandle, ioBindingState.handle, outputCount, outputValuesOffset, runOptionsHandle);\n    } else {\n      errorCode = await wasm._OrtRun(\n          sessionHandle, inputNamesOffset, inputValuesOffset, inputCount, outputNamesOffset, outputCount,\n          outputValuesOffset, runOptionsHandle);\n    }\n\n    if (errorCode !== 0) {\n      checkLastError('failed to call OrtRun().');\n    }\n\n    const output: TensorMetadata[] = [];\n\n    for (let i = 0; i < outputCount; i++) {\n      const tensor = wasm.HEAPU32[outputValuesOffset / 4 + i];\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 * 4);\n\n      let keepOutputTensor = false;\n      let type: Tensor.Type|undefined, dataOffset = 0;\n      try {\n        const errorCode = wasm._OrtGetTensorData(\n            tensor, tensorDataOffset, tensorDataOffset + 4, tensorDataOffset + 8, tensorDataOffset + 12);\n        if (errorCode !== 0) {\n          checkLastError(`Can't access output tensor data on index ${i}.`);\n        }\n        let tensorDataIndex = tensorDataOffset / 4;\n        const dataType = wasm.HEAPU32[tensorDataIndex++];\n        dataOffset = wasm.HEAPU32[tensorDataIndex++];\n        const dimsOffset = wasm.HEAPU32[tensorDataIndex++];\n        const dimsLength = wasm.HEAPU32[tensorDataIndex++];\n        const dims = [];\n        for (let i = 0; i < dimsLength; i++) {\n          dims.push(wasm.HEAPU32[dimsOffset / 4 + i]);\n        }\n        wasm._OrtFree(dimsOffset);\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') {\n            throw new Error('String tensor is not supported on GPU.');\n          }\n          const stringData: string[] = [];\n          let dataIndex = dataOffset / 4;\n          for (let i = 0; i < size; i++) {\n            const offset = wasm.HEAPU32[dataIndex++];\n            const maxBytesToRead = i === size - 1 ? undefined : wasm.HEAPU32[dataIndex] - 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 = 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 elementSize = getTensorElementSize(dataType);\n            if (elementSize === 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            output.push([\n              type, dims, {\n                gpuBuffer,\n                download: wasm.jsepCreateDownloader!(gpuBuffer, size * elementSize, type),\n                dispose: () => {\n                  wasm._OrtReleaseTensor(tensor);\n                }\n              },\n              'gpu-buffer'\n            ]);\n          } else {\n            const typedArrayConstructor = tensorTypeToTypedArrayConstructor(type);\n            const data = new typedArrayConstructor(size);\n            new Uint8Array(data.buffer, data.byteOffset, data.byteLength)\n                .set(wasm.HEAPU8.subarray(dataOffset, dataOffset + data.byteLength));\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      wasm._OrtClearBoundOutputs(ioBindingState.handle);\n      activeSessions.set(\n          sessionId,\n          [sessionHandle, inputNamesUTF8Encoded, outputNamesUTF8Encoded, ioBindingState, enableGraphCapture, false]);\n    }\n    return output;\n  } finally {\n    wasm.stackRestore(beforeRunStack);\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 {OrtWasmMessage, SerializableInternalBuffer, SerializableSessionMetadata, SerializableTensorMetadata, TensorMetadata} from './proxy-messages';\nimport * as core from './wasm-core-impl';\nimport {initializeWebAssembly} from './wasm-factory';\n\nconst isProxy = (): boolean => !!env.wasm.proxy && typeof document !== 'undefined';\nlet proxyWorker: Worker|undefined;\nlet initializing = false;\nlet initialized = false;\nlet aborted = false;\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      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\nconst scriptSrc = typeof document !== 'undefined' ? (document?.currentScript as HTMLScriptElement)?.src : undefined;\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    // overwrite wasm filepaths\n    if (env.wasm.wasmPaths === undefined) {\n      if (scriptSrc && scriptSrc.indexOf('blob:') !== 0) {\n        env.wasm.wasmPaths = scriptSrc.substr(0, +(scriptSrc).lastIndexOf('/') + 1);\n      }\n    }\n\n    return new Promise<void>((resolve, reject) => {\n      proxyWorker?.terminate();\n\n      const workerUrl = URL.createObjectURL(new Blob(\n          [\n            // This require() function is handled by esbuild plugin to load file content as string.\n            // eslint-disable-next-line @typescript-eslint/no-require-imports\n            require('./proxy-worker/main')\n          ],\n          {type: 'text/javascript'}));\n      proxyWorker = new Worker(workerUrl, {name: 'ort-wasm-proxy-worker'});\n      proxyWorker.onerror = (ev: ErrorEvent) => reject(ev);\n      proxyWorker.onmessage = onProxyWorkerMessage;\n      URL.revokeObjectURL(workerUrl);\n      initWasmCallbacks = [resolve, reject];\n      const message: OrtWasmMessage = {type: 'init-wasm', in : env};\n      proxyWorker.postMessage(message);\n    });\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 =\n    async(model: SerializableInternalBuffer|Uint8Array, 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, inputIndices: number[], inputs: TensorMetadata[], outputIndices: number[],\n    outputs: Array<TensorMetadata|null>, options: InferenceSession.RunOptions): 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', in : {sessionId, inputIndices, inputs: serializableInputs, outputIndices, options}};\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 {InferenceSession, InferenceSessionHandler, SessionHandler, Tensor, TRACE_FUNC_BEGIN, TRACE_FUNC_END} from 'onnxruntime-common';\n\nimport {SerializableInternalBuffer, TensorMetadata} from './proxy-messages';\nimport {copyFromExternalBuffer, createSession, endProfiling, releaseSession, run} from './proxy-wrapper';\nimport {isGpuBufferSupportedType} from './wasm-common';\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    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    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: string[];\n  outputNames: string[];\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 (typeof process !== 'undefined' && process.versions && process.versions.node) {\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] = await createSession(model, options);\n    TRACE_FUNC_END();\n  }\n\n  async dispose(): Promise<void> {\n    return releaseSession(this.sessionId);\n  }\n\n  async run(feeds: SessionHandler.FeedsType, fetches: SessionHandler.FetchesType, 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 =\n        inputArray.map((t, i) => encodeTensorMetadata(t, () => `input \"${this.inputNames[inputIndices[i]]}\"`));\n    const outputs = outputArray.map(\n        (t, i) => t ? encodeTensorMetadata(t, () => `output \"${this.outputNames[outputIndices[i]]}\"`) : null);\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 {cpus} from 'node:os';\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  if (typeof env.wasm.simd !== 'boolean') {\n    env.wasm.simd = true;\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    // Web: when crossOriginIsolated is false, SharedArrayBuffer is not available so WebAssembly threads will not work.\n    // Node.js: onnxruntime-web does not support multi-threads in Node.js.\n    if ((typeof self !== 'undefined' && !self.crossOriginIsolated) ||\n        (typeof process !== 'undefined' && process.versions && process.versions.node)) {\n      env.wasm.numThreads = 1;\n    }\n    const numCpuLogicalCores = typeof navigator === 'undefined' ? cpus().length : navigator.hardwareConcurrency;\n    env.wasm.numThreads = Math.min(4, Math.ceil((numCpuLogicalCores || 1) / 2));\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(path: string, options?: InferenceSession.SessionOptions):\n      Promise<InferenceSessionHandler>;\n  createInferenceSessionHandler(buffer: Uint8Array, options?: InferenceSession.SessionOptions):\n      Promise<InferenceSessionHandler>;\n  async createInferenceSessionHandler(pathOrBuffer: string|Uint8Array, options?: InferenceSession.SessionOptions):\n      Promise<InferenceSessionHandler> {\n    const handler = new OnnxruntimeWebAssemblySessionHandler();\n    await handler.loadModel(pathOrBuffer, options);\n    return Promise.resolve(handler);\n  }\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {OnnxruntimeWebAssemblyBackend} from './backend-wasm';\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// 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 = BUILD_DEFS.DISABLE_TRAINING ? require('./backend-wasm-inference').wasmBackend :\n                                                    require('./backend-wasm-training').wasmBackend;\n  if (!BUILD_DEFS.DISABLE_WEBGPU) {\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.18.0';\n"],
  "mappings": "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",
  "names": ["i", "env", "Tensor", "Tensor", "InferenceSession", "Tensor", "TrainingSession", "InferenceSession", "Tensor", "TrainingSession", "env", "wasm", "wasm", "wasm", "readFile", "readFile", "env", "wasm", "tensor", "errorCode", "i", "initializing", "initialized", "aborted", "copyFromExternalBuffer", "createSession", "releaseSession", "run", "endProfiling", "env", "Tensor", "copyFromExternalBuffer", "createSession", "releaseSession", "run", "endProfiling", "env", "version", "wasmBackend", "env", "version"]
}
