onnxruntime-web
Version:
A Javascript library for running ONNX models on browsers
1,256 lines (1,237 loc) • 2.58 MB
JavaScript
/*!
* ONNX Runtime Web v1.22.0
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License.
*/
"use strict";
var ort = (() => {
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
}) : x)(function(x) {
if (typeof require !== "undefined") return require.apply(this, arguments);
throw Error('Dynamic require of "' + x + '" is not supported');
});
var __esm = (fn, res) => function __init() {
return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
};
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// common/dist/esm/backend-impl.js
var backends, backendsSortedByPriority, registerBackend, tryResolveAndInitializeBackend, resolveBackendAndExecutionProviders;
var init_backend_impl = __esm({
"common/dist/esm/backend-impl.js"() {
"use strict";
backends = /* @__PURE__ */ new Map();
backendsSortedByPriority = [];
registerBackend = (name, backend, priority) => {
if (backend && typeof backend.init === "function" && typeof backend.createInferenceSessionHandler === "function") {
const currentBackend = backends.get(name);
if (currentBackend === void 0) {
backends.set(name, { backend, priority });
} else if (currentBackend.priority > priority) {
return;
} else if (currentBackend.priority === priority) {
if (currentBackend.backend !== backend) {
throw new Error(`cannot register backend "${name}" using priority ${priority}`);
}
}
if (priority >= 0) {
const i = backendsSortedByPriority.indexOf(name);
if (i !== -1) {
backendsSortedByPriority.splice(i, 1);
}
for (let i2 = 0; i2 < backendsSortedByPriority.length; i2++) {
if (backends.get(backendsSortedByPriority[i2]).priority <= priority) {
backendsSortedByPriority.splice(i2, 0, name);
return;
}
}
backendsSortedByPriority.push(name);
}
return;
}
throw new TypeError("not a valid backend");
};
tryResolveAndInitializeBackend = async (backendName) => {
const backendInfo = backends.get(backendName);
if (!backendInfo) {
return "backend not found.";
}
if (backendInfo.initialized) {
return backendInfo.backend;
} else if (backendInfo.aborted) {
return backendInfo.error;
} else {
const isInitializing = !!backendInfo.initPromise;
try {
if (!isInitializing) {
backendInfo.initPromise = backendInfo.backend.init(backendName);
}
await backendInfo.initPromise;
backendInfo.initialized = true;
return backendInfo.backend;
} catch (e) {
if (!isInitializing) {
backendInfo.error = `${e}`;
backendInfo.aborted = true;
}
return backendInfo.error;
} finally {
delete backendInfo.initPromise;
}
}
};
resolveBackendAndExecutionProviders = async (options) => {
const eps = options.executionProviders || [];
const backendHints = eps.map((i) => typeof i === "string" ? i : i.name);
const backendNames = backendHints.length === 0 ? backendsSortedByPriority : backendHints;
let backend;
const errors = [];
const availableBackendNames = /* @__PURE__ */ new Set();
for (const backendName of backendNames) {
const resolveResult = await tryResolveAndInitializeBackend(backendName);
if (typeof resolveResult === "string") {
errors.push({ name: backendName, err: resolveResult });
} else {
if (!backend) {
backend = resolveResult;
}
if (backend === resolveResult) {
availableBackendNames.add(backendName);
}
}
}
if (!backend) {
throw new Error(`no available backend found. ERR: ${errors.map((e) => `[${e.name}] ${e.err}`).join(", ")}`);
}
for (const { name, err } of errors) {
if (backendHints.includes(name)) {
console.warn(`removing requested execution provider "${name}" from session options because it is not available: ${err}`);
}
}
const filteredEps = eps.filter((i) => availableBackendNames.has(typeof i === "string" ? i : i.name));
return [
backend,
new Proxy(options, {
get: (target, prop) => {
if (prop === "executionProviders") {
return filteredEps;
}
return Reflect.get(target, prop);
}
})
];
};
}
});
// common/dist/esm/backend.js
var init_backend = __esm({
"common/dist/esm/backend.js"() {
"use strict";
init_backend_impl();
}
});
// common/dist/esm/version.js
var version;
var init_version = __esm({
"common/dist/esm/version.js"() {
"use strict";
version = "1.22.0";
}
});
// common/dist/esm/env-impl.js
var logLevelValue, env;
var init_env_impl = __esm({
"common/dist/esm/env-impl.js"() {
"use strict";
init_version();
logLevelValue = "warning";
env = {
wasm: {},
webgl: {},
webgpu: {},
versions: { common: version },
set logLevel(value) {
if (value === void 0) {
return;
}
if (typeof value !== "string" || ["verbose", "info", "warning", "error", "fatal"].indexOf(value) === -1) {
throw new Error(`Unsupported logging level: ${value}`);
}
logLevelValue = value;
},
get logLevel() {
return logLevelValue;
}
};
Object.defineProperty(env, "logLevel", { enumerable: true });
}
});
// common/dist/esm/env.js
var env2;
var init_env = __esm({
"common/dist/esm/env.js"() {
"use strict";
init_env_impl();
env2 = env;
}
});
// common/dist/esm/tensor-conversion-impl.js
var tensorToDataURL, tensorToImageData;
var init_tensor_conversion_impl = __esm({
"common/dist/esm/tensor-conversion-impl.js"() {
"use strict";
tensorToDataURL = (tensor, options) => {
const canvas = typeof document !== "undefined" ? document.createElement("canvas") : new OffscreenCanvas(1, 1);
canvas.width = tensor.dims[3];
canvas.height = tensor.dims[2];
const pixels2DContext = canvas.getContext("2d");
if (pixels2DContext != null) {
let width;
let height;
if (options?.tensorLayout !== void 0 && options.tensorLayout === "NHWC") {
width = tensor.dims[2];
height = tensor.dims[3];
} else {
width = tensor.dims[3];
height = tensor.dims[2];
}
const inputformat = options?.format !== void 0 ? options.format : "RGB";
const norm = options?.norm;
let normMean;
let normBias;
if (norm === void 0 || norm.mean === void 0) {
normMean = [255, 255, 255, 255];
} else {
if (typeof norm.mean === "number") {
normMean = [norm.mean, norm.mean, norm.mean, norm.mean];
} else {
normMean = [norm.mean[0], norm.mean[1], norm.mean[2], 0];
if (norm.mean[3] !== void 0) {
normMean[3] = norm.mean[3];
}
}
}
if (norm === void 0 || norm.bias === void 0) {
normBias = [0, 0, 0, 0];
} else {
if (typeof norm.bias === "number") {
normBias = [norm.bias, norm.bias, norm.bias, norm.bias];
} else {
normBias = [norm.bias[0], norm.bias[1], norm.bias[2], 0];
if (norm.bias[3] !== void 0) {
normBias[3] = norm.bias[3];
}
}
}
const stride = height * width;
let rTensorPointer = 0, gTensorPointer = stride, bTensorPointer = stride * 2, aTensorPointer = -1;
if (inputformat === "RGBA") {
rTensorPointer = 0;
gTensorPointer = stride;
bTensorPointer = stride * 2;
aTensorPointer = stride * 3;
} else if (inputformat === "RGB") {
rTensorPointer = 0;
gTensorPointer = stride;
bTensorPointer = stride * 2;
} else if (inputformat === "RBG") {
rTensorPointer = 0;
bTensorPointer = stride;
gTensorPointer = stride * 2;
}
for (let i = 0; i < height; i++) {
for (let j = 0; j < width; j++) {
const R = (tensor.data[rTensorPointer++] - normBias[0]) * normMean[0];
const G = (tensor.data[gTensorPointer++] - normBias[1]) * normMean[1];
const B = (tensor.data[bTensorPointer++] - normBias[2]) * normMean[2];
const A = aTensorPointer === -1 ? 255 : (tensor.data[aTensorPointer++] - normBias[3]) * normMean[3];
pixels2DContext.fillStyle = "rgba(" + R + "," + G + "," + B + "," + A + ")";
pixels2DContext.fillRect(j, i, 1, 1);
}
}
if ("toDataURL" in canvas) {
return canvas.toDataURL();
} else {
throw new Error("toDataURL is not supported");
}
} else {
throw new Error("Can not access image data");
}
};
tensorToImageData = (tensor, options) => {
const pixels2DContext = typeof document !== "undefined" ? document.createElement("canvas").getContext("2d") : new OffscreenCanvas(1, 1).getContext("2d");
let image;
if (pixels2DContext != null) {
let width;
let height;
let channels;
if (options?.tensorLayout !== void 0 && options.tensorLayout === "NHWC") {
width = tensor.dims[2];
height = tensor.dims[1];
channels = tensor.dims[3];
} else {
width = tensor.dims[3];
height = tensor.dims[2];
channels = tensor.dims[1];
}
const inputformat = options !== void 0 ? options.format !== void 0 ? options.format : "RGB" : "RGB";
const norm = options?.norm;
let normMean;
let normBias;
if (norm === void 0 || norm.mean === void 0) {
normMean = [255, 255, 255, 255];
} else {
if (typeof norm.mean === "number") {
normMean = [norm.mean, norm.mean, norm.mean, norm.mean];
} else {
normMean = [norm.mean[0], norm.mean[1], norm.mean[2], 255];
if (norm.mean[3] !== void 0) {
normMean[3] = norm.mean[3];
}
}
}
if (norm === void 0 || norm.bias === void 0) {
normBias = [0, 0, 0, 0];
} else {
if (typeof norm.bias === "number") {
normBias = [norm.bias, norm.bias, norm.bias, norm.bias];
} else {
normBias = [norm.bias[0], norm.bias[1], norm.bias[2], 0];
if (norm.bias[3] !== void 0) {
normBias[3] = norm.bias[3];
}
}
}
const stride = height * width;
if (options !== void 0) {
if (options.format !== void 0 && channels === 4 && options.format !== "RGBA" || channels === 3 && options.format !== "RGB" && options.format !== "BGR") {
throw new Error("Tensor format doesn't match input tensor dims");
}
}
const step = 4;
let rImagePointer = 0, gImagePointer = 1, bImagePointer = 2, aImagePointer = 3;
let rTensorPointer = 0, gTensorPointer = stride, bTensorPointer = stride * 2, aTensorPointer = -1;
if (inputformat === "RGBA") {
rTensorPointer = 0;
gTensorPointer = stride;
bTensorPointer = stride * 2;
aTensorPointer = stride * 3;
} else if (inputformat === "RGB") {
rTensorPointer = 0;
gTensorPointer = stride;
bTensorPointer = stride * 2;
} else if (inputformat === "RBG") {
rTensorPointer = 0;
bTensorPointer = stride;
gTensorPointer = stride * 2;
}
image = pixels2DContext.createImageData(width, height);
for (let i = 0; i < height * width; rImagePointer += step, gImagePointer += step, bImagePointer += step, aImagePointer += step, i++) {
image.data[rImagePointer] = (tensor.data[rTensorPointer++] - normBias[0]) * normMean[0];
image.data[gImagePointer] = (tensor.data[gTensorPointer++] - normBias[1]) * normMean[1];
image.data[bImagePointer] = (tensor.data[bTensorPointer++] - normBias[2]) * normMean[2];
image.data[aImagePointer] = aTensorPointer === -1 ? 255 : (tensor.data[aTensorPointer++] - normBias[3]) * normMean[3];
}
} else {
throw new Error("Can not access image data");
}
return image;
};
}
});
// common/dist/esm/tensor-factory-impl.js
var bufferToTensor, tensorFromImage, tensorFromTexture, tensorFromGpuBuffer, tensorFromMLTensor, tensorFromPinnedBuffer;
var init_tensor_factory_impl = __esm({
"common/dist/esm/tensor-factory-impl.js"() {
"use strict";
init_tensor_impl();
bufferToTensor = (buffer, options) => {
if (buffer === void 0) {
throw new Error("Image buffer must be defined");
}
if (options.height === void 0 || options.width === void 0) {
throw new Error("Image height and width must be defined");
}
if (options.tensorLayout === "NHWC") {
throw new Error("NHWC Tensor layout is not supported yet");
}
const { height, width } = options;
const norm = options.norm ?? { mean: 255, bias: 0 };
let normMean;
let normBias;
if (typeof norm.mean === "number") {
normMean = [norm.mean, norm.mean, norm.mean, norm.mean];
} else {
normMean = [norm.mean[0], norm.mean[1], norm.mean[2], norm.mean[3] ?? 255];
}
if (typeof norm.bias === "number") {
normBias = [norm.bias, norm.bias, norm.bias, norm.bias];
} else {
normBias = [norm.bias[0], norm.bias[1], norm.bias[2], norm.bias[3] ?? 0];
}
const inputformat = options.format !== void 0 ? options.format : "RGBA";
const outputformat = options.tensorFormat !== void 0 ? options.tensorFormat !== void 0 ? options.tensorFormat : "RGB" : "RGB";
const stride = height * width;
const float32Data = outputformat === "RGBA" ? new Float32Array(stride * 4) : new Float32Array(stride * 3);
let step = 4, rImagePointer = 0, gImagePointer = 1, bImagePointer = 2, aImagePointer = 3;
let rTensorPointer = 0, gTensorPointer = stride, bTensorPointer = stride * 2, aTensorPointer = -1;
if (inputformat === "RGB") {
step = 3;
rImagePointer = 0;
gImagePointer = 1;
bImagePointer = 2;
aImagePointer = -1;
}
if (outputformat === "RGBA") {
aTensorPointer = stride * 3;
} else if (outputformat === "RBG") {
rTensorPointer = 0;
bTensorPointer = stride;
gTensorPointer = stride * 2;
} else if (outputformat === "BGR") {
bTensorPointer = 0;
gTensorPointer = stride;
rTensorPointer = stride * 2;
}
for (let i = 0; i < stride; i++, rImagePointer += step, bImagePointer += step, gImagePointer += step, aImagePointer += step) {
float32Data[rTensorPointer++] = (buffer[rImagePointer] + normBias[0]) / normMean[0];
float32Data[gTensorPointer++] = (buffer[gImagePointer] + normBias[1]) / normMean[1];
float32Data[bTensorPointer++] = (buffer[bImagePointer] + normBias[2]) / normMean[2];
if (aTensorPointer !== -1 && aImagePointer !== -1) {
float32Data[aTensorPointer++] = (buffer[aImagePointer] + normBias[3]) / normMean[3];
}
}
const outputTensor = outputformat === "RGBA" ? new Tensor("float32", float32Data, [1, 4, height, width]) : new Tensor("float32", float32Data, [1, 3, height, width]);
return outputTensor;
};
tensorFromImage = async (image, options) => {
const isHTMLImageEle = typeof HTMLImageElement !== "undefined" && image instanceof HTMLImageElement;
const isImageDataEle = typeof ImageData !== "undefined" && image instanceof ImageData;
const isImageBitmap = typeof ImageBitmap !== "undefined" && image instanceof ImageBitmap;
const isString = typeof image === "string";
let data;
let bufferToTensorOptions = options ?? {};
const createCanvas = () => {
if (typeof document !== "undefined") {
return document.createElement("canvas");
} else if (typeof OffscreenCanvas !== "undefined") {
return new OffscreenCanvas(1, 1);
} else {
throw new Error("Canvas is not supported");
}
};
const createCanvasContext = (canvas) => {
if (typeof HTMLCanvasElement !== "undefined" && canvas instanceof HTMLCanvasElement) {
return canvas.getContext("2d");
} else if (canvas instanceof OffscreenCanvas) {
return canvas.getContext("2d");
} else {
return null;
}
};
if (isHTMLImageEle) {
const canvas = createCanvas();
canvas.width = image.width;
canvas.height = image.height;
const pixels2DContext = createCanvasContext(canvas);
if (pixels2DContext != null) {
let height = image.height;
let width = image.width;
if (options !== void 0 && options.resizedHeight !== void 0 && options.resizedWidth !== void 0) {
height = options.resizedHeight;
width = options.resizedWidth;
}
if (options !== void 0) {
bufferToTensorOptions = options;
if (options.tensorFormat !== void 0) {
throw new Error("Image input config format must be RGBA for HTMLImageElement");
} else {
bufferToTensorOptions.tensorFormat = "RGBA";
}
bufferToTensorOptions.height = height;
bufferToTensorOptions.width = width;
} else {
bufferToTensorOptions.tensorFormat = "RGBA";
bufferToTensorOptions.height = height;
bufferToTensorOptions.width = width;
}
pixels2DContext.drawImage(image, 0, 0);
data = pixels2DContext.getImageData(0, 0, width, height).data;
} else {
throw new Error("Can not access image data");
}
} else if (isImageDataEle) {
let height;
let width;
if (options !== void 0 && options.resizedWidth !== void 0 && options.resizedHeight !== void 0) {
height = options.resizedHeight;
width = options.resizedWidth;
} else {
height = image.height;
width = image.width;
}
if (options !== void 0) {
bufferToTensorOptions = options;
}
bufferToTensorOptions.format = "RGBA";
bufferToTensorOptions.height = height;
bufferToTensorOptions.width = width;
if (options !== void 0) {
const tempCanvas = createCanvas();
tempCanvas.width = width;
tempCanvas.height = height;
const pixels2DContext = createCanvasContext(tempCanvas);
if (pixels2DContext != null) {
pixels2DContext.putImageData(image, 0, 0);
data = pixels2DContext.getImageData(0, 0, width, height).data;
} else {
throw new Error("Can not access image data");
}
} else {
data = image.data;
}
} else if (isImageBitmap) {
if (options === void 0) {
throw new Error("Please provide image config with format for Imagebitmap");
}
const canvas = createCanvas();
canvas.width = image.width;
canvas.height = image.height;
const pixels2DContext = createCanvasContext(canvas);
if (pixels2DContext != null) {
const height = image.height;
const width = image.width;
pixels2DContext.drawImage(image, 0, 0, width, height);
data = pixels2DContext.getImageData(0, 0, width, height).data;
bufferToTensorOptions.height = height;
bufferToTensorOptions.width = width;
return bufferToTensor(data, bufferToTensorOptions);
} else {
throw new Error("Can not access image data");
}
} else if (isString) {
return new Promise((resolve, reject) => {
const canvas = createCanvas();
const context = createCanvasContext(canvas);
if (!image || !context) {
return reject();
}
const newImage = new Image();
newImage.crossOrigin = "Anonymous";
newImage.src = image;
newImage.onload = () => {
canvas.width = newImage.width;
canvas.height = newImage.height;
context.drawImage(newImage, 0, 0, canvas.width, canvas.height);
const img = context.getImageData(0, 0, canvas.width, canvas.height);
bufferToTensorOptions.height = canvas.height;
bufferToTensorOptions.width = canvas.width;
resolve(bufferToTensor(img.data, bufferToTensorOptions));
};
});
} else {
throw new Error("Input data provided is not supported - aborted tensor creation");
}
if (data !== void 0) {
return bufferToTensor(data, bufferToTensorOptions);
} else {
throw new Error("Input data provided is not supported - aborted tensor creation");
}
};
tensorFromTexture = (texture, options) => {
const { width, height, download, dispose } = options;
const dims = [1, height, width, 4];
return new Tensor({ location: "texture", type: "float32", texture, dims, download, dispose });
};
tensorFromGpuBuffer = (gpuBuffer, options) => {
const { dataType, dims, download, dispose } = options;
return new Tensor({ location: "gpu-buffer", type: dataType ?? "float32", gpuBuffer, dims, download, dispose });
};
tensorFromMLTensor = (mlTensor, options) => {
const { dataType, dims, download, dispose } = options;
return new Tensor({ location: "ml-tensor", type: dataType ?? "float32", mlTensor, dims, download, dispose });
};
tensorFromPinnedBuffer = (type, buffer, dims) => new Tensor({ location: "cpu-pinned", type, data: buffer, dims: dims ?? [buffer.length] });
}
});
// common/dist/esm/tensor-impl-type-mapping.js
var NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP, NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP, isTypedArrayChecked, checkTypedArray;
var init_tensor_impl_type_mapping = __esm({
"common/dist/esm/tensor-impl-type-mapping.js"() {
"use strict";
NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP = /* @__PURE__ */ new Map([
["float32", Float32Array],
["uint8", Uint8Array],
["int8", Int8Array],
["uint16", Uint16Array],
["int16", Int16Array],
["int32", Int32Array],
["bool", Uint8Array],
["float64", Float64Array],
["uint32", Uint32Array],
["int4", Uint8Array],
["uint4", Uint8Array]
]);
NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP = /* @__PURE__ */ new Map([
[Float32Array, "float32"],
[Uint8Array, "uint8"],
[Int8Array, "int8"],
[Uint16Array, "uint16"],
[Int16Array, "int16"],
[Int32Array, "int32"],
[Float64Array, "float64"],
[Uint32Array, "uint32"]
]);
isTypedArrayChecked = false;
checkTypedArray = () => {
if (!isTypedArrayChecked) {
isTypedArrayChecked = true;
const isBigInt64ArrayAvailable = typeof BigInt64Array !== "undefined" && BigInt64Array.from;
const isBigUint64ArrayAvailable = typeof BigUint64Array !== "undefined" && BigUint64Array.from;
const Float16Array2 = globalThis.Float16Array;
const isFloat16ArrayAvailable = typeof Float16Array2 !== "undefined" && Float16Array2.from;
if (isBigInt64ArrayAvailable) {
NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set("int64", BigInt64Array);
NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.set(BigInt64Array, "int64");
}
if (isBigUint64ArrayAvailable) {
NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set("uint64", BigUint64Array);
NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.set(BigUint64Array, "uint64");
}
if (isFloat16ArrayAvailable) {
NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set("float16", Float16Array2);
NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.set(Float16Array2, "float16");
} else {
NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set("float16", Uint16Array);
}
}
};
}
});
// common/dist/esm/tensor-utils-impl.js
var calculateSize, tensorReshape;
var init_tensor_utils_impl = __esm({
"common/dist/esm/tensor-utils-impl.js"() {
"use strict";
init_tensor_impl();
calculateSize = (dims) => {
let size = 1;
for (let i = 0; i < dims.length; i++) {
const dim = dims[i];
if (typeof dim !== "number" || !Number.isSafeInteger(dim)) {
throw new TypeError(`dims[${i}] must be an integer, got: ${dim}`);
}
if (dim < 0) {
throw new RangeError(`dims[${i}] must be a non-negative integer, got: ${dim}`);
}
size *= dim;
}
return size;
};
tensorReshape = (tensor, dims) => {
switch (tensor.location) {
case "cpu":
return new Tensor(tensor.type, tensor.data, dims);
case "cpu-pinned":
return new Tensor({
location: "cpu-pinned",
data: tensor.data,
type: tensor.type,
dims
});
case "texture":
return new Tensor({
location: "texture",
texture: tensor.texture,
type: tensor.type,
dims
});
case "gpu-buffer":
return new Tensor({
location: "gpu-buffer",
gpuBuffer: tensor.gpuBuffer,
type: tensor.type,
dims
});
case "ml-tensor":
return new Tensor({
location: "ml-tensor",
mlTensor: tensor.mlTensor,
type: tensor.type,
dims
});
default:
throw new Error(`tensorReshape: tensor location ${tensor.location} is not supported`);
}
};
}
});
// common/dist/esm/tensor-impl.js
var Tensor;
var init_tensor_impl = __esm({
"common/dist/esm/tensor-impl.js"() {
"use strict";
init_tensor_conversion_impl();
init_tensor_factory_impl();
init_tensor_impl_type_mapping();
init_tensor_utils_impl();
Tensor = class {
/**
* implementation.
*/
constructor(arg0, arg1, arg2) {
checkTypedArray();
let type;
let dims;
if (typeof arg0 === "object" && "location" in arg0) {
this.dataLocation = arg0.location;
type = arg0.type;
dims = arg0.dims;
switch (arg0.location) {
case "cpu-pinned": {
const expectedTypedArrayConstructor = NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.get(type);
if (!expectedTypedArrayConstructor) {
throw new TypeError(`unsupported type "${type}" to create tensor from pinned buffer`);
}
if (!(arg0.data instanceof expectedTypedArrayConstructor)) {
throw new TypeError(`buffer should be of type ${expectedTypedArrayConstructor.name}`);
}
this.cpuData = arg0.data;
break;
}
case "texture": {
if (type !== "float32") {
throw new TypeError(`unsupported type "${type}" to create tensor from texture`);
}
this.gpuTextureData = arg0.texture;
this.downloader = arg0.download;
this.disposer = arg0.dispose;
break;
}
case "gpu-buffer": {
if (type !== "float32" && type !== "float16" && type !== "int32" && type !== "int64" && type !== "uint32" && type !== "uint8" && type !== "bool" && type !== "uint4" && type !== "int4") {
throw new TypeError(`unsupported type "${type}" to create tensor from gpu buffer`);
}
this.gpuBufferData = arg0.gpuBuffer;
this.downloader = arg0.download;
this.disposer = arg0.dispose;
break;
}
case "ml-tensor": {
if (type !== "float32" && type !== "float16" && type !== "int32" && type !== "int64" && type !== "uint32" && type !== "uint64" && type !== "int8" && type !== "uint8" && type !== "bool" && type !== "uint4" && type !== "int4") {
throw new TypeError(`unsupported type "${type}" to create tensor from MLTensor`);
}
this.mlTensorData = arg0.mlTensor;
this.downloader = arg0.download;
this.disposer = arg0.dispose;
break;
}
default:
throw new Error(`Tensor constructor: unsupported location '${this.dataLocation}'`);
}
} else {
let data;
let maybeDims;
if (typeof arg0 === "string") {
type = arg0;
maybeDims = arg2;
if (arg0 === "string") {
if (!Array.isArray(arg1)) {
throw new TypeError("A string tensor's data must be a string array.");
}
data = arg1;
} else {
const typedArrayConstructor = NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.get(arg0);
if (typedArrayConstructor === void 0) {
throw new TypeError(`Unsupported tensor type: ${arg0}.`);
}
if (Array.isArray(arg1)) {
if (arg0 === "float16" && typedArrayConstructor === Uint16Array || arg0 === "uint4" || arg0 === "int4") {
throw new TypeError(`Creating a ${arg0} tensor from number array is not supported. Please use ${typedArrayConstructor.name} as data.`);
} else if (arg0 === "uint64" || arg0 === "int64") {
data = typedArrayConstructor.from(arg1, BigInt);
} else {
data = typedArrayConstructor.from(arg1);
}
} else if (arg1 instanceof typedArrayConstructor) {
data = arg1;
} else if (arg1 instanceof Uint8ClampedArray) {
if (arg0 === "uint8") {
data = Uint8Array.from(arg1);
} else {
throw new TypeError(`A Uint8ClampedArray tensor's data must be type of uint8`);
}
} else if (arg0 === "float16" && arg1 instanceof Uint16Array && typedArrayConstructor !== Uint16Array) {
data = new globalThis.Float16Array(arg1.buffer, arg1.byteOffset, arg1.length);
} else {
throw new TypeError(`A ${type} tensor's data must be type of ${typedArrayConstructor}`);
}
}
} else {
maybeDims = arg1;
if (Array.isArray(arg0)) {
if (arg0.length === 0) {
throw new TypeError("Tensor type cannot be inferred from an empty array.");
}
const firstElementType = typeof arg0[0];
if (firstElementType === "string") {
type = "string";
data = arg0;
} else if (firstElementType === "boolean") {
type = "bool";
data = Uint8Array.from(arg0);
} else {
throw new TypeError(`Invalid element type of data array: ${firstElementType}.`);
}
} else if (arg0 instanceof Uint8ClampedArray) {
type = "uint8";
data = Uint8Array.from(arg0);
} else {
const mappedType = NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.get(arg0.constructor);
if (mappedType === void 0) {
throw new TypeError(`Unsupported type for tensor data: ${arg0.constructor}.`);
}
type = mappedType;
data = arg0;
}
}
if (maybeDims === void 0) {
maybeDims = [data.length];
} else if (!Array.isArray(maybeDims)) {
throw new TypeError("A tensor's dims must be a number array");
}
dims = maybeDims;
this.cpuData = data;
this.dataLocation = "cpu";
}
const size = calculateSize(dims);
if (this.cpuData && size !== this.cpuData.length) {
if ((type === "uint4" || type === "int4") && Math.ceil(size / 2) === this.cpuData.length) {
} else {
throw new Error(`Tensor's size(${size}) does not match data length(${this.cpuData.length}).`);
}
}
this.type = type;
this.dims = dims;
this.size = size;
}
// #endregion
// #region factory
static async fromImage(image, options) {
return tensorFromImage(image, options);
}
static fromTexture(texture, options) {
return tensorFromTexture(texture, options);
}
static fromGpuBuffer(gpuBuffer, options) {
return tensorFromGpuBuffer(gpuBuffer, options);
}
static fromMLTensor(mlTensor, options) {
return tensorFromMLTensor(mlTensor, options);
}
static fromPinnedBuffer(type, buffer, dims) {
return tensorFromPinnedBuffer(type, buffer, dims);
}
// #endregion
// #region conversions
toDataURL(options) {
return tensorToDataURL(this, options);
}
toImageData(options) {
return tensorToImageData(this, options);
}
// #endregion
// #region properties
get data() {
this.ensureValid();
if (!this.cpuData) {
throw new Error("The data is not on CPU. Use `getData()` to download GPU data to CPU, or use `texture` or `gpuBuffer` property to access the GPU data directly.");
}
return this.cpuData;
}
get location() {
return this.dataLocation;
}
get texture() {
this.ensureValid();
if (!this.gpuTextureData) {
throw new Error("The data is not stored as a WebGL texture.");
}
return this.gpuTextureData;
}
get gpuBuffer() {
this.ensureValid();
if (!this.gpuBufferData) {
throw new Error("The data is not stored as a WebGPU buffer.");
}
return this.gpuBufferData;
}
get mlTensor() {
this.ensureValid();
if (!this.mlTensorData) {
throw new Error("The data is not stored as a WebNN MLTensor.");
}
return this.mlTensorData;
}
// #endregion
// #region methods
async getData(releaseData) {
this.ensureValid();
switch (this.dataLocation) {
case "cpu":
case "cpu-pinned":
return this.data;
case "texture":
case "gpu-buffer":
case "ml-tensor": {
if (!this.downloader) {
throw new Error("The current tensor is not created with a specified data downloader.");
}
if (this.isDownloading) {
throw new Error("The current tensor is being downloaded.");
}
try {
this.isDownloading = true;
const data = await this.downloader();
this.downloader = void 0;
this.dataLocation = "cpu";
this.cpuData = data;
if (releaseData && this.disposer) {
this.disposer();
this.disposer = void 0;
}
return data;
} finally {
this.isDownloading = false;
}
}
default:
throw new Error(`cannot get data from location: ${this.dataLocation}`);
}
}
dispose() {
if (this.isDownloading) {
throw new Error("The current tensor is being downloaded.");
}
if (this.disposer) {
this.disposer();
this.disposer = void 0;
}
this.cpuData = void 0;
this.gpuTextureData = void 0;
this.gpuBufferData = void 0;
this.mlTensorData = void 0;
this.downloader = void 0;
this.isDownloading = void 0;
this.dataLocation = "none";
}
// #endregion
// #region tensor utilities
ensureValid() {
if (this.dataLocation === "none") {
throw new Error("The tensor is disposed.");
}
}
reshape(dims) {
this.ensureValid();
if (this.downloader || this.disposer) {
throw new Error("Cannot reshape a tensor that owns GPU resource.");
}
return tensorReshape(this, dims);
}
};
}
});
// common/dist/esm/tensor.js
var Tensor2;
var init_tensor = __esm({
"common/dist/esm/tensor.js"() {
"use strict";
init_tensor_impl();
Tensor2 = Tensor;
}
});
// common/dist/esm/trace.js
var TRACE, TRACE_FUNC, TRACE_FUNC_BEGIN, TRACE_FUNC_END;
var init_trace = __esm({
"common/dist/esm/trace.js"() {
"use strict";
init_env_impl();
TRACE = (deviceType, label) => {
if (typeof env.trace === "undefined" ? !env.wasm.trace : !env.trace) {
return;
}
console.timeStamp(`${deviceType}::ORT::${label}`);
};
TRACE_FUNC = (msg, extraMsg) => {
const stack = new Error().stack?.split(/\r\n|\r|\n/g) || [];
let hasTraceFunc = false;
for (let i = 0; i < stack.length; i++) {
if (hasTraceFunc && !stack[i].includes("TRACE_FUNC")) {
let label = `FUNC_${msg}::${stack[i].trim().split(" ")[1]}`;
if (extraMsg) {
label += `::${extraMsg}`;
}
TRACE("CPU", label);
return;
}
if (stack[i].includes("TRACE_FUNC")) {
hasTraceFunc = true;
}
}
};
TRACE_FUNC_BEGIN = (extraMsg) => {
if (typeof env.trace === "undefined" ? !env.wasm.trace : !env.trace) {
return;
}
TRACE_FUNC("BEGIN", extraMsg);
};
TRACE_FUNC_END = (extraMsg) => {
if (typeof env.trace === "undefined" ? !env.wasm.trace : !env.trace) {
return;
}
TRACE_FUNC("END", extraMsg);
};
}
});
// common/dist/esm/inference-session-impl.js
var InferenceSession;
var init_inference_session_impl = __esm({
"common/dist/esm/inference-session-impl.js"() {
"use strict";
init_backend_impl();
init_tensor();
init_trace();
InferenceSession = class _InferenceSession {
constructor(handler) {
this.handler = handler;
}
async run(feeds, arg1, arg2) {
TRACE_FUNC_BEGIN();
const fetches = {};
let options = {};
if (typeof feeds !== "object" || feeds === null || feeds instanceof Tensor2 || Array.isArray(feeds)) {
throw new TypeError("'feeds' must be an object that use input names as keys and OnnxValue as corresponding values.");
}
let isFetchesEmpty = true;
if (typeof arg1 === "object") {
if (arg1 === null) {
throw new TypeError("Unexpected argument[1]: cannot be null.");
}
if (arg1 instanceof Tensor2) {
throw new TypeError("'fetches' cannot be a Tensor");
}
if (Array.isArray(arg1)) {
if (arg1.length === 0) {
throw new TypeError("'fetches' cannot be an empty array.");
}
isFetchesEmpty = false;
for (const name of arg1) {
if (typeof name !== "string") {
throw new TypeError("'fetches' must be a string array or an object.");
}
if (this.outputNames.indexOf(name) === -1) {
throw new RangeError(`'fetches' contains invalid output name: ${name}.`);
}
fetches[name] = null;
}
if (typeof arg2 === "object" && arg2 !== null) {
options = arg2;
} else if (typeof arg2 !== "undefined") {
throw new TypeError("'options' must be an object.");
}
} else {
let isFetches = false;
const arg1Keys = Object.getOwnPropertyNames(arg1);
for (const name of this.outputNames) {
if (arg1Keys.indexOf(name) !== -1) {
const v = arg1[name];
if (v === null || v instanceof Tensor2) {
isFetches = true;
isFetchesEmpty = false;
fetches[name] = v;
}
}
}
if (isFetches) {
if (typeof arg2 === "object" && arg2 !== null) {
options = arg2;
} else if (typeof arg2 !== "undefined") {
throw new TypeError("'options' must be an object.");
}
} else {
options = arg1;
}
}
} else if (typeof arg1 !== "undefined") {
throw new TypeError("Unexpected argument[1]: must be 'fetches' or 'options'.");
}
for (const name of this.inputNames) {
if (typeof feeds[name] === "undefined") {
throw new Error(`input '${name}' is missing in 'feeds'.`);
}
}
if (isFetchesEmpty) {
for (const name of this.outputNames) {
fetches[name] = null;
}
}
const results = await this.handler.run(feeds, fetches, options);
const returnValue = {};
for (const key in results) {
if (Object.hasOwnProperty.call(results, key)) {
const result = results[key];
if (result instanceof Tensor2) {
returnValue[key] = result;
} else {
returnValue[key] = new Tensor2(result.type, result.data, result.dims);
}
}
}
TRACE_FUNC_END();
return returnValue;
}
async release() {
return this.handler.dispose();
}
static async create(arg0, arg1, arg2, arg3) {
TRACE_FUNC_BEGIN();
let filePathOrUint8Array;
let options = {};
if (typeof arg0 === "string") {
filePathOrUint8Array = arg0;
if (typeof arg1 === "object" && arg1 !== null) {
options = arg1;
} else if (typeof arg1 !== "undefined") {
throw new TypeError("'options' must be an object.");
}
} else if (arg0 instanceof Uint8Array) {
filePathOrUint8Array = arg0;
if (typeof arg1 === "object" && arg1 !== null) {
options = arg1;
} else if (typeof arg1 !== "undefined") {
throw new TypeError("'options' must be an object.");
}
} else if (arg0 instanceof ArrayBuffer || typeof SharedArrayBuffer !== "undefined" && arg0 instanceof SharedArrayBuffer) {
const buffer = arg0;
let byteOffset = 0;
let byteLength = arg0.byteLength;
if (typeof arg1 === "object" && arg1 !== null) {
options = arg1;
} else if (typeof arg1 === "number") {
byteOffset = arg1;
if (!Number.isSafeInteger(byteOffset)) {
throw new RangeError("'byteOffset' must be an integer.");
}
if (byteOffset < 0 || byteOffset >= buffer.byteLength) {
throw new RangeError(`'byteOffset' is out of range [0, ${buffer.byteLength}).`);
}
byteLength = arg0.byteLength - byteOffset;
if (typeof arg2 === "number") {
byteLength = arg2;
if (!Number.isSafeInteger(byteLength)) {
throw new RangeError("'byteLength' must be an integer.");
}
if (byteLength <= 0 || byteOffset + byteLength > buffer.byteLength) {
throw new RangeError(`'byteLength' is out of range (0, ${buffer.byteLength - byteOffset}].`);
}
if (typeof arg3 === "object" && arg3 !== null) {
options = arg3;
} else if (typeof arg3 !== "undefined") {
throw new TypeError("'options' must be an object.");
}
} else if (typeof arg2 !== "undefined") {
throw new TypeError("'byteLength' must be a number.");
}
} else if (typeof arg1 !== "undefined") {
throw new TypeError("'options' must be an object.");
}
filePathOrUint8Array = new Uint8Array(buffer, byteOffset, byteLength);
} else {
throw new TypeError("Unexpected argument[0]: must be 'path' or 'buffer'.");
}
const [backend, optionsWithValidatedEPs] = await resolveBackendAndExecutionProviders(options);
const handler = await backend.createInferenceSessionHandler(filePathOrUint8Array, optionsWithValidatedEPs);
TRACE_FUNC_END();
return new _InferenceSession(handler);
}
startProfiling() {
this.handler.startProfiling();
}
endProfiling() {
this.handler.endProfiling();
}
get inputNames() {
return this.handler.inputNames;
}
get outputNames() {
return this.handler.outputNames;
}
get inputMetadata() {
return this.handler.inputMetadata;
}
get outputMetadata() {
return this.handler.outputMetadata;
}
};
}
});
// common/dist/esm/inference-session.js
var InferenceSession2;
var init_inference_session = __esm({
"common/dist/esm/inference-session.js"() {
"use strict";
init_inference_session_impl();
InferenceSession2 = InferenceSession;
}
});
// common/dist/esm/tensor-conversion.js
var init_tensor_conversion = __esm({
"common/dist/esm/tensor-conversion.js"() {
"use strict";
}
});
// common/dist/esm/tensor-factory.js
var init_tensor_factory = __esm({
"common/dist/esm/tensor-factory.js"() {
"use strict";
}
});
// common/dist/esm/onnx-model.js
var init_onnx_model = __esm({
"common/dist/esm/onnx-model.js"() {
"use strict";
}
});
// common/dist/esm/onnx-value.js
var init_onnx_value = __esm({
"common/dist/esm/onnx-value.js"() {
"use strict";
}
});
// common/dist/esm/index.js
var esm_exports = {};
__export(esm_exports, {
InferenceSession: () => InferenceSession2,
TRACE: () => TRACE,
TRACE_FUNC_BEGIN: () => TRACE_FUNC_BEGIN,
TRACE_FUNC_END: () => TRACE_FUNC_END,
Tensor: () => Tensor2,
env: () => env2,
registerBackend: () => registerBacken