Spracherkennung für: .mjs vermutete Sprache: Unknown {[0] [0] [0]} [Methode: Schwerpunktbildung, einfache Gewichte, sechs Dimensionen]
/*!
* ONNX Runtime Web v1.20.1
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License.
*/
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
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 __commonJS = (cb, mod2) => function __require2() {
return mod2 || (0, cb[__getOwnPropNames(cb)[0]])((mod2 = { exports: {} }).exports, mod2), mod2.exports;
};
var __export = (target, all) => {
for (var name2 in all)
__defProp(target, name2, { get: all[name2], 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 __toESM = (mod2, isNodeMode, target) => (target = mod2 != null ? __create(__getProtoOf(mod2)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod2 || !mod2.__esModule ? __defProp(target, "default", { value: mod2, enumerable: true }) : target,
mod2
));
var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);
// 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 = (name2, backend2, priority) => {
if (backend2 && typeof backend2.init === "function" && typeof backend2.createInferenceSessionHandler === "function") {
const currentBackend = backends.get(name2);
if (currentBackend === void 0) {
backends.set(name2, { backend: backend2, priority });
} else if (currentBackend.priority > priority) {
return;
} else if (currentBackend.priority === priority) {
if (currentBackend.backend !== backend2) {
throw new Error(`cannot register backend "${name2}" using priority ${priority}`);
}
}
if (priority >= 0) {
const i = backendsSortedByPriority.indexOf(name2);
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, name2);
return;
}
}
backendsSortedByPriority.push(name2);
}
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 backend2;
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 (!backend2) {
backend2 = resolveResult;
}
if (backend2 === resolveResult) {
availableBackendNames.add(backendName);
}
}
}
if (!backend2) {
throw new Error(`no available backend found. ERR: ${errors.map((e) => `[${e.name}] ${e.err}`).join(", ")}`);
}
for (const { name: name2, err } of errors) {
if (backendHints.includes(name2)) {
console.warn(`removing requested execution provider "${name2}" from session options because it is not available: ${err}`);
}
}
const filteredEps = eps.filter((i) => availableBackendNames.has(typeof i === "string" ? i : i.name));
return [
backend2,
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.20.1";
}
});
// 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 createCanvas2 = () => {
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 = createCanvas2();
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 = createCanvas2();
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 = createCanvas2();
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 = createCanvas2();
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 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
});
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") {
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 {
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 name2 of arg1) {
if (typeof name2 !== "string") {
throw new TypeError("'fetches' must be a string array or an object.");
}
if (this.outputNames.indexOf(name2) === -1) {
throw new RangeError(`'fetches' contains invalid output name: ${name2}.`);
}
fetches[name2] = 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 name2 of this.outputNames) {
if (arg1Keys.indexOf(name2) !== -1) {
const v = arg1[name2];
if (v === null || v instanceof Tensor2) {
isFetches = true;
isFetchesEmpty = false;
fetches[name2] = 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 name2 of this.inputNames) {
if (typeof feeds[name2] === "undefined") {
throw new Error(`input '${name2}' is missing in 'feeds'.`);
}
}
if (isFetchesEmpty) {
for (const name2 of this.outputNames) {
fetches[name2] = 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 [backend2, optionsWithValidatedEPs] = await resolveBackendAndExecutionProviders(options);
const handler = await backend2.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 [backend2, optionsWithValidatedEPs] = await resolveBackendAndExecutionProviders(options);
if (backend2.createTrainingSessionHandler) {
const handler = await backend2.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 name2 of arg1) {
if (typeof name2 !== "string") {
throw new TypeError("'fetches' must be a string array or an object.");
}
if (outputNames.indexOf(name2) === -1) {
throw new RangeError(`'fetches' contains invalid output name: ${name2}.`);
}
fetches[name2] = 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 name2 of outputNames) {
if (arg1Keys.indexOf(name2) !== -1) {
const v = arg1[name2];
if (v === null || v instanceof Tensor2) {
isFetches = true;
isFetchesEmpty = false;
fetches[name2] = 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 name2 of inputNames) {
if (typeof feeds[name2] === "undefined") {
throw new Error(`input '${name2}' is missing in 'feeds'.`);
}
}
if (isFetchesEmpty) {
for (const name2 of outputNames) {
fetches[name2] = 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();
}
});
// web/lib/onnxjs/instrument.ts
function log(arg0, arg1, arg2, arg3) {
if (arg1 === void 0) {
return createCategorizedLogger(arg0);
} else if (arg2 === void 0) {
logInternal(arg0, arg1, 1);
} else if (typeof arg2 === "number" && arg3 === void 0) {
logInternal(arg0, arg1, arg2);
} else if (typeof arg2 === "string" && arg3 === void 0) {
logInternal(arg0, arg2, 1, arg1);
} else if (typeof arg2 === "string" && typeof arg3 === "number") {
logInternal(arg0, arg2, arg3, arg1);
} else {
throw new TypeError("input is valid");
}
}
function createCategorizedLogger(category) {
return {
verbose: log.verbose.bind(null, category),
info: log.info.bind(null, category),
warning: log.warning.bind(null, category),
error: log.error.bind(null, category),
fatal: log.fatal.bind(null, category)
};
}
function logInternal(severity, content, _stack, category) {
const config = LOGGER_CONFIG_MAP[category || ""] || LOGGER_CONFIG_MAP[""];
if (SEVERITY_VALUE[severity] < SEVERITY_VALUE[config.minimalSeverity]) {
return;
}
if (config.logDateTime) {
content = `${(/* @__PURE__ */ new Date()).toISOString()}|${content}`;
}
if (config.logSourceLocation) {
}
LOGGER_PROVIDER_MAP[config.provider].log(severity, content, category);
}
var NoOpLoggerProvider, ConsoleLoggerProvider, SEVERITY_VALUE, LOGGER_PROVIDER_MAP, LOGGER_DEFAULT_CONFIG, LOGGER_CONFIG_MAP, Logger, Event, EventRecord, Profiler, now;
var init_instrument = __esm({
"web/lib/onnxjs/instrument.ts"() {
"use strict";
NoOpLoggerProvider = class {
log(_severity, _content, _category) {
}
};
ConsoleLoggerProvider = class {
log(severity, content, category) {
console.log(`${this.color(severity)} ${category ? "\x1B[35m" + category + "\x1B[0m " : ""}${content}`);
}
color(severity) {
switch (severity) {
case "verbose":
return "\x1B[34;40mv\x1B[0m";
case "info":
return "\x1B[32mi\x1B[0m";
case "warning":
return "\x1B[30;43mw\x1B[0m";
case "error":
return "\x1B[31;40me\x1B[0m";
case "fatal":
return "\x1B[101mf\x1B[0m";
default:
throw new Error(`unsupported severity: ${severity}`);
}
}
};
SEVERITY_VALUE = {
verbose: 1e3,
info: 2e3,
warning: 4e3,
error: 5e3,
fatal: 6e3
};
LOGGER_PROVIDER_MAP = {
["none"]: new NoOpLoggerProvider(),
["console"]: new ConsoleLoggerProvider()
};
LOGGER_DEFAULT_CONFIG = {
provider: "console",
minimalSeverity: "warning",
logDateTime: true,
logSourceLocation: false
};
LOGGER_CONFIG_MAP = {
[""]: LOGGER_DEFAULT_CONFIG
};
((log3) => {
function verbose(arg0, arg1) {
log3("verbose", arg0, arg1);
}
log3.verbose = verbose;
function info(arg0, arg1) {
log3("info", arg0, arg1);
}
log3.info = info;
function warning(arg0, arg1) {
log3("warning", arg0, arg1);
}
log3.warning = warning;
function error(arg0, arg1) {
log3("error", arg0, arg1);
}
log3.error = error;
function fatal(arg0, arg1) {
log3("fatal", arg0, arg1);
}
log3.fatal = fatal;
function reset(config) {
LOGGER_CONFIG_MAP = {};
set("", config || {});
}
log3.reset = reset;
function set(category, config) {
if (category === "*") {
reset(config);
} else {
const previousConfig = LOGGER_CONFIG_MAP[category] || LOGGER_DEFAULT_CONFIG;
LOGGER_CONFIG_MAP[category] = {
provider: config.provider || previousConfig.provider,
minimalSeverity: config.minimalSeverity || previousConfig.minimalSeverity,
logDateTime: config.logDateTime === void 0 ? previousConfig.logDateTime : config.logDateTime,
logSourceLocation: config.logSourceLocation === void 0 ? previousConfig.logSourceLocation : config.logSourceLocation
};
}
}
log3.set = set;
function setWithEnv(env3) {
const config = {};
if (env3.logLevel) {
config.minimalSeverity = env3.logLevel;
}
set("", config);
}
log3.setWithEnv = setWithEnv;
})(log || (log = {}));
Logger = log;
Event = class {
constructor(category, name2, startTime, endCallback, timer, ctx) {
this.category = category;
this.name = name2;
this.startTime = startTime;
this.endCallback = endCallback;
this.timer = timer;
this.ctx = ctx;
}
async end() {
return this.endCallback(this);
}
async checkTimer() {
if (this.ctx === void 0 || this.timer === void 0) {
throw new Error("No webgl timer found");
} else {
this.ctx.endTimer();
return this.ctx.waitForQueryAndGetTime(this.timer);
}
}
};
EventRecord = class {
constructor(category, name2, startTime, endTime) {
this.category = category;
this.name = name2;
this.startTime = startTime;
this.endTime = endTime;
}
};
Profiler = class {
constructor(maxNumberEvents, flushBatchSize, flushIntervalInMilliseconds) {
this._started = false;
this._flushPointer = 0;
this._started = false;
this._maxNumberEvents = maxNumberEvents === void 0 ? 1e4 : maxNumberEvents;
this._flushBatchSize = flushBatchSize === void 0 ? 10 : flushBatchSize;
this._flushIntervalInMilliseconds = flushIntervalInMilliseconds === void 0 ? 5e3 : flushIntervalInMilliseconds;
}
static create(config) {
if (config === void 0) {
return new this();
}
return new this(config.maxNumberEvents, config.flushBatchSize, config.flushIntervalInMilliseconds);
}
// start profiling
start() {
this._started = true;
this._timingEvents = [];
this._flushTime = now();
this._flushPointer = 0;
}
// stop profiling
stop() {
this._started = false;
for (; this._flushPointer < this._timingEvents.length; this._flushPointer++) {
this.logOneEvent(this._timingEvents[this._flushPointer]);
}
}
event(category, name2, func, ctx) {
const event = this._started ? this.begin(category, name2, ctx) : void 0;
let isPromise = false;
const res = func();
if (res && typeof res.then === "function") {
isPromise = true;
return new Promise((resolve, reject) => {
res.then(
async (value) => {
if (event) {
await event.end();
}
resolve(value);
},
async (reason) => {
if (event) {
await event.end();
}
reject(reason);
}
);
});
}
if (!isPromise && event) {
const eventRes = event.end();
if (eventRes && typeof eventRes.then === "function") {
return new Promise((resolve, reject) => {
eventRes.then(
() => {
resolve(res);
},
(reason) => {
reject(reason);
}
);
});
}
}
return res;
}
// begin an event
begin(category, name2, ctx) {
if (!this._started) {
throw new Error("profiler is not started yet");
}
if (ctx === void 0) {
const startTime = now();
this.flush(startTime);
return new Event(category, name2, startTime, (e) => this.endSync(e));
} else {
const timer = ctx.beginTimer();
return new Event(category, name2, 0, async (e) => this.end(e), timer, ctx);
}
}
// end the specific event
async end(event) {
const endTime = await event.checkTimer();
if (this._timingEvents.length < this._maxNumberEvents) {
this._timingEvents.push(new EventRecord(event.category, event.name, event.startTime, endTime));
this.flush(endTime);
}
}
endSync(event) {
const endTime = now();
if (this._timingEvents.length < this._maxNumberEvents) {
this._timingEvents.push(new EventRecord(event.category, event.name, event.startTime, endTime));
this.flush(endTime);
}
}
logOneEvent(event) {
Logger.verbose(
`Profiler.${event.category}`,
`${(event.endTime - event.startTime).toFixed(2)}ms on event '${event.name}' at ${event.endTime.toFixed(2)}`
);
}
flush(currentTime) {
if (this._timingEvents.length - this._flushPointer >= this._flushBatchSize || currentTime - this._flushTime >= this._flushIntervalInMilliseconds) {
for (const previousPointer = this._flushPointer; this._flushPointer < previousPointer + this._flushBatchSize && this._flushPointer < this._timingEvents.length; this._flushPointer++) {
this.logOneEvent(this._timingEvents[this._flushPointer]);
}
this._flushTime = now();
}
}
get started() {
return this._started;
}
};
now = typeof performance !== "undefined" && performance.now ? () => performance.now() : Date.now;
}
});
// web/lib/onnxjs/opset.ts
function resolveOperator(node, opsets, rules) {
for (const rule of rules) {
const opType = rule[0];
const domain = rule[1];
const versionSelector = rule[2];
const opImpl = rule[3];
const opInit = rule[4];
if (node.opType === opType) {
for (const opset of opsets) {
if (opset.domain === domain || opset.domain === "ai.onnx" && domain === "") {
if (matchSelector(opset.version, versionSelector)) {
return { opImpl, opInit };
}
}
}
}
}
throw new TypeError(
`cannot resolve operator '${node.opType}' with opsets: ${opsets.map((set) => `${set.domain || "ai.onnx"} v${set.version}`).join(", ")}`
);
}
function matchSelector(version3, selector) {
if (selector.endsWith("+")) {
const rangeStart = Number.parseInt(selector.substring(0, selector.length - 1), 10);
return !isNaN(rangeStart) && rangeStart <= version3;
} else if (selector.split("-").length === 2) {
const pair = selector.split("-");
const rangeStart = Number.parseInt(pair[0], 10);
const rangeEnd = Number.parseInt(pair[1], 10);
return !isNaN(rangeStart) && !isNaN(rangeEnd) && rangeStart <= version3 && version3 <= rangeEnd;
} else {
return Number.parseInt(selector, 10) === version3;
}
}
var init_opset = __esm({
"web/lib/onnxjs/opset.ts"() {
"use strict";
}
});
// web/node_modules/guid-typescript/dist/guid.js
var require_guid = __commonJS({
"web/node_modules/guid-typescript/dist/guid.js"(exports2) {
"use strict";
exports2.__esModule = true;
var Guid2 = (
/** @class */
function() {
function Guid3(guid) {
if (!guid) {
throw new TypeError("Invalid argument; `value` has no value.");
}
this.value = Guid3.EMPTY;
if (guid && Guid3.isGuid(guid)) {
this.value = guid;
}
}
Guid3.isGuid = function(guid) {
var value = guid.toString();
return guid && (guid instanceof Guid3 || Guid3.validator.test(value));
};
Guid3.create = function() {
return new Guid3([Guid3.gen(2), Guid3.gen(1), Guid3.gen(1), Guid3.gen(1), Guid3.gen(3)].join("-"));
};
Guid3.createEmpty = function() {
return new Guid3("emptyguid");
};
Guid3.parse = function(guid) {
return new Guid3(guid);
};
Guid3.raw = function() {
return [Guid3.gen(2), Guid3.gen(1), Guid3.gen(1), Guid3.gen(1), Guid3.gen(3)].join("-");
};
Guid3.gen = function(count) {
var out = "";
for (var i = 0; i < count; i++) {
out += ((1 + Math.random()) * 65536 | 0).toString(16).substring(1);
}
return out;
};
Guid3.prototype.equals = function(other) {
return Guid3.isGuid(other) && this.value === other.toString();
};
Guid3.prototype.isEmpty = function() {
return this.value === Guid3.EMPTY;
};
Guid3.prototype.toString = function() {
return this.value;
};
Guid3.prototype.toJSON = function() {
return {
value: this.value
};
};
Guid3.validator = new RegExp("^[a-z0-9]{8}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{12}$", "i");
Guid3.EMPTY = "00000000-0000-0000-0000-000000000000";
return Guid3;
}()
);
exports2.Guid = Guid2;
}
});
// web/node_modules/long/index.js
function Long(low, high, unsigned) {
this.low = low | 0;
this.high = high | 0;
this.unsigned = !!unsigned;
}
function isLong(obj) {
return (obj && obj["__isLong__"]) === true;
}
function ctz32(value) {
var c = Math.clz32(value & -value);
return value ? 31 - c : c;
}
function fromInt(value, unsigned) {
var obj, cachedObj, cache2;
if (unsigned) {
value >>>= 0;
if (cache2 = 0 <= value && value < 256) {
cachedObj = UINT_CACHE[value];
if (cachedObj)
return cachedObj;
}
obj = fromBits(value, 0, true);
if (cache2)
UINT_CACHE[value] = obj;
return obj;
} else {
value |= 0;
if (cache2 = -128 <= value && value < 128) {
cachedObj = INT_CACHE[value];
if (cachedObj)
return cachedObj;
}
obj = fromBits(value, value < 0 ? -1 : 0, false);
if (cache2)
INT_CACHE[value] = obj;
return obj;
}
}
function fromNumber(value, unsigned) {
if (isNaN(value))
return unsigned ? UZERO : ZERO;
if (unsigned) {
if (value < 0)
return UZERO;
if (value >= TWO_PWR_64_DBL)
return MAX_UNSIGNED_VALUE;
} else {
if (value <= -TWO_PWR_63_DBL)
return MIN_VALUE;
if (value + 1 >= TWO_PWR_63_DBL)
return MAX_VALUE;
}
if (value < 0)
return fromNumber(-value, unsigned).neg();
return fromBits(value % TWO_PWR_32_DBL | 0, value / TWO_PWR_32_DBL | 0, unsigned);
}
function fromBits(lowBits, highBits, unsigned) {
return new Long(lowBits, highBits, unsigned);
}
function fromString(str, unsigned, radix) {
if (str.length === 0)
throw Error("empty string");
if (typeof unsigned === "number") {
radix = unsigned;
unsigned = false;
} else {
unsigned = !!unsigned;
}
if (str === "NaN" || str === "Infinity" || str === "+Infinity" || str === "-Infinity")
return unsigned ? UZERO : ZERO;
radix = radix || 10;
if (radix < 2 || 36 < radix)
throw RangeError("radix");
var p;
if ((p = str.indexOf("-")) > 0)
throw Error("interior hyphen");
else if (p === 0) {
return fromString(str.substring(1), unsigned, radix).neg();
}
var radixToPower = fromNumber(pow_dbl(radix, 8));
var result = ZERO;
for (var i = 0; i < str.length; i += 8) {
var size = Math.min(8, str.length - i), value = parseInt(str.substring(i, i + size), radix);
if (size < 8) {
var power = fromNumber(pow_dbl(radix, size));
result = result.mul(power).add(fromNumber(value));
} else {
result = result.mul(radixToPower);
result = result.add(fromNumber(value));
}
}
result.unsigned = unsigned;
return result;
}
function fromValue(val, unsigned) {
if (typeof val === "number")
return fromNumber(val, unsigned);
if (typeof val === "string")
return fromString(val, unsigned);
return fromBits(val.low, val.high, typeof unsigned === "boolean" ? unsigned : val.unsigned);
}
var wasm, INT_CACHE, UINT_CACHE, pow_dbl, TWO_PWR_16_DBL, TWO_PWR_24_DBL, TWO_PWR_32_DBL, TWO_PWR_64_DBL, TWO_PWR_63_DBL, TWO_PWR_24, ZERO, UZERO, ONE, UONE, NEG_ONE, MAX_VALUE, MAX_UNSIGNED_VALUE, MIN_VALUE, LongPrototype, long_default;
var init_long = __esm({
"web/node_modules/long/index.js"() {
wasm = null;
try {
wasm = new WebAssembly.Instance(new WebAssembly.Module(new Uint8Array([
0,
97,
115,
109,
1,
0,
0,
0,
1,
13,
2,
96,
0,
1,
127,
96,
4,
127,
127,
127,
127,
1,
127,
3,
7,
6,
0,
1,
1,
1,
1,
1,
6,
6,
1,
127,
1,
65,
0,
11,
7,
50,
6,
3,
109,
117,
108,
0,
1,
5,
100,
105,
118,
95,
115,
0,
2,
5,
100,
105,
118,
95,
117,
0,
3,
5,
114,
101,
109,
95,
115,
0,
4,
5,
114,
101,
109,
95,
117,
0,
5,
8,
103,
101,
116,
95,
104,
105,
103,
104,
0,
0,
10,
191,
1,
6,
4,
0,
35,
0,
11,
36,
1,
1,
126,
32,
0,
173,
32,
1,
173,
66,
32,
134,
132,
32,
2,
173,
32,
3,
173,
66,
32,
134,
132,
126,
34,
4,
66,
32,
135,
167,
36,
0,
32,
4,
167,
11,
36,
1,
1,
126,
32,
0,
173,
32,
1,
173,
66,
32,
134,
132,
32,
2,
173,
32,
3,
173,
66,
32,
134,
132,
127,
34,
4,
66,
32,
135,
167,
36,
0,
32,
4,
167,
11,
36,
1,
1,
126,
32,
0,
173,
32,
1,
173,
66,
32,
134,
132,
32,
2,
173,
32,
3,
173,
66,
32,
134,
132,
128,
34,
4,
66,
32,
135,
167,
36,
0,
32,
4,
167,
11,
36,
1,
1,
126,
32,
0,
173,
32,
1,
173,
66,
32,
134,
132,
32,
2,
173,
32,
3,
173,
66,
32,
134,
132,
129,
34,
4,
66,
32,
135,
167,
36,
0,
32,
4,
167,
11,
36,
1,
1,
126,
32,
0,
173,
32,
1,
173,
66,
32,
134,
132,
32,
2,
173,
32,
3,
173,
66,
32,
134,
132,
130,
34,
4,
66,
32,
135,
167,
36,
0,
32,
4,
167,
11
])), {}).exports;
} catch (e) {
}
Long.prototype.__isLong__;
Object.defineProperty(Long.prototype, "__isLong__", { value: true });
Long.isLong = isLong;
INT_CACHE = {};
UINT_CACHE = {};
Long.fromInt = fromInt;
Long.fromNumber = fromNumber;
Long.fromBits = fromBits;
pow_dbl = Math.pow;
Long.fromString = fromString;
Long.fromValue = fromValue;
TWO_PWR_16_DBL = 1 << 16;
TWO_PWR_24_DBL = 1 << 24;
TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL;
TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL;
TWO_PWR_63_DBL = TWO_PWR_64_DBL / 2;
TWO_PWR_24 = fromInt(TWO_PWR_24_DBL);
ZERO = fromInt(0);
Long.ZERO = ZERO;
UZERO = fromInt(0, true);
Long.UZERO = UZERO;
ONE = fromInt(1);
Long.ONE = ONE;
UONE = fromInt(1, true);
Long.UONE = UONE;
NEG_ONE = fromInt(-1);
Long.NEG_ONE = NEG_ONE;
MAX_VALUE = fromBits(4294967295 | 0, 2147483647 | 0, false);
Long.MAX_VALUE = MAX_VALUE;
MAX_UNSIGNED_VALUE = fromBits(4294967295 | 0, 4294967295 | 0, true);
Long.MAX_UNSIGNED_VALUE = MAX_UNSIGNED_VALUE;
MIN_VALUE = fromBits(0, 2147483648 | 0, false);
Long.MIN_VALUE = MIN_VALUE;
LongPrototype = Long.prototype;
LongPrototype.toInt = function toInt() {
return this.unsigned ? this.low >>> 0 : this.low;
};
LongPrototype.toNumber = function toNumber() {
if (this.unsigned)
return (this.high >>> 0) * TWO_PWR_32_DBL + (this.low >>> 0);
return this.high * TWO_PWR_32_DBL + (this.low >>> 0);
};
LongPrototype.toString = function toString(radix) {
radix = radix || 10;
if (radix < 2 || 36 < radix)
throw RangeError("radix");
if (this.isZero())
return "0";
if (this.isNegative()) {
if (this.eq(MIN_VALUE)) {
var radixLong = fromNumber(radix), div2 = this.div(radixLong), rem1 = div2.mul(radixLong).sub(this);
return div2.toString(radix) + rem1.toInt().toString(radix);
} else
return "-" + this.neg().toString(radix);
}
var radixToPower = fromNumber(pow_dbl(radix, 6), this.unsigned), rem = this;
var result = "";
while (true) {
var remDiv = rem.div(radixToPower), intval = rem.sub(remDiv.mul(radixToPower)).toInt() >>> 0, digits = intval.toString(radix);
rem = remDiv;
if (rem.isZero())
return digits + result;
else {
while (digits.length < 6)
digits = "0" + digits;
result = "" + digits + result;
}
}
};
LongPrototype.getHighBits = function getHighBits() {
return this.high;
};
LongPrototype.getHighBitsUnsigned = function getHighBitsUnsigned() {
return this.high >>> 0;
};
LongPrototype.getLowBits = function getLowBits() {
return this.low;
};
LongPrototype.getLowBitsUnsigned = function getLowBitsUnsigned() {
return this.low >>> 0;
};
LongPrototype.getNumBitsAbs = function getNumBitsAbs() {
if (this.isNegative())
return this.eq(MIN_VALUE) ? 64 : this.neg().getNumBitsAbs();
var val = this.high != 0 ? this.high : this.low;
for (var bit = 31; bit > 0; bit--)
if ((val & 1 << bit) != 0)
break;
return this.high != 0 ? bit + 33 : bit + 1;
};
LongPrototype.isZero = function isZero() {
return this.high === 0 && this.low === 0;
};
LongPrototype.eqz = LongPrototype.isZero;
LongPrototype.isNegative = function isNegative() {
return !this.unsigned && this.high < 0;
};
LongPrototype.isPositive = function isPositive() {
return this.unsigned || this.high >= 0;
};
LongPrototype.isOdd = function isOdd() {
return (this.low & 1) === 1;
};
LongPrototype.isEven = function isEven() {
return (this.low & 1) === 0;
};
LongPrototype.equals = function equals(other) {
if (!isLong(other))
other = fromValue(other);
if (this.unsigned !== other.unsigned && this.high >>> 31 === 1 && other.high >>> 31 === 1)
return false;
return this.high === other.high && this.low === other.low;
};
LongPrototype.eq = LongPrototype.equals;
LongPrototype.notEquals = function notEquals(other) {
return !this.eq(
/* validates */
other
);
};
LongPrototype.neq = LongPrototype.notEquals;
LongPrototype.ne = LongPrototype.notEquals;
LongPrototype.lessThan = function lessThan(other) {
return this.comp(
/* validates */
other
) < 0;
};
LongPrototype.lt = LongPrototype.lessThan;
LongPrototype.lessThanOrEqual = function lessThanOrEqual(other) {
return this.comp(
/* validates */
other
) <= 0;
};
LongPrototype.lte = LongPrototype.lessThanOrEqual;
LongPrototype.le = LongPrototype.lessThanOrEqual;
LongPrototype.greaterThan = function greaterThan(other) {
return this.comp(
/* validates */
other
) > 0;
};
LongPrototype.gt = LongPrototype.greaterThan;
LongPrototype.greaterThanOrEqual = function greaterThanOrEqual(other) {
return this.comp(
/* validates */
other
) >= 0;
};
LongPrototype.gte = LongPrototype.greaterThanOrEqual;
LongPrototype.ge = LongPrototype.greaterThanOrEqual;
LongPrototype.compare = function compare(other) {
if (!isLong(other))
other = fromValue(other);
if (this.eq(other))
return 0;
var thisNeg = this.isNegative(), otherNeg = other.isNegative();
if (thisNeg && !otherNeg)
return -1;
if (!thisNeg && otherNeg)
return 1;
if (!this.unsigned)
return this.sub(other).isNegative() ? -1 : 1;
return other.high >>> 0 > this.high >>> 0 || other.high === this.high && other.low >>> 0 > this.low >>> 0 ? -1 : 1;
};
LongPrototype.comp = LongPrototype.compare;
LongPrototype.negate = function negate() {
if (!this.unsigned && this.eq(MIN_VALUE))
return MIN_VALUE;
return this.not().add(ONE);
};
LongPrototype.neg = LongPrototype.negate;
LongPrototype.add = function add(addend) {
if (!isLong(addend))
addend = fromValue(addend);
var a48 = this.high >>> 16;
var a32 = this.high & 65535;
var a16 = this.low >>> 16;
var a00 = this.low & 65535;
var b48 = addend.high >>> 16;
var b32 = addend.high & 65535;
var b16 = addend.low >>> 16;
var b00 = addend.low & 65535;
var c48 = 0, c32 = 0, c16 = 0, c00 = 0;
c00 += a00 + b00;
c16 += c00 >>> 16;
c00 &= 65535;
c16 += a16 + b16;
c32 += c16 >>> 16;
c16 &= 65535;
c32 += a32 + b32;
c48 += c32 >>> 16;
c32 &= 65535;
c48 += a48 + b48;
c48 &= 65535;
return fromBits(c16 << 16 | c00, c48 << 16 | c32, this.unsigned);
};
LongPrototype.subtract = function subtract(subtrahend) {
if (!isLong(subtrahend))
subtrahend = fromValue(subtrahend);
return this.add(subtrahend.neg());
};
LongPrototype.sub = LongPrototype.subtract;
LongPrototype.multiply = function multiply(multiplier) {
if (this.isZero())
return this;
if (!isLong(multiplier))
multiplier = fromValue(multiplier);
if (wasm) {
var low = wasm["mul"](
this.low,
this.high,
multiplier.low,
multiplier.high
);
return fromBits(low, wasm["get_high"](), this.unsigned);
}
if (multiplier.isZero())
return this.unsigned ? UZERO : ZERO;
if (this.eq(MIN_VALUE))
return multiplier.isOdd() ? MIN_VALUE : ZERO;
if (multiplier.eq(MIN_VALUE))
return this.isOdd() ? MIN_VALUE : ZERO;
if (this.isNegative()) {
if (multiplier.isNegative())
return this.neg().mul(multiplier.neg());
else
return this.neg().mul(multiplier).neg();
} else if (multiplier.isNegative())
return this.mul(multiplier.neg()).neg();
if (this.lt(TWO_PWR_24) && multiplier.lt(TWO_PWR_24))
return fromNumber(this.toNumber() * multiplier.toNumber(), this.unsigned);
var a48 = this.high >>> 16;
var a32 = this.high & 65535;
var a16 = this.low >>> 16;
var a00 = this.low & 65535;
var b48 = multiplier.high >>> 16;
var b32 = multiplier.high & 65535;
var b16 = multiplier.low >>> 16;
var b00 = multiplier.low & 65535;
var c48 = 0, c32 = 0, c16 = 0, c00 = 0;
c00 += a00 * b00;
c16 += c00 >>> 16;
c00 &= 65535;
c16 += a16 * b00;
c32 += c16 >>> 16;
c16 &= 65535;
c16 += a00 * b16;
c32 += c16 >>> 16;
c16 &= 65535;
c32 += a32 * b00;
c48 += c32 >>> 16;
c32 &= 65535;
c32 += a16 * b16;
c48 += c32 >>> 16;
c32 &= 65535;
c32 += a00 * b32;
c48 += c32 >>> 16;
c32 &= 65535;
c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48;
c48 &= 65535;
return fromBits(c16 << 16 | c00, c48 << 16 | c32, this.unsigned);
};
LongPrototype.mul = LongPrototype.multiply;
LongPrototype.divide = function divide(divisor) {
if (!isLong(divisor))
divisor = fromValue(divisor);
if (divisor.isZero())
throw Error("division by zero");
if (wasm) {
if (!this.unsigned && this.high === -2147483648 && divisor.low === -1 && divisor.high === -1) {
return this;
}
var low = (this.unsigned ? wasm["div_u"] : wasm["div_s"])(
this.low,
this.high,
divisor.low,
divisor.high
);
return fromBits(low, wasm["get_high"](), this.unsigned);
}
if (this.isZero())
return this.unsigned ? UZERO : ZERO;
var approx, rem, res;
if (!this.unsigned) {
if (this.eq(MIN_VALUE)) {
if (divisor.eq(ONE) || divisor.eq(NEG_ONE))
return MIN_VALUE;
else if (divisor.eq(MIN_VALUE))
return ONE;
else {
var halfThis = this.shr(1);
approx = halfThis.div(divisor).shl(1);
if (approx.eq(ZERO)) {
return divisor.isNegative() ? ONE : NEG_ONE;
} else {
rem = this.sub(divisor.mul(approx));
res = approx.add(rem.div(divisor));
return res;
}
}
} else if (divisor.eq(MIN_VALUE))
return this.unsigned ? UZERO : ZERO;
if (this.isNegative()) {
if (divisor.isNegative())
return this.neg().div(divisor.neg());
return this.neg().div(divisor).neg();
} else if (divisor.isNegative())
return this.div(divisor.neg()).neg();
res = ZERO;
} else {
if (!divisor.unsigned)
divisor = divisor.toUnsigned();
if (divisor.gt(this))
return UZERO;
if (divisor.gt(this.shru(1)))
return UONE;
res = UZERO;
}
rem = this;
while (rem.gte(divisor)) {
approx = Math.max(1, Math.floor(rem.toNumber() / divisor.toNumber()));
var log22 = Math.ceil(Math.log(approx) / Math.LN2), delta = log22 <= 48 ? 1 : pow_dbl(2, log22 - 48), approxRes = fromNumber(approx), approxRem = approxRes.mul(divisor);
while (approxRem.isNegative() || approxRem.gt(rem)) {
approx -= delta;
approxRes = fromNumber(approx, this.unsigned);
approxRem = approxRes.mul(divisor);
}
if (approxRes.isZero())
approxRes = ONE;
res = res.add(approxRes);
rem = rem.sub(approxRem);
}
return res;
};
LongPrototype.div = LongPrototype.divide;
LongPrototype.modulo = function modulo(divisor) {
if (!isLong(divisor))
divisor = fromValue(divisor);
if (wasm) {
var low = (this.unsigned ? wasm["rem_u"] : wasm["rem_s"])(
this.low,
this.high,
divisor.low,
divisor.high
);
return fromBits(low, wasm["get_high"](), this.unsigned);
}
return this.sub(this.div(divisor).mul(divisor));
};
LongPrototype.mod = LongPrototype.modulo;
LongPrototype.rem = LongPrototype.modulo;
LongPrototype.not = function not() {
return fromBits(~this.low, ~this.high, this.unsigned);
};
LongPrototype.countLeadingZeros = function countLeadingZeros() {
return this.high ? Math.clz32(this.high) : Math.clz32(this.low) + 32;
};
LongPrototype.clz = LongPrototype.countLeadingZeros;
LongPrototype.countTrailingZeros = function countTrailingZeros() {
return this.low ? ctz32(this.low) : ctz32(this.high) + 32;
};
LongPrototype.ctz = LongPrototype.countTrailingZeros;
LongPrototype.and = function and(other) {
if (!isLong(other))
other = fromValue(other);
return fromBits(this.low & other.low, this.high & other.high, this.unsigned);
};
LongPrototype.or = function or(other) {
if (!isLong(other))
other = fromValue(other);
return fromBits(this.low | other.low, this.high | other.high, this.unsigned);
};
LongPrototype.xor = function xor(other) {
if (!isLong(other))
other = fromValue(other);
return fromBits(this.low ^ other.low, this.high ^ other.high, this.unsigned);
};
LongPrototype.shiftLeft = function shiftLeft(numBits) {
if (isLong(numBits))
numBits = numBits.toInt();
if ((numBits &= 63) === 0)
return this;
else if (numBits < 32)
return fromBits(this.low << numBits, this.high << numBits | this.low >>> 32 - numBits, this.unsigned);
else
return fromBits(0, this.low << numBits - 32, this.unsigned);
};
LongPrototype.shl = LongPrototype.shiftLeft;
LongPrototype.shiftRight = function shiftRight(numBits) {
if (isLong(numBits))
numBits = numBits.toInt();
if ((numBits &= 63) === 0)
return this;
else if (numBits < 32)
return fromBits(this.low >>> numBits | this.high << 32 - numBits, this.high >> numBits, this.unsigned);
else
return fromBits(this.high >> numBits - 32, this.high >= 0 ? 0 : -1, this.unsigned);
};
LongPrototype.shr = LongPrototype.shiftRight;
LongPrototype.shiftRightUnsigned = function shiftRightUnsigned(numBits) {
if (isLong(numBits))
numBits = numBits.toInt();
if ((numBits &= 63) === 0)
return this;
if (numBits < 32)
return fromBits(this.low >>> numBits | this.high << 32 - numBits, this.high >>> numBits, this.unsigned);
if (numBits === 32)
return fromBits(this.high, 0, this.unsigned);
return fromBits(this.high >>> numBits - 32, 0, this.unsigned);
};
LongPrototype.shru = LongPrototype.shiftRightUnsigned;
LongPrototype.shr_u = LongPrototype.shiftRightUnsigned;
LongPrototype.rotateLeft = function rotateLeft(numBits) {
var b;
if (isLong(numBits))
numBits = numBits.toInt();
if ((numBits &= 63) === 0)
return this;
if (numBits === 32)
return fromBits(this.high, this.low, this.unsigned);
if (numBits < 32) {
b = 32 - numBits;
return fromBits(this.low << numBits | this.high >>> b, this.high << numBits | this.low >>> b, this.unsigned);
}
numBits -= 32;
b = 32 - numBits;
return fromBits(this.high << numBits | this.low >>> b, this.low << numBits | this.high >>> b, this.unsigned);
};
LongPrototype.rotl = LongPrototype.rotateLeft;
LongPrototype.rotateRight = function rotateRight(numBits) {
var b;
if (isLong(numBits))
numBits = numBits.toInt();
if ((numBits &= 63) === 0)
return this;
if (numBits === 32)
return fromBits(this.high, this.low, this.unsigned);
if (numBits < 32) {
b = 32 - numBits;
return fromBits(this.high << b | this.low >>> numBits, this.low << b | this.high >>> numBits, this.unsigned);
}
numBits -= 32;
b = 32 - numBits;
return fromBits(this.low << b | this.high >>> numBits, this.high << b | this.low >>> numBits, this.unsigned);
};
LongPrototype.rotr = LongPrototype.rotateRight;
LongPrototype.toSigned = function toSigned() {
if (!this.unsigned)
return this;
return fromBits(this.low, this.high, false);
};
LongPrototype.toUnsigned = function toUnsigned() {
if (this.unsigned)
return this;
return fromBits(this.low, this.high, true);
};
LongPrototype.toBytes = function toBytes(le) {
return le ? this.toBytesLE() : this.toBytesBE();
};
LongPrototype.toBytesLE = function toBytesLE() {
var hi = this.high, lo = this.low;
return [
lo & 255,
lo >>> 8 & 255,
lo >>> 16 & 255,
lo >>> 24,
hi & 255,
hi >>> 8 & 255,
hi >>> 16 & 255,
hi >>> 24
];
};
LongPrototype.toBytesBE = function toBytesBE() {
var hi = this.high, lo = this.low;
return [
hi >>> 24,
hi >>> 16 & 255,
hi >>> 8 & 255,
hi & 255,
lo >>> 24,
lo >>> 16 & 255,
lo >>> 8 & 255,
lo & 255
];
};
Long.fromBytes = function fromBytes(bytes, unsigned, le) {
return le ? Long.fromBytesLE(bytes, unsigned) : Long.fromBytesBE(bytes, unsigned);
};
Long.fromBytesLE = function fromBytesLE(bytes, unsigned) {
return new Long(
bytes[0] | bytes[1] << 8 | bytes[2] << 16 | bytes[3] << 24,
bytes[4] | bytes[5] << 8 | bytes[6] << 16 | bytes[7] << 24,
unsigned
);
};
Long.fromBytesBE = function fromBytesBE(bytes, unsigned) {
return new Long(
bytes[4] << 24 | bytes[5] << 16 | bytes[6] << 8 | bytes[7],
bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3],
unsigned
);
};
long_default = Long;
}
});
// web/node_modules/flatbuffers/js/flatbuffers.mjs
var flatbuffers;
var init_flatbuffers = __esm({
"web/node_modules/flatbuffers/js/flatbuffers.mjs"() {
flatbuffers = {};
flatbuffers.Offset;
flatbuffers.Table;
flatbuffers.SIZEOF_SHORT = 2;
flatbuffers.SIZEOF_INT = 4;
flatbuffers.FILE_IDENTIFIER_LENGTH = 4;
flatbuffers.SIZE_PREFIX_LENGTH = 4;
flatbuffers.Encoding = {
UTF8_BYTES: 1,
UTF16_STRING: 2
};
flatbuffers.int32 = new Int32Array(2);
flatbuffers.float32 = new Float32Array(flatbuffers.int32.buffer);
flatbuffers.float64 = new Float64Array(flatbuffers.int32.buffer);
flatbuffers.isLittleEndian = new Uint16Array(new Uint8Array([1, 0]).buffer)[0] === 1;
flatbuffers.Long = function(low, high) {
this.low = low | 0;
this.high = high | 0;
};
flatbuffers.Long.create = function(low, high) {
return low == 0 && high == 0 ? flatbuffers.Long.ZERO : new flatbuffers.Long(low, high);
};
flatbuffers.Long.prototype.toFloat64 = function() {
return (this.low >>> 0) + this.high * 4294967296;
};
flatbuffers.Long.prototype.equals = function(other) {
return this.low == other.low && this.high == other.high;
};
flatbuffers.Long.ZERO = new flatbuffers.Long(0, 0);
flatbuffers.Builder = function(opt_initial_size) {
if (!opt_initial_size) {
var initial_size = 1024;
} else {
var initial_size = opt_initial_size;
}
this.bb = flatbuffers.ByteBuffer.allocate(initial_size);
this.space = initial_size;
this.minalign = 1;
this.vtable = null;
this.vtable_in_use = 0;
this.isNested = false;
this.object_start = 0;
this.vtables = [];
this.vector_num_elems = 0;
this.force_defaults = false;
};
flatbuffers.Builder.prototype.clear = function() {
this.bb.clear();
this.space = this.bb.capacity();
this.minalign = 1;
this.vtable = null;
this.vtable_in_use = 0;
this.isNested = false;
this.object_start = 0;
this.vtables = [];
this.vector_num_elems = 0;
this.force_defaults = false;
};
flatbuffers.Builder.prototype.forceDefaults = function(forceDefaults) {
this.force_defaults = forceDefaults;
};
flatbuffers.Builder.prototype.dataBuffer = function() {
return this.bb;
};
flatbuffers.Builder.prototype.asUint8Array = function() {
return this.bb.bytes().subarray(this.bb.position(), this.bb.position() + this.offset());
};
flatbuffers.Builder.prototype.prep = function(size, additional_bytes) {
if (size > this.minalign) {
this.minalign = size;
}
var align_size = ~(this.bb.capacity() - this.space + additional_bytes) + 1 & size - 1;
while (this.space < align_size + size + additional_bytes) {
var old_buf_size = this.bb.capacity();
this.bb = flatbuffers.Builder.growByteBuffer(this.bb);
this.space += this.bb.capacity() - old_buf_size;
}
this.pad(align_size);
};
flatbuffers.Builder.prototype.pad = function(byte_size) {
for (var i = 0; i < byte_size; i++) {
this.bb.writeInt8(--this.space, 0);
}
};
flatbuffers.Builder.prototype.writeInt8 = function(value) {
this.bb.writeInt8(this.space -= 1, value);
};
flatbuffers.Builder.prototype.writeInt16 = function(value) {
this.bb.writeInt16(this.space -= 2, value);
};
flatbuffers.Builder.prototype.writeInt32 = function(value) {
this.bb.writeInt32(this.space -= 4, value);
};
flatbuffers.Builder.prototype.writeInt64 = function(value) {
this.bb.writeInt64(this.space -= 8, value);
};
flatbuffers.Builder.prototype.writeFloat32 = function(value) {
this.bb.writeFloat32(this.space -= 4, value);
};
flatbuffers.Builder.prototype.writeFloat64 = function(value) {
this.bb.writeFloat64(this.space -= 8, value);
};
flatbuffers.Builder.prototype.addInt8 = function(value) {
this.prep(1, 0);
this.writeInt8(value);
};
flatbuffers.Builder.prototype.addInt16 = function(value) {
this.prep(2, 0);
this.writeInt16(value);
};
flatbuffers.Builder.prototype.addInt32 = function(value) {
this.prep(4, 0);
this.writeInt32(value);
};
flatbuffers.Builder.prototype.addInt64 = function(value) {
this.prep(8, 0);
this.writeInt64(value);
};
flatbuffers.Builder.prototype.addFloat32 = function(value) {
this.prep(4, 0);
this.writeFloat32(value);
};
flatbuffers.Builder.prototype.addFloat64 = function(value) {
this.prep(8, 0);
this.writeFloat64(value);
};
flatbuffers.Builder.prototype.addFieldInt8 = function(voffset, value, defaultValue) {
if (this.force_defaults || value != defaultValue) {
this.addInt8(value);
this.slot(voffset);
}
};
flatbuffers.Builder.prototype.addFieldInt16 = function(voffset, value, defaultValue) {
if (this.force_defaults || value != defaultValue) {
this.addInt16(value);
this.slot(voffset);
}
};
flatbuffers.Builder.prototype.addFieldInt32 = function(voffset, value, defaultValue) {
if (this.force_defaults || value != defaultValue) {
this.addInt32(value);
this.slot(voffset);
}
};
flatbuffers.Builder.prototype.addFieldInt64 = function(voffset, value, defaultValue) {
if (this.force_defaults || !value.equals(defaultValue)) {
this.addInt64(value);
this.slot(voffset);
}
};
flatbuffers.Builder.prototype.addFieldFloat32 = function(voffset, value, defaultValue) {
if (this.force_defaults || value != defaultValue) {
this.addFloat32(value);
this.slot(voffset);
}
};
flatbuffers.Builder.prototype.addFieldFloat64 = function(voffset, value, defaultValue) {
if (this.force_defaults || value != defaultValue) {
this.addFloat64(value);
this.slot(voffset);
}
};
flatbuffers.Builder.prototype.addFieldOffset = function(voffset, value, defaultValue) {
if (this.force_defaults || value != defaultValue) {
this.addOffset(value);
this.slot(voffset);
}
};
flatbuffers.Builder.prototype.addFieldStruct = function(voffset, value, defaultValue) {
if (value != defaultValue) {
this.nested(value);
this.slot(voffset);
}
};
flatbuffers.Builder.prototype.nested = function(obj) {
if (obj != this.offset()) {
throw new Error("FlatBuffers: struct must be serialized inline.");
}
};
flatbuffers.Builder.prototype.notNested = function() {
if (this.isNested) {
throw new Error("FlatBuffers: object serialization must not be nested.");
}
};
flatbuffers.Builder.prototype.slot = function(voffset) {
this.vtable[voffset] = this.offset();
};
flatbuffers.Builder.prototype.offset = function() {
return this.bb.capacity() - this.space;
};
flatbuffers.Builder.growByteBuffer = function(bb) {
var old_buf_size = bb.capacity();
if (old_buf_size & 3221225472) {
throw new Error("FlatBuffers: cannot grow buffer beyond 2 gigabytes.");
}
var new_buf_size = old_buf_size << 1;
var nbb = flatbuffers.ByteBuffer.allocate(new_buf_size);
nbb.setPosition(new_buf_size - old_buf_size);
nbb.bytes().set(bb.bytes(), new_buf_size - old_buf_size);
return nbb;
};
flatbuffers.Builder.prototype.addOffset = function(offset) {
this.prep(flatbuffers.SIZEOF_INT, 0);
this.writeInt32(this.offset() - offset + flatbuffers.SIZEOF_INT);
};
flatbuffers.Builder.prototype.startObject = function(numfields) {
this.notNested();
if (this.vtable == null) {
this.vtable = [];
}
this.vtable_in_use = numfields;
for (var i = 0; i < numfields; i++) {
this.vtable[i] = 0;
}
this.isNested = true;
this.object_start = this.offset();
};
flatbuffers.Builder.prototype.endObject = function() {
if (this.vtable == null || !this.isNested) {
throw new Error("FlatBuffers: endObject called without startObject");
}
this.addInt32(0);
var vtableloc = this.offset();
var i = this.vtable_in_use - 1;
for (; i >= 0 && this.vtable[i] == 0; i--) {
}
var trimmed_size = i + 1;
for (; i >= 0; i--) {
this.addInt16(this.vtable[i] != 0 ? vtableloc - this.vtable[i] : 0);
}
var standard_fields = 2;
this.addInt16(vtableloc - this.object_start);
var len = (trimmed_size + standard_fields) * flatbuffers.SIZEOF_SHORT;
this.addInt16(len);
var existing_vtable = 0;
var vt1 = this.space;
outer_loop:
for (i = 0; i < this.vtables.length; i++) {
var vt2 = this.bb.capacity() - this.vtables[i];
if (len == this.bb.readInt16(vt2)) {
for (var j = flatbuffers.SIZEOF_SHORT; j < len; j += flatbuffers.SIZEOF_SHORT) {
if (this.bb.readInt16(vt1 + j) != this.bb.readInt16(vt2 + j)) {
continue outer_loop;
}
}
existing_vtable = this.vtables[i];
break;
}
}
if (existing_vtable) {
this.space = this.bb.capacity() - vtableloc;
this.bb.writeInt32(this.space, existing_vtable - vtableloc);
} else {
this.vtables.push(this.offset());
this.bb.writeInt32(this.bb.capacity() - vtableloc, this.offset() - vtableloc);
}
this.isNested = false;
return vtableloc;
};
flatbuffers.Builder.prototype.finish = function(root_table, opt_file_identifier, opt_size_prefix) {
var size_prefix = opt_size_prefix ? flatbuffers.SIZE_PREFIX_LENGTH : 0;
if (opt_file_identifier) {
var file_identifier = opt_file_identifier;
this.prep(this.minalign, flatbuffers.SIZEOF_INT + flatbuffers.FILE_IDENTIFIER_LENGTH + size_prefix);
if (file_identifier.length != flatbuffers.FILE_IDENTIFIER_LENGTH) {
throw new Error("FlatBuffers: file identifier must be length " + flatbuffers.FILE_IDENTIFIER_LENGTH);
}
for (var i = flatbuffers.FILE_IDENTIFIER_LENGTH - 1; i >= 0; i--) {
this.writeInt8(file_identifier.charCodeAt(i));
}
}
this.prep(this.minalign, flatbuffers.SIZEOF_INT + size_prefix);
this.addOffset(root_table);
if (size_prefix) {
this.addInt32(this.bb.capacity() - this.space);
}
this.bb.setPosition(this.space);
};
flatbuffers.Builder.prototype.finishSizePrefixed = function(root_table, opt_file_identifier) {
this.finish(root_table, opt_file_identifier, true);
};
flatbuffers.Builder.prototype.requiredField = function(table, field) {
var table_start = this.bb.capacity() - table;
var vtable_start = table_start - this.bb.readInt32(table_start);
var ok = this.bb.readInt16(vtable_start + field) != 0;
if (!ok) {
throw new Error("FlatBuffers: field " + field + " must be set");
}
};
flatbuffers.Builder.prototype.startVector = function(elem_size, num_elems, alignment) {
this.notNested();
this.vector_num_elems = num_elems;
this.prep(flatbuffers.SIZEOF_INT, elem_size * num_elems);
this.prep(alignment, elem_size * num_elems);
};
flatbuffers.Builder.prototype.endVector = function() {
this.writeInt32(this.vector_num_elems);
return this.offset();
};
flatbuffers.Builder.prototype.createString = function(s) {
if (s instanceof Uint8Array) {
var utf8 = s;
} else {
var utf8 = [];
var i = 0;
while (i < s.length) {
var codePoint;
var a = s.charCodeAt(i++);
if (a < 55296 || a >= 56320) {
codePoint = a;
} else {
var b = s.charCodeAt(i++);
codePoint = (a << 10) + b + (65536 - (55296 << 10) - 56320);
}
if (codePoint < 128) {
utf8.push(codePoint);
} else {
if (codePoint < 2048) {
utf8.push(codePoint >> 6 & 31 | 192);
} else {
if (codePoint < 65536) {
utf8.push(codePoint >> 12 & 15 | 224);
} else {
utf8.push(
codePoint >> 18 & 7 | 240,
codePoint >> 12 & 63 | 128
);
}
utf8.push(codePoint >> 6 & 63 | 128);
}
utf8.push(codePoint & 63 | 128);
}
}
}
this.addInt8(0);
this.startVector(1, utf8.length, 1);
this.bb.setPosition(this.space -= utf8.length);
for (var i = 0, offset = this.space, bytes = this.bb.bytes(); i < utf8.length; i++) {
bytes[offset++] = utf8[i];
}
return this.endVector();
};
flatbuffers.Builder.prototype.createLong = function(low, high) {
return flatbuffers.Long.create(low, high);
};
flatbuffers.ByteBuffer = function(bytes) {
this.bytes_ = bytes;
this.position_ = 0;
};
flatbuffers.ByteBuffer.allocate = function(byte_size) {
return new flatbuffers.ByteBuffer(new Uint8Array(byte_size));
};
flatbuffers.ByteBuffer.prototype.clear = function() {
this.position_ = 0;
};
flatbuffers.ByteBuffer.prototype.bytes = function() {
return this.bytes_;
};
flatbuffers.ByteBuffer.prototype.position = function() {
return this.position_;
};
flatbuffers.ByteBuffer.prototype.setPosition = function(position) {
this.position_ = position;
};
flatbuffers.ByteBuffer.prototype.capacity = function() {
return this.bytes_.length;
};
flatbuffers.ByteBuffer.prototype.readInt8 = function(offset) {
return this.readUint8(offset) << 24 >> 24;
};
flatbuffers.ByteBuffer.prototype.readUint8 = function(offset) {
return this.bytes_[offset];
};
flatbuffers.ByteBuffer.prototype.readInt16 = function(offset) {
return this.readUint16(offset) << 16 >> 16;
};
flatbuffers.ByteBuffer.prototype.readUint16 = function(offset) {
return this.bytes_[offset] | this.bytes_[offset + 1] << 8;
};
flatbuffers.ByteBuffer.prototype.readInt32 = function(offset) {
return this.bytes_[offset] | this.bytes_[offset + 1] << 8 | this.bytes_[offset + 2] << 16 | this.bytes_[offset + 3] << 24;
};
flatbuffers.ByteBuffer.prototype.readUint32 = function(offset) {
return this.readInt32(offset) >>> 0;
};
flatbuffers.ByteBuffer.prototype.readInt64 = function(offset) {
return new flatbuffers.Long(this.readInt32(offset), this.readInt32(offset + 4));
};
flatbuffers.ByteBuffer.prototype.readUint64 = function(offset) {
return new flatbuffers.Long(this.readUint32(offset), this.readUint32(offset + 4));
};
flatbuffers.ByteBuffer.prototype.readFloat32 = function(offset) {
flatbuffers.int32[0] = this.readInt32(offset);
return flatbuffers.float32[0];
};
flatbuffers.ByteBuffer.prototype.readFloat64 = function(offset) {
flatbuffers.int32[flatbuffers.isLittleEndian ? 0 : 1] = this.readInt32(offset);
flatbuffers.int32[flatbuffers.isLittleEndian ? 1 : 0] = this.readInt32(offset + 4);
return flatbuffers.float64[0];
};
flatbuffers.ByteBuffer.prototype.writeInt8 = function(offset, value) {
this.bytes_[offset] = /** @type {number} */
value;
};
flatbuffers.ByteBuffer.prototype.writeUint8 = function(offset, value) {
this.bytes_[offset] = value;
};
flatbuffers.ByteBuffer.prototype.writeInt16 = function(offset, value) {
this.bytes_[offset] = value;
this.bytes_[offset + 1] = value >> 8;
};
flatbuffers.ByteBuffer.prototype.writeUint16 = function(offset, value) {
this.bytes_[offset] = value;
this.bytes_[offset + 1] = value >> 8;
};
flatbuffers.ByteBuffer.prototype.writeInt32 = function(offset, value) {
this.bytes_[offset] = value;
this.bytes_[offset + 1] = value >> 8;
this.bytes_[offset + 2] = value >> 16;
this.bytes_[offset + 3] = value >> 24;
};
flatbuffers.ByteBuffer.prototype.writeUint32 = function(offset, value) {
this.bytes_[offset] = value;
this.bytes_[offset + 1] = value >> 8;
this.bytes_[offset + 2] = value >> 16;
this.bytes_[offset + 3] = value >> 24;
};
flatbuffers.ByteBuffer.prototype.writeInt64 = function(offset, value) {
this.writeInt32(offset, value.low);
this.writeInt32(offset + 4, value.high);
};
flatbuffers.ByteBuffer.prototype.writeUint64 = function(offset, value) {
this.writeUint32(offset, value.low);
this.writeUint32(offset + 4, value.high);
};
flatbuffers.ByteBuffer.prototype.writeFloat32 = function(offset, value) {
flatbuffers.float32[0] = value;
this.writeInt32(offset, flatbuffers.int32[0]);
};
flatbuffers.ByteBuffer.prototype.writeFloat64 = function(offset, value) {
flatbuffers.float64[0] = value;
this.writeInt32(offset, flatbuffers.int32[flatbuffers.isLittleEndian ? 0 : 1]);
this.writeInt32(offset + 4, flatbuffers.int32[flatbuffers.isLittleEndian ? 1 : 0]);
};
flatbuffers.ByteBuffer.prototype.getBufferIdentifier = function() {
if (this.bytes_.length < this.position_ + flatbuffers.SIZEOF_INT + flatbuffers.FILE_IDENTIFIER_LENGTH) {
throw new Error(
"FlatBuffers: ByteBuffer is too short to contain an identifier."
);
}
var result = "";
for (var i = 0; i < flatbuffers.FILE_IDENTIFIER_LENGTH; i++) {
result += String.fromCharCode(
this.readInt8(this.position_ + flatbuffers.SIZEOF_INT + i)
);
}
return result;
};
flatbuffers.ByteBuffer.prototype.__offset = function(bb_pos, vtable_offset) {
var vtable = bb_pos - this.readInt32(bb_pos);
return vtable_offset < this.readInt16(vtable) ? this.readInt16(vtable + vtable_offset) : 0;
};
flatbuffers.ByteBuffer.prototype.__union = function(t, offset) {
t.bb_pos = offset + this.readInt32(offset);
t.bb = this;
return t;
};
flatbuffers.ByteBuffer.prototype.__string = function(offset, opt_encoding) {
offset += this.readInt32(offset);
var length = this.readInt32(offset);
var result = "";
var i = 0;
offset += flatbuffers.SIZEOF_INT;
if (opt_encoding === flatbuffers.Encoding.UTF8_BYTES) {
return this.bytes_.subarray(offset, offset + length);
}
while (i < length) {
var codePoint;
var a = this.readUint8(offset + i++);
if (a < 192) {
codePoint = a;
} else {
var b = this.readUint8(offset + i++);
if (a < 224) {
codePoint = (a & 31) << 6 | b & 63;
} else {
var c = this.readUint8(offset + i++);
if (a < 240) {
codePoint = (a & 15) << 12 | (b & 63) << 6 | c & 63;
} else {
var d = this.readUint8(offset + i++);
codePoint = (a & 7) << 18 | (b & 63) << 12 | (c & 63) << 6 | d & 63;
}
}
}
if (codePoint < 65536) {
result += String.fromCharCode(codePoint);
} else {
codePoint -= 65536;
result += String.fromCharCode(
(codePoint >> 10) + 55296,
(codePoint & (1 << 10) - 1) + 56320
);
}
}
return result;
};
flatbuffers.ByteBuffer.prototype.__indirect = function(offset) {
return offset + this.readInt32(offset);
};
flatbuffers.ByteBuffer.prototype.__vector = function(offset) {
return offset + this.readInt32(offset) + flatbuffers.SIZEOF_INT;
};
flatbuffers.ByteBuffer.prototype.__vector_len = function(offset) {
return this.readInt32(offset + this.readInt32(offset));
};
flatbuffers.ByteBuffer.prototype.__has_identifier = function(ident) {
if (ident.length != flatbuffers.FILE_IDENTIFIER_LENGTH) {
throw new Error("FlatBuffers: file identifier must be length " + flatbuffers.FILE_IDENTIFIER_LENGTH);
}
for (var i = 0; i < flatbuffers.FILE_IDENTIFIER_LENGTH; i++) {
if (ident.charCodeAt(i) != this.readInt8(this.position_ + flatbuffers.SIZEOF_INT + i)) {
return false;
}
}
return true;
};
flatbuffers.ByteBuffer.prototype.createLong = function(low, high) {
return flatbuffers.Long.create(low, high);
};
}
});
// web/lib/onnxjs/ort-schema/flatbuffers/ort-generated.ts
var onnxruntime;
var init_ort_generated = __esm({
"web/lib/onnxjs/ort-schema/flatbuffers/ort-generated.ts"() {
"use strict";
init_flatbuffers();
((onnxruntime2) => {
let experimental;
((experimental2) => {
let fbs;
((fbs2) => {
let AttributeType;
((AttributeType2) => {
AttributeType2[AttributeType2["UNDEFINED"] = 0] = "UNDEFINED";
AttributeType2[AttributeType2["FLOAT"] = 1] = "FLOAT";
AttributeType2[AttributeType2["INT"] = 2] = "INT";
AttributeType2[AttributeType2["STRING"] = 3] = "STRING";
AttributeType2[AttributeType2["TENSOR"] = 4] = "TENSOR";
AttributeType2[AttributeType2["GRAPH"] = 5] = "GRAPH";
AttributeType2[AttributeType2["FLOATS"] = 6] = "FLOATS";
AttributeType2[AttributeType2["INTS"] = 7] = "INTS";
AttributeType2[AttributeType2["STRINGS"] = 8] = "STRINGS";
AttributeType2[AttributeType2["TENSORS"] = 9] = "TENSORS";
AttributeType2[AttributeType2["GRAPHS"] = 10] = "GRAPHS";
AttributeType2[AttributeType2["SPARSE_TENSOR"] = 11] = "SPARSE_TENSOR";
AttributeType2[AttributeType2["SPARSE_TENSORS"] = 12] = "SPARSE_TENSORS";
})(AttributeType = fbs2.AttributeType || (fbs2.AttributeType = {}));
})(fbs = experimental2.fbs || (experimental2.fbs = {}));
})(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
})(onnxruntime || (onnxruntime = {}));
((onnxruntime2) => {
let experimental;
((experimental2) => {
let fbs;
((fbs2) => {
let DimensionValueType;
((DimensionValueType2) => {
DimensionValueType2[DimensionValueType2["UNKNOWN"] = 0] = "UNKNOWN";
DimensionValueType2[DimensionValueType2["VALUE"] = 1] = "VALUE";
DimensionValueType2[DimensionValueType2["PARAM"] = 2] = "PARAM";
})(DimensionValueType = fbs2.DimensionValueType || (fbs2.DimensionValueType = {}));
})(fbs = experimental2.fbs || (experimental2.fbs = {}));
})(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
})(onnxruntime || (onnxruntime = {}));
((onnxruntime2) => {
let experimental;
((experimental2) => {
let fbs;
((fbs2) => {
let TensorDataType;
((TensorDataType2) => {
TensorDataType2[TensorDataType2["UNDEFINED"] = 0] = "UNDEFINED";
TensorDataType2[TensorDataType2["FLOAT"] = 1] = "FLOAT";
TensorDataType2[TensorDataType2["UINT8"] = 2] = "UINT8";
TensorDataType2[TensorDataType2["INT8"] = 3] = "INT8";
TensorDataType2[TensorDataType2["UINT16"] = 4] = "UINT16";
TensorDataType2[TensorDataType2["INT16"] = 5] = "INT16";
TensorDataType2[TensorDataType2["INT32"] = 6] = "INT32";
TensorDataType2[TensorDataType2["INT64"] = 7] = "INT64";
TensorDataType2[TensorDataType2["STRING"] = 8] = "STRING";
TensorDataType2[TensorDataType2["BOOL"] = 9] = "BOOL";
TensorDataType2[TensorDataType2["FLOAT16"] = 10] = "FLOAT16";
TensorDataType2[TensorDataType2["DOUBLE"] = 11] = "DOUBLE";
TensorDataType2[TensorDataType2["UINT32"] = 12] = "UINT32";
TensorDataType2[TensorDataType2["UINT64"] = 13] = "UINT64";
TensorDataType2[TensorDataType2["COMPLEX64"] = 14] = "COMPLEX64";
TensorDataType2[TensorDataType2["COMPLEX128"] = 15] = "COMPLEX128";
TensorDataType2[TensorDataType2["BFLOAT16"] = 16] = "BFLOAT16";
TensorDataType2[TensorDataType2["FLOAT8E4M3FN"] = 17] = "FLOAT8E4M3FN";
TensorDataType2[TensorDataType2["FLOAT8E4M3FNUZ"] = 18] = "FLOAT8E4M3FNUZ";
TensorDataType2[TensorDataType2["FLOAT8E5M2"] = 19] = "FLOAT8E5M2";
TensorDataType2[TensorDataType2["FLOAT8E5M2FNUZ"] = 20] = "FLOAT8E5M2FNUZ";
})(TensorDataType = fbs2.TensorDataType || (fbs2.TensorDataType = {}));
})(fbs = experimental2.fbs || (experimental2.fbs = {}));
})(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
})(onnxruntime || (onnxruntime = {}));
((onnxruntime2) => {
let experimental;
((experimental2) => {
let fbs;
((fbs2) => {
let NodeType;
((NodeType2) => {
NodeType2[NodeType2["Primitive"] = 0] = "Primitive";
NodeType2[NodeType2["Fused"] = 1] = "Fused";
})(NodeType = fbs2.NodeType || (fbs2.NodeType = {}));
})(fbs = experimental2.fbs || (experimental2.fbs = {}));
})(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
})(onnxruntime || (onnxruntime = {}));
((onnxruntime2) => {
let experimental;
((experimental2) => {
let fbs;
((fbs2) => {
let TypeInfoValue;
((TypeInfoValue2) => {
TypeInfoValue2[TypeInfoValue2["NONE"] = 0] = "NONE";
TypeInfoValue2[TypeInfoValue2["tensor_type"] = 1] = "tensor_type";
TypeInfoValue2[TypeInfoValue2["sequence_type"] = 2] = "sequence_type";
TypeInfoValue2[TypeInfoValue2["map_type"] = 3] = "map_type";
})(TypeInfoValue = fbs2.TypeInfoValue || (fbs2.TypeInfoValue = {}));
})(fbs = experimental2.fbs || (experimental2.fbs = {}));
})(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
})(onnxruntime || (onnxruntime = {}));
((onnxruntime2) => {
let experimental;
((experimental2) => {
let fbs;
((fbs2) => {
class Shape {
constructor() {
this.bb = null;
this.bb_pos = 0;
}
/**
* @param number i
* @param flatbuffers.ByteBuffer bb
* @returns Shape
*/
__init(i, bb) {
this.bb_pos = i;
this.bb = bb;
return this;
}
/**
* @param flatbuffers.ByteBuffer bb
* @param Shape= obj
* @returns Shape
*/
static getRootAsShape(bb, obj) {
return (obj || new Shape()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
/**
* @param flatbuffers.ByteBuffer bb
* @param Shape= obj
* @returns Shape
*/
static getSizePrefixedRootAsShape(bb, obj) {
bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
return (obj || new Shape()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
/**
* @param number index
* @param onnxruntime.experimental.fbs.Dimension= obj
* @returns onnxruntime.experimental.fbs.Dimension
*/
dim(index, obj) {
let offset = this.bb.__offset(this.bb_pos, 4);
return offset ? (obj || new onnxruntime2.experimental.fbs.Dimension()).__init(
this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
this.bb
) : null;
}
/**
* @returns number
*/
dimLength() {
let offset = this.bb.__offset(this.bb_pos, 4);
return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
}
/**
* @param flatbuffers.Builder builder
*/
static startShape(builder) {
builder.startObject(1);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset dimOffset
*/
static addDim(builder, dimOffset) {
builder.addFieldOffset(0, dimOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param Array.<flatbuffers.Offset> data
* @returns flatbuffers.Offset
*/
static createDimVector(builder, data) {
builder.startVector(4, data.length, 4);
for (let i = data.length - 1; i >= 0; i--) {
builder.addOffset(data[i]);
}
return builder.endVector();
}
/**
* @param flatbuffers.Builder builder
* @param number numElems
*/
static startDimVector(builder, numElems) {
builder.startVector(4, numElems, 4);
}
/**
* @param flatbuffers.Builder builder
* @returns flatbuffers.Offset
*/
static endShape(builder) {
let offset = builder.endObject();
return offset;
}
static createShape(builder, dimOffset) {
Shape.startShape(builder);
Shape.addDim(builder, dimOffset);
return Shape.endShape(builder);
}
}
fbs2.Shape = Shape;
})(fbs = experimental2.fbs || (experimental2.fbs = {}));
})(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
})(onnxruntime || (onnxruntime = {}));
((onnxruntime2) => {
let experimental;
((experimental2) => {
let fbs;
((fbs2) => {
class Dimension {
constructor() {
this.bb = null;
this.bb_pos = 0;
}
/**
* @param number i
* @param flatbuffers.ByteBuffer bb
* @returns Dimension
*/
__init(i, bb) {
this.bb_pos = i;
this.bb = bb;
return this;
}
/**
* @param flatbuffers.ByteBuffer bb
* @param Dimension= obj
* @returns Dimension
*/
static getRootAsDimension(bb, obj) {
return (obj || new Dimension()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
/**
* @param flatbuffers.ByteBuffer bb
* @param Dimension= obj
* @returns Dimension
*/
static getSizePrefixedRootAsDimension(bb, obj) {
bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
return (obj || new Dimension()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
/**
* @param onnxruntime.experimental.fbs.DimensionValue= obj
* @returns onnxruntime.experimental.fbs.DimensionValue|null
*/
value(obj) {
let offset = this.bb.__offset(this.bb_pos, 4);
return offset ? (obj || new onnxruntime2.experimental.fbs.DimensionValue()).__init(
this.bb.__indirect(this.bb_pos + offset),
this.bb
) : null;
}
denotation(optionalEncoding) {
let offset = this.bb.__offset(this.bb_pos, 6);
return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
}
/**
* @param flatbuffers.Builder builder
*/
static startDimension(builder) {
builder.startObject(2);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset valueOffset
*/
static addValue(builder, valueOffset) {
builder.addFieldOffset(0, valueOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset denotationOffset
*/
static addDenotation(builder, denotationOffset) {
builder.addFieldOffset(1, denotationOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @returns flatbuffers.Offset
*/
static endDimension(builder) {
let offset = builder.endObject();
return offset;
}
static createDimension(builder, valueOffset, denotationOffset) {
Dimension.startDimension(builder);
Dimension.addValue(builder, valueOffset);
Dimension.addDenotation(builder, denotationOffset);
return Dimension.endDimension(builder);
}
}
fbs2.Dimension = Dimension;
})(fbs = experimental2.fbs || (experimental2.fbs = {}));
})(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
})(onnxruntime || (onnxruntime = {}));
((onnxruntime2) => {
let experimental;
((experimental2) => {
let fbs;
((fbs2) => {
class DimensionValue {
constructor() {
this.bb = null;
this.bb_pos = 0;
}
/**
* @param number i
* @param flatbuffers.ByteBuffer bb
* @returns DimensionValue
*/
__init(i, bb) {
this.bb_pos = i;
this.bb = bb;
return this;
}
/**
* @param flatbuffers.ByteBuffer bb
* @param DimensionValue= obj
* @returns DimensionValue
*/
static getRootAsDimensionValue(bb, obj) {
return (obj || new DimensionValue()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
/**
* @param flatbuffers.ByteBuffer bb
* @param DimensionValue= obj
* @returns DimensionValue
*/
static getSizePrefixedRootAsDimensionValue(bb, obj) {
bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
return (obj || new DimensionValue()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
/**
* @returns onnxruntime.experimental.fbs.DimensionValueType
*/
dimType() {
let offset = this.bb.__offset(this.bb_pos, 4);
return offset ? (
/** */
this.bb.readInt8(this.bb_pos + offset)
) : 0 /* UNKNOWN */;
}
/**
* @returns flatbuffers.Long
*/
dimValue() {
let offset = this.bb.__offset(this.bb_pos, 6);
return offset ? this.bb.readInt64(this.bb_pos + offset) : this.bb.createLong(0, 0);
}
dimParam(optionalEncoding) {
let offset = this.bb.__offset(this.bb_pos, 8);
return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
}
/**
* @param flatbuffers.Builder builder
*/
static startDimensionValue(builder) {
builder.startObject(3);
}
/**
* @param flatbuffers.Builder builder
* @param onnxruntime.experimental.fbs.DimensionValueType dimType
*/
static addDimType(builder, dimType) {
builder.addFieldInt8(0, dimType, 0 /* UNKNOWN */);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Long dimValue
*/
static addDimValue(builder, dimValue) {
builder.addFieldInt64(1, dimValue, builder.createLong(0, 0));
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset dimParamOffset
*/
static addDimParam(builder, dimParamOffset) {
builder.addFieldOffset(2, dimParamOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @returns flatbuffers.Offset
*/
static endDimensionValue(builder) {
let offset = builder.endObject();
return offset;
}
static createDimensionValue(builder, dimType, dimValue, dimParamOffset) {
DimensionValue.startDimensionValue(builder);
DimensionValue.addDimType(builder, dimType);
DimensionValue.addDimValue(builder, dimValue);
DimensionValue.addDimParam(builder, dimParamOffset);
return DimensionValue.endDimensionValue(builder);
}
}
fbs2.DimensionValue = DimensionValue;
})(fbs = experimental2.fbs || (experimental2.fbs = {}));
})(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
})(onnxruntime || (onnxruntime = {}));
((onnxruntime2) => {
let experimental;
((experimental2) => {
let fbs;
((fbs2) => {
class TensorTypeAndShape {
constructor() {
this.bb = null;
this.bb_pos = 0;
}
/**
* @param number i
* @param flatbuffers.ByteBuffer bb
* @returns TensorTypeAndShape
*/
__init(i, bb) {
this.bb_pos = i;
this.bb = bb;
return this;
}
/**
* @param flatbuffers.ByteBuffer bb
* @param TensorTypeAndShape= obj
* @returns TensorTypeAndShape
*/
static getRootAsTensorTypeAndShape(bb, obj) {
return (obj || new TensorTypeAndShape()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
/**
* @param flatbuffers.ByteBuffer bb
* @param TensorTypeAndShape= obj
* @returns TensorTypeAndShape
*/
static getSizePrefixedRootAsTensorTypeAndShape(bb, obj) {
bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
return (obj || new TensorTypeAndShape()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
/**
* @returns onnxruntime.experimental.fbs.TensorDataType
*/
elemType() {
let offset = this.bb.__offset(this.bb_pos, 4);
return offset ? (
/** */
this.bb.readInt32(this.bb_pos + offset)
) : 0 /* UNDEFINED */;
}
/**
* @param onnxruntime.experimental.fbs.Shape= obj
* @returns onnxruntime.experimental.fbs.Shape|null
*/
shape(obj) {
let offset = this.bb.__offset(this.bb_pos, 6);
return offset ? (obj || new onnxruntime2.experimental.fbs.Shape()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
}
/**
* @param flatbuffers.Builder builder
*/
static startTensorTypeAndShape(builder) {
builder.startObject(2);
}
/**
* @param flatbuffers.Builder builder
* @param onnxruntime.experimental.fbs.TensorDataType elemType
*/
static addElemType(builder, elemType) {
builder.addFieldInt32(0, elemType, 0 /* UNDEFINED */);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset shapeOffset
*/
static addShape(builder, shapeOffset) {
builder.addFieldOffset(1, shapeOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @returns flatbuffers.Offset
*/
static endTensorTypeAndShape(builder) {
let offset = builder.endObject();
return offset;
}
static createTensorTypeAndShape(builder, elemType, shapeOffset) {
TensorTypeAndShape.startTensorTypeAndShape(builder);
TensorTypeAndShape.addElemType(builder, elemType);
TensorTypeAndShape.addShape(builder, shapeOffset);
return TensorTypeAndShape.endTensorTypeAndShape(builder);
}
}
fbs2.TensorTypeAndShape = TensorTypeAndShape;
})(fbs = experimental2.fbs || (experimental2.fbs = {}));
})(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
})(onnxruntime || (onnxruntime = {}));
((onnxruntime2) => {
let experimental;
((experimental2) => {
let fbs;
((fbs2) => {
class MapType {
constructor() {
this.bb = null;
this.bb_pos = 0;
}
/**
* @param number i
* @param flatbuffers.ByteBuffer bb
* @returns MapType
*/
__init(i, bb) {
this.bb_pos = i;
this.bb = bb;
return this;
}
/**
* @param flatbuffers.ByteBuffer bb
* @param MapType= obj
* @returns MapType
*/
static getRootAsMapType(bb, obj) {
return (obj || new MapType()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
/**
* @param flatbuffers.ByteBuffer bb
* @param MapType= obj
* @returns MapType
*/
static getSizePrefixedRootAsMapType(bb, obj) {
bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
return (obj || new MapType()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
/**
* @returns onnxruntime.experimental.fbs.TensorDataType
*/
keyType() {
let offset = this.bb.__offset(this.bb_pos, 4);
return offset ? (
/** */
this.bb.readInt32(this.bb_pos + offset)
) : 0 /* UNDEFINED */;
}
/**
* @param onnxruntime.experimental.fbs.TypeInfo= obj
* @returns onnxruntime.experimental.fbs.TypeInfo|null
*/
valueType(obj) {
let offset = this.bb.__offset(this.bb_pos, 6);
return offset ? (obj || new onnxruntime2.experimental.fbs.TypeInfo()).__init(
this.bb.__indirect(this.bb_pos + offset),
this.bb
) : null;
}
/**
* @param flatbuffers.Builder builder
*/
static startMapType(builder) {
builder.startObject(2);
}
/**
* @param flatbuffers.Builder builder
* @param onnxruntime.experimental.fbs.TensorDataType keyType
*/
static addKeyType(builder, keyType) {
builder.addFieldInt32(0, keyType, 0 /* UNDEFINED */);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset valueTypeOffset
*/
static addValueType(builder, valueTypeOffset) {
builder.addFieldOffset(1, valueTypeOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @returns flatbuffers.Offset
*/
static endMapType(builder) {
let offset = builder.endObject();
return offset;
}
static createMapType(builder, keyType, valueTypeOffset) {
MapType.startMapType(builder);
MapType.addKeyType(builder, keyType);
MapType.addValueType(builder, valueTypeOffset);
return MapType.endMapType(builder);
}
}
fbs2.MapType = MapType;
})(fbs = experimental2.fbs || (experimental2.fbs = {}));
})(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
})(onnxruntime || (onnxruntime = {}));
((onnxruntime2) => {
let experimental;
((experimental2) => {
let fbs;
((fbs2) => {
class SequenceType {
constructor() {
this.bb = null;
this.bb_pos = 0;
}
/**
* @param number i
* @param flatbuffers.ByteBuffer bb
* @returns SequenceType
*/
__init(i, bb) {
this.bb_pos = i;
this.bb = bb;
return this;
}
/**
* @param flatbuffers.ByteBuffer bb
* @param SequenceType= obj
* @returns SequenceType
*/
static getRootAsSequenceType(bb, obj) {
return (obj || new SequenceType()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
/**
* @param flatbuffers.ByteBuffer bb
* @param SequenceType= obj
* @returns SequenceType
*/
static getSizePrefixedRootAsSequenceType(bb, obj) {
bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
return (obj || new SequenceType()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
/**
* @param onnxruntime.experimental.fbs.TypeInfo= obj
* @returns onnxruntime.experimental.fbs.TypeInfo|null
*/
elemType(obj) {
let offset = this.bb.__offset(this.bb_pos, 4);
return offset ? (obj || new onnxruntime2.experimental.fbs.TypeInfo()).__init(
this.bb.__indirect(this.bb_pos + offset),
this.bb
) : null;
}
/**
* @param flatbuffers.Builder builder
*/
static startSequenceType(builder) {
builder.startObject(1);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset elemTypeOffset
*/
static addElemType(builder, elemTypeOffset) {
builder.addFieldOffset(0, elemTypeOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @returns flatbuffers.Offset
*/
static endSequenceType(builder) {
let offset = builder.endObject();
return offset;
}
static createSequenceType(builder, elemTypeOffset) {
SequenceType.startSequenceType(builder);
SequenceType.addElemType(builder, elemTypeOffset);
return SequenceType.endSequenceType(builder);
}
}
fbs2.SequenceType = SequenceType;
})(fbs = experimental2.fbs || (experimental2.fbs = {}));
})(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
})(onnxruntime || (onnxruntime = {}));
((onnxruntime2) => {
let experimental;
((experimental2) => {
let fbs;
((fbs2) => {
class EdgeEnd {
constructor() {
this.bb = null;
this.bb_pos = 0;
}
/**
* @param number i
* @param flatbuffers.ByteBuffer bb
* @returns EdgeEnd
*/
__init(i, bb) {
this.bb_pos = i;
this.bb = bb;
return this;
}
/**
* @returns number
*/
nodeIndex() {
return this.bb.readUint32(this.bb_pos);
}
/**
* @returns number
*/
srcArgIndex() {
return this.bb.readInt32(this.bb_pos + 4);
}
/**
* @returns number
*/
dstArgIndex() {
return this.bb.readInt32(this.bb_pos + 8);
}
/**
* @param flatbuffers.Builder builder
* @param number node_index
* @param number src_arg_index
* @param number dst_arg_index
* @returns flatbuffers.Offset
*/
static createEdgeEnd(builder, node_index, src_arg_index, dst_arg_index) {
builder.prep(4, 12);
builder.writeInt32(dst_arg_index);
builder.writeInt32(src_arg_index);
builder.writeInt32(node_index);
return builder.offset();
}
}
fbs2.EdgeEnd = EdgeEnd;
})(fbs = experimental2.fbs || (experimental2.fbs = {}));
})(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
})(onnxruntime || (onnxruntime = {}));
((onnxruntime2) => {
let experimental;
((experimental2) => {
let fbs;
((fbs2) => {
class NodeEdge {
constructor() {
this.bb = null;
this.bb_pos = 0;
}
/**
* @param number i
* @param flatbuffers.ByteBuffer bb
* @returns NodeEdge
*/
__init(i, bb) {
this.bb_pos = i;
this.bb = bb;
return this;
}
/**
* @param flatbuffers.ByteBuffer bb
* @param NodeEdge= obj
* @returns NodeEdge
*/
static getRootAsNodeEdge(bb, obj) {
return (obj || new NodeEdge()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
/**
* @param flatbuffers.ByteBuffer bb
* @param NodeEdge= obj
* @returns NodeEdge
*/
static getSizePrefixedRootAsNodeEdge(bb, obj) {
bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
return (obj || new NodeEdge()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
/**
* @returns number
*/
nodeIndex() {
let offset = this.bb.__offset(this.bb_pos, 4);
return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
}
/**
* @param number index
* @param onnxruntime.experimental.fbs.EdgeEnd= obj
* @returns onnxruntime.experimental.fbs.EdgeEnd
*/
inputEdges(index, obj) {
let offset = this.bb.__offset(this.bb_pos, 6);
return offset ? (obj || new onnxruntime2.experimental.fbs.EdgeEnd()).__init(
this.bb.__vector(this.bb_pos + offset) + index * 12,
this.bb
) : null;
}
/**
* @returns number
*/
inputEdgesLength() {
let offset = this.bb.__offset(this.bb_pos, 6);
return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
}
/**
* @param number index
* @param onnxruntime.experimental.fbs.EdgeEnd= obj
* @returns onnxruntime.experimental.fbs.EdgeEnd
*/
outputEdges(index, obj) {
let offset = this.bb.__offset(this.bb_pos, 8);
return offset ? (obj || new onnxruntime2.experimental.fbs.EdgeEnd()).__init(
this.bb.__vector(this.bb_pos + offset) + index * 12,
this.bb
) : null;
}
/**
* @returns number
*/
outputEdgesLength() {
let offset = this.bb.__offset(this.bb_pos, 8);
return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
}
/**
* @param flatbuffers.Builder builder
*/
static startNodeEdge(builder) {
builder.startObject(3);
}
/**
* @param flatbuffers.Builder builder
* @param number nodeIndex
*/
static addNodeIndex(builder, nodeIndex) {
builder.addFieldInt32(0, nodeIndex, 0);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset inputEdgesOffset
*/
static addInputEdges(builder, inputEdgesOffset) {
builder.addFieldOffset(1, inputEdgesOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param number numElems
*/
static startInputEdgesVector(builder, numElems) {
builder.startVector(12, numElems, 4);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset outputEdgesOffset
*/
static addOutputEdges(builder, outputEdgesOffset) {
builder.addFieldOffset(2, outputEdgesOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param number numElems
*/
static startOutputEdgesVector(builder, numElems) {
builder.startVector(12, numElems, 4);
}
/**
* @param flatbuffers.Builder builder
* @returns flatbuffers.Offset
*/
static endNodeEdge(builder) {
let offset = builder.endObject();
return offset;
}
static createNodeEdge(builder, nodeIndex, inputEdgesOffset, outputEdgesOffset) {
NodeEdge.startNodeEdge(builder);
NodeEdge.addNodeIndex(builder, nodeIndex);
NodeEdge.addInputEdges(builder, inputEdgesOffset);
NodeEdge.addOutputEdges(builder, outputEdgesOffset);
return NodeEdge.endNodeEdge(builder);
}
}
fbs2.NodeEdge = NodeEdge;
})(fbs = experimental2.fbs || (experimental2.fbs = {}));
})(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
})(onnxruntime || (onnxruntime = {}));
((onnxruntime2) => {
let experimental;
((experimental2) => {
let fbs;
((fbs2) => {
class Node2 {
constructor() {
this.bb = null;
this.bb_pos = 0;
}
/**
* @param number i
* @param flatbuffers.ByteBuffer bb
* @returns Node
*/
__init(i, bb) {
this.bb_pos = i;
this.bb = bb;
return this;
}
/**
* @param flatbuffers.ByteBuffer bb
* @param Node= obj
* @returns Node
*/
static getRootAsNode(bb, obj) {
return (obj || new Node2()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
/**
* @param flatbuffers.ByteBuffer bb
* @param Node= obj
* @returns Node
*/
static getSizePrefixedRootAsNode(bb, obj) {
bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
return (obj || new Node2()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
name(optionalEncoding) {
let offset = this.bb.__offset(this.bb_pos, 4);
return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
}
docString(optionalEncoding) {
let offset = this.bb.__offset(this.bb_pos, 6);
return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
}
domain(optionalEncoding) {
let offset = this.bb.__offset(this.bb_pos, 8);
return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
}
/**
* @returns number
*/
sinceVersion() {
let offset = this.bb.__offset(this.bb_pos, 10);
return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
}
/**
* @returns number
*/
index() {
let offset = this.bb.__offset(this.bb_pos, 12);
return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
}
opType(optionalEncoding) {
let offset = this.bb.__offset(this.bb_pos, 14);
return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
}
/**
* @returns onnxruntime.experimental.fbs.NodeType
*/
type() {
let offset = this.bb.__offset(this.bb_pos, 16);
return offset ? (
/** */
this.bb.readInt32(this.bb_pos + offset)
) : 0 /* Primitive */;
}
executionProviderType(optionalEncoding) {
let offset = this.bb.__offset(this.bb_pos, 18);
return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
}
inputs(index, optionalEncoding) {
let offset = this.bb.__offset(this.bb_pos, 20);
return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;
}
/**
* @returns number
*/
inputsLength() {
let offset = this.bb.__offset(this.bb_pos, 20);
return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
}
outputs(index, optionalEncoding) {
let offset = this.bb.__offset(this.bb_pos, 22);
return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;
}
/**
* @returns number
*/
outputsLength() {
let offset = this.bb.__offset(this.bb_pos, 22);
return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
}
/**
* @param number index
* @param onnxruntime.experimental.fbs.Attribute= obj
* @returns onnxruntime.experimental.fbs.Attribute
*/
attributes(index, obj) {
let offset = this.bb.__offset(this.bb_pos, 24);
return offset ? (obj || new onnxruntime2.experimental.fbs.Attribute()).__init(
this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
this.bb
) : null;
}
/**
* @returns number
*/
attributesLength() {
let offset = this.bb.__offset(this.bb_pos, 24);
return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
}
/**
* @param number index
* @returns number
*/
inputArgCounts(index) {
let offset = this.bb.__offset(this.bb_pos, 26);
return offset ? this.bb.readInt32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
}
/**
* @returns number
*/
inputArgCountsLength() {
let offset = this.bb.__offset(this.bb_pos, 26);
return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
}
/**
* @returns Int32Array
*/
inputArgCountsArray() {
let offset = this.bb.__offset(this.bb_pos, 26);
return offset ? new Int32Array(
this.bb.bytes().buffer,
this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset),
this.bb.__vector_len(this.bb_pos + offset)
) : null;
}
implicitInputs(index, optionalEncoding) {
let offset = this.bb.__offset(this.bb_pos, 28);
return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;
}
/**
* @returns number
*/
implicitInputsLength() {
let offset = this.bb.__offset(this.bb_pos, 28);
return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
}
/**
* @param flatbuffers.Builder builder
*/
static startNode(builder) {
builder.startObject(13);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset nameOffset
*/
static addName(builder, nameOffset) {
builder.addFieldOffset(0, nameOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset docStringOffset
*/
static addDocString(builder, docStringOffset) {
builder.addFieldOffset(1, docStringOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset domainOffset
*/
static addDomain(builder, domainOffset) {
builder.addFieldOffset(2, domainOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param number sinceVersion
*/
static addSinceVersion(builder, sinceVersion) {
builder.addFieldInt32(3, sinceVersion, 0);
}
/**
* @param flatbuffers.Builder builder
* @param number index
*/
static addIndex(builder, index) {
builder.addFieldInt32(4, index, 0);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset opTypeOffset
*/
static addOpType(builder, opTypeOffset) {
builder.addFieldOffset(5, opTypeOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param onnxruntime.experimental.fbs.NodeType type
*/
static addType(builder, type) {
builder.addFieldInt32(6, type, 0 /* Primitive */);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset executionProviderTypeOffset
*/
static addExecutionProviderType(builder, executionProviderTypeOffset) {
builder.addFieldOffset(7, executionProviderTypeOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset inputsOffset
*/
static addInputs(builder, inputsOffset) {
builder.addFieldOffset(8, inputsOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param Array.<flatbuffers.Offset> data
* @returns flatbuffers.Offset
*/
static createInputsVector(builder, data) {
builder.startVector(4, data.length, 4);
for (let i = data.length - 1; i >= 0; i--) {
builder.addOffset(data[i]);
}
return builder.endVector();
}
/**
* @param flatbuffers.Builder builder
* @param number numElems
*/
static startInputsVector(builder, numElems) {
builder.startVector(4, numElems, 4);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset outputsOffset
*/
static addOutputs(builder, outputsOffset) {
builder.addFieldOffset(9, outputsOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param Array.<flatbuffers.Offset> data
* @returns flatbuffers.Offset
*/
static createOutputsVector(builder, data) {
builder.startVector(4, data.length, 4);
for (let i = data.length - 1; i >= 0; i--) {
builder.addOffset(data[i]);
}
return builder.endVector();
}
/**
* @param flatbuffers.Builder builder
* @param number numElems
*/
static startOutputsVector(builder, numElems) {
builder.startVector(4, numElems, 4);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset attributesOffset
*/
static addAttributes(builder, attributesOffset) {
builder.addFieldOffset(10, attributesOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param Array.<flatbuffers.Offset> data
* @returns flatbuffers.Offset
*/
static createAttributesVector(builder, data) {
builder.startVector(4, data.length, 4);
for (let i = data.length - 1; i >= 0; i--) {
builder.addOffset(data[i]);
}
return builder.endVector();
}
/**
* @param flatbuffers.Builder builder
* @param number numElems
*/
static startAttributesVector(builder, numElems) {
builder.startVector(4, numElems, 4);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset inputArgCountsOffset
*/
static addInputArgCounts(builder, inputArgCountsOffset) {
builder.addFieldOffset(11, inputArgCountsOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param Array.<number> data
* @returns flatbuffers.Offset
*/
static createInputArgCountsVector(builder, data) {
builder.startVector(4, data.length, 4);
for (let i = data.length - 1; i >= 0; i--) {
builder.addInt32(data[i]);
}
return builder.endVector();
}
/**
* @param flatbuffers.Builder builder
* @param number numElems
*/
static startInputArgCountsVector(builder, numElems) {
builder.startVector(4, numElems, 4);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset implicitInputsOffset
*/
static addImplicitInputs(builder, implicitInputsOffset) {
builder.addFieldOffset(12, implicitInputsOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param Array.<flatbuffers.Offset> data
* @returns flatbuffers.Offset
*/
static createImplicitInputsVector(builder, data) {
builder.startVector(4, data.length, 4);
for (let i = data.length - 1; i >= 0; i--) {
builder.addOffset(data[i]);
}
return builder.endVector();
}
/**
* @param flatbuffers.Builder builder
* @param number numElems
*/
static startImplicitInputsVector(builder, numElems) {
builder.startVector(4, numElems, 4);
}
/**
* @param flatbuffers.Builder builder
* @returns flatbuffers.Offset
*/
static endNode(builder) {
let offset = builder.endObject();
return offset;
}
static createNode(builder, nameOffset, docStringOffset, domainOffset, sinceVersion, index, opTypeOffset, type, executionProviderTypeOffset, inputsOffset, outputsOffset, attributesOffset, inputArgCountsOffset, implicitInputsOffset) {
Node2.startNode(builder);
Node2.addName(builder, nameOffset);
Node2.addDocString(builder, docStringOffset);
Node2.addDomain(builder, domainOffset);
Node2.addSinceVersion(builder, sinceVersion);
Node2.addIndex(builder, index);
Node2.addOpType(builder, opTypeOffset);
Node2.addType(builder, type);
Node2.addExecutionProviderType(builder, executionProviderTypeOffset);
Node2.addInputs(builder, inputsOffset);
Node2.addOutputs(builder, outputsOffset);
Node2.addAttributes(builder, attributesOffset);
Node2.addInputArgCounts(builder, inputArgCountsOffset);
Node2.addImplicitInputs(builder, implicitInputsOffset);
return Node2.endNode(builder);
}
}
fbs2.Node = Node2;
})(fbs = experimental2.fbs || (experimental2.fbs = {}));
})(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
})(onnxruntime || (onnxruntime = {}));
((onnxruntime2) => {
let experimental;
((experimental2) => {
let fbs;
((fbs2) => {
class ValueInfo {
constructor() {
this.bb = null;
this.bb_pos = 0;
}
/**
* @param number i
* @param flatbuffers.ByteBuffer bb
* @returns ValueInfo
*/
__init(i, bb) {
this.bb_pos = i;
this.bb = bb;
return this;
}
/**
* @param flatbuffers.ByteBuffer bb
* @param ValueInfo= obj
* @returns ValueInfo
*/
static getRootAsValueInfo(bb, obj) {
return (obj || new ValueInfo()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
/**
* @param flatbuffers.ByteBuffer bb
* @param ValueInfo= obj
* @returns ValueInfo
*/
static getSizePrefixedRootAsValueInfo(bb, obj) {
bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
return (obj || new ValueInfo()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
name(optionalEncoding) {
let offset = this.bb.__offset(this.bb_pos, 4);
return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
}
docString(optionalEncoding) {
let offset = this.bb.__offset(this.bb_pos, 6);
return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
}
/**
* @param onnxruntime.experimental.fbs.TypeInfo= obj
* @returns onnxruntime.experimental.fbs.TypeInfo|null
*/
type(obj) {
let offset = this.bb.__offset(this.bb_pos, 8);
return offset ? (obj || new onnxruntime2.experimental.fbs.TypeInfo()).__init(
this.bb.__indirect(this.bb_pos + offset),
this.bb
) : null;
}
/**
* @param flatbuffers.Builder builder
*/
static startValueInfo(builder) {
builder.startObject(3);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset nameOffset
*/
static addName(builder, nameOffset) {
builder.addFieldOffset(0, nameOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset docStringOffset
*/
static addDocString(builder, docStringOffset) {
builder.addFieldOffset(1, docStringOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset typeOffset
*/
static addType(builder, typeOffset) {
builder.addFieldOffset(2, typeOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @returns flatbuffers.Offset
*/
static endValueInfo(builder) {
let offset = builder.endObject();
return offset;
}
static createValueInfo(builder, nameOffset, docStringOffset, typeOffset) {
ValueInfo.startValueInfo(builder);
ValueInfo.addName(builder, nameOffset);
ValueInfo.addDocString(builder, docStringOffset);
ValueInfo.addType(builder, typeOffset);
return ValueInfo.endValueInfo(builder);
}
}
fbs2.ValueInfo = ValueInfo;
})(fbs = experimental2.fbs || (experimental2.fbs = {}));
})(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
})(onnxruntime || (onnxruntime = {}));
((onnxruntime2) => {
let experimental;
((experimental2) => {
let fbs;
((fbs2) => {
class TypeInfo {
constructor() {
this.bb = null;
this.bb_pos = 0;
}
/**
* @param number i
* @param flatbuffers.ByteBuffer bb
* @returns TypeInfo
*/
__init(i, bb) {
this.bb_pos = i;
this.bb = bb;
return this;
}
/**
* @param flatbuffers.ByteBuffer bb
* @param TypeInfo= obj
* @returns TypeInfo
*/
static getRootAsTypeInfo(bb, obj) {
return (obj || new TypeInfo()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
/**
* @param flatbuffers.ByteBuffer bb
* @param TypeInfo= obj
* @returns TypeInfo
*/
static getSizePrefixedRootAsTypeInfo(bb, obj) {
bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
return (obj || new TypeInfo()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
denotation(optionalEncoding) {
let offset = this.bb.__offset(this.bb_pos, 4);
return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
}
/**
* @returns onnxruntime.experimental.fbs.TypeInfoValue
*/
valueType() {
let offset = this.bb.__offset(this.bb_pos, 6);
return offset ? (
/** */
this.bb.readUint8(this.bb_pos + offset)
) : 0 /* NONE */;
}
/**
* @param flatbuffers.Table obj
* @returns ?flatbuffers.Table
*/
value(obj) {
let offset = this.bb.__offset(this.bb_pos, 8);
return offset ? this.bb.__union(obj, this.bb_pos + offset) : null;
}
/**
* @param flatbuffers.Builder builder
*/
static startTypeInfo(builder) {
builder.startObject(3);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset denotationOffset
*/
static addDenotation(builder, denotationOffset) {
builder.addFieldOffset(0, denotationOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param onnxruntime.experimental.fbs.TypeInfoValue valueType
*/
static addValueType(builder, valueType) {
builder.addFieldInt8(1, valueType, 0 /* NONE */);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset valueOffset
*/
static addValue(builder, valueOffset) {
builder.addFieldOffset(2, valueOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @returns flatbuffers.Offset
*/
static endTypeInfo(builder) {
let offset = builder.endObject();
return offset;
}
static createTypeInfo(builder, denotationOffset, valueType, valueOffset) {
TypeInfo.startTypeInfo(builder);
TypeInfo.addDenotation(builder, denotationOffset);
TypeInfo.addValueType(builder, valueType);
TypeInfo.addValue(builder, valueOffset);
return TypeInfo.endTypeInfo(builder);
}
}
fbs2.TypeInfo = TypeInfo;
})(fbs = experimental2.fbs || (experimental2.fbs = {}));
})(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
})(onnxruntime || (onnxruntime = {}));
((onnxruntime2) => {
let experimental;
((experimental2) => {
let fbs;
((fbs2) => {
class OperatorSetId {
constructor() {
this.bb = null;
this.bb_pos = 0;
}
/**
* @param number i
* @param flatbuffers.ByteBuffer bb
* @returns OperatorSetId
*/
__init(i, bb) {
this.bb_pos = i;
this.bb = bb;
return this;
}
/**
* @param flatbuffers.ByteBuffer bb
* @param OperatorSetId= obj
* @returns OperatorSetId
*/
static getRootAsOperatorSetId(bb, obj) {
return (obj || new OperatorSetId()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
/**
* @param flatbuffers.ByteBuffer bb
* @param OperatorSetId= obj
* @returns OperatorSetId
*/
static getSizePrefixedRootAsOperatorSetId(bb, obj) {
bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
return (obj || new OperatorSetId()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
domain(optionalEncoding) {
let offset = this.bb.__offset(this.bb_pos, 4);
return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
}
/**
* @returns flatbuffers.Long
*/
version() {
let offset = this.bb.__offset(this.bb_pos, 6);
return offset ? this.bb.readInt64(this.bb_pos + offset) : this.bb.createLong(0, 0);
}
/**
* @param flatbuffers.Builder builder
*/
static startOperatorSetId(builder) {
builder.startObject(2);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset domainOffset
*/
static addDomain(builder, domainOffset) {
builder.addFieldOffset(0, domainOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Long version
*/
static addVersion(builder, version3) {
builder.addFieldInt64(1, version3, builder.createLong(0, 0));
}
/**
* @param flatbuffers.Builder builder
* @returns flatbuffers.Offset
*/
static endOperatorSetId(builder) {
let offset = builder.endObject();
return offset;
}
static createOperatorSetId(builder, domainOffset, version3) {
OperatorSetId.startOperatorSetId(builder);
OperatorSetId.addDomain(builder, domainOffset);
OperatorSetId.addVersion(builder, version3);
return OperatorSetId.endOperatorSetId(builder);
}
}
fbs2.OperatorSetId = OperatorSetId;
})(fbs = experimental2.fbs || (experimental2.fbs = {}));
})(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
})(onnxruntime || (onnxruntime = {}));
((onnxruntime2) => {
let experimental;
((experimental2) => {
let fbs;
((fbs2) => {
class Tensor4 {
constructor() {
this.bb = null;
this.bb_pos = 0;
}
/**
* @param number i
* @param flatbuffers.ByteBuffer bb
* @returns Tensor
*/
__init(i, bb) {
this.bb_pos = i;
this.bb = bb;
return this;
}
/**
* @param flatbuffers.ByteBuffer bb
* @param Tensor= obj
* @returns Tensor
*/
static getRootAsTensor(bb, obj) {
return (obj || new Tensor4()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
/**
* @param flatbuffers.ByteBuffer bb
* @param Tensor= obj
* @returns Tensor
*/
static getSizePrefixedRootAsTensor(bb, obj) {
bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
return (obj || new Tensor4()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
name(optionalEncoding) {
let offset = this.bb.__offset(this.bb_pos, 4);
return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
}
docString(optionalEncoding) {
let offset = this.bb.__offset(this.bb_pos, 6);
return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
}
/**
* @param number index
* @returns flatbuffers.Long
*/
dims(index) {
let offset = this.bb.__offset(this.bb_pos, 8);
return offset ? this.bb.readInt64(this.bb.__vector(this.bb_pos + offset) + index * 8) : this.bb.createLong(0, 0);
}
/**
* @returns number
*/
dimsLength() {
let offset = this.bb.__offset(this.bb_pos, 8);
return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
}
/**
* @returns onnxruntime.experimental.fbs.TensorDataType
*/
dataType() {
let offset = this.bb.__offset(this.bb_pos, 10);
return offset ? (
/** */
this.bb.readInt32(this.bb_pos + offset)
) : 0 /* UNDEFINED */;
}
/**
* @param number index
* @returns number
*/
rawData(index) {
let offset = this.bb.__offset(this.bb_pos, 12);
return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0;
}
/**
* @returns number
*/
rawDataLength() {
let offset = this.bb.__offset(this.bb_pos, 12);
return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
}
/**
* @returns Uint8Array
*/
rawDataArray() {
let offset = this.bb.__offset(this.bb_pos, 12);
return offset ? new Uint8Array(
this.bb.bytes().buffer,
this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset),
this.bb.__vector_len(this.bb_pos + offset)
) : null;
}
stringData(index, optionalEncoding) {
let offset = this.bb.__offset(this.bb_pos, 14);
return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;
}
/**
* @returns number
*/
stringDataLength() {
let offset = this.bb.__offset(this.bb_pos, 14);
return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
}
/**
* @param flatbuffers.Builder builder
*/
static startTensor(builder) {
builder.startObject(6);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset nameOffset
*/
static addName(builder, nameOffset) {
builder.addFieldOffset(0, nameOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset docStringOffset
*/
static addDocString(builder, docStringOffset) {
builder.addFieldOffset(1, docStringOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset dimsOffset
*/
static addDims(builder, dimsOffset) {
builder.addFieldOffset(2, dimsOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param Array.<flatbuffers.Long> data
* @returns flatbuffers.Offset
*/
static createDimsVector(builder, data) {
builder.startVector(8, data.length, 8);
for (let i = data.length - 1; i >= 0; i--) {
builder.addInt64(data[i]);
}
return builder.endVector();
}
/**
* @param flatbuffers.Builder builder
* @param number numElems
*/
static startDimsVector(builder, numElems) {
builder.startVector(8, numElems, 8);
}
/**
* @param flatbuffers.Builder builder
* @param onnxruntime.experimental.fbs.TensorDataType dataType
*/
static addDataType(builder, dataType) {
builder.addFieldInt32(3, dataType, 0 /* UNDEFINED */);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset rawDataOffset
*/
static addRawData(builder, rawDataOffset) {
builder.addFieldOffset(4, rawDataOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param Array.<number> data
* @returns flatbuffers.Offset
*/
static createRawDataVector(builder, data) {
builder.startVector(1, data.length, 1);
for (let i = data.length - 1; i >= 0; i--) {
builder.addInt8(data[i]);
}
return builder.endVector();
}
/**
* @param flatbuffers.Builder builder
* @param number numElems
*/
static startRawDataVector(builder, numElems) {
builder.startVector(1, numElems, 1);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset stringDataOffset
*/
static addStringData(builder, stringDataOffset) {
builder.addFieldOffset(5, stringDataOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param Array.<flatbuffers.Offset> data
* @returns flatbuffers.Offset
*/
static createStringDataVector(builder, data) {
builder.startVector(4, data.length, 4);
for (let i = data.length - 1; i >= 0; i--) {
builder.addOffset(data[i]);
}
return builder.endVector();
}
/**
* @param flatbuffers.Builder builder
* @param number numElems
*/
static startStringDataVector(builder, numElems) {
builder.startVector(4, numElems, 4);
}
/**
* @param flatbuffers.Builder builder
* @returns flatbuffers.Offset
*/
static endTensor(builder) {
let offset = builder.endObject();
return offset;
}
static createTensor(builder, nameOffset, docStringOffset, dimsOffset, dataType, rawDataOffset, stringDataOffset) {
Tensor4.startTensor(builder);
Tensor4.addName(builder, nameOffset);
Tensor4.addDocString(builder, docStringOffset);
Tensor4.addDims(builder, dimsOffset);
Tensor4.addDataType(builder, dataType);
Tensor4.addRawData(builder, rawDataOffset);
Tensor4.addStringData(builder, stringDataOffset);
return Tensor4.endTensor(builder);
}
}
fbs2.Tensor = Tensor4;
})(fbs = experimental2.fbs || (experimental2.fbs = {}));
})(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
})(onnxruntime || (onnxruntime = {}));
((onnxruntime2) => {
let experimental;
((experimental2) => {
let fbs;
((fbs2) => {
class SparseTensor {
constructor() {
this.bb = null;
this.bb_pos = 0;
}
/**
* @param number i
* @param flatbuffers.ByteBuffer bb
* @returns SparseTensor
*/
__init(i, bb) {
this.bb_pos = i;
this.bb = bb;
return this;
}
/**
* @param flatbuffers.ByteBuffer bb
* @param SparseTensor= obj
* @returns SparseTensor
*/
static getRootAsSparseTensor(bb, obj) {
return (obj || new SparseTensor()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
/**
* @param flatbuffers.ByteBuffer bb
* @param SparseTensor= obj
* @returns SparseTensor
*/
static getSizePrefixedRootAsSparseTensor(bb, obj) {
bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
return (obj || new SparseTensor()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
/**
* @param onnxruntime.experimental.fbs.Tensor= obj
* @returns onnxruntime.experimental.fbs.Tensor|null
*/
values(obj) {
let offset = this.bb.__offset(this.bb_pos, 4);
return offset ? (obj || new onnxruntime2.experimental.fbs.Tensor()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
}
/**
* @param onnxruntime.experimental.fbs.Tensor= obj
* @returns onnxruntime.experimental.fbs.Tensor|null
*/
indices(obj) {
let offset = this.bb.__offset(this.bb_pos, 6);
return offset ? (obj || new onnxruntime2.experimental.fbs.Tensor()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
}
/**
* @param number index
* @returns flatbuffers.Long
*/
dims(index) {
let offset = this.bb.__offset(this.bb_pos, 8);
return offset ? this.bb.readInt64(this.bb.__vector(this.bb_pos + offset) + index * 8) : this.bb.createLong(0, 0);
}
/**
* @returns number
*/
dimsLength() {
let offset = this.bb.__offset(this.bb_pos, 8);
return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
}
/**
* @param flatbuffers.Builder builder
*/
static startSparseTensor(builder) {
builder.startObject(3);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset valuesOffset
*/
static addValues(builder, valuesOffset) {
builder.addFieldOffset(0, valuesOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset indicesOffset
*/
static addIndices(builder, indicesOffset) {
builder.addFieldOffset(1, indicesOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset dimsOffset
*/
static addDims(builder, dimsOffset) {
builder.addFieldOffset(2, dimsOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param Array.<flatbuffers.Long> data
* @returns flatbuffers.Offset
*/
static createDimsVector(builder, data) {
builder.startVector(8, data.length, 8);
for (let i = data.length - 1; i >= 0; i--) {
builder.addInt64(data[i]);
}
return builder.endVector();
}
/**
* @param flatbuffers.Builder builder
* @param number numElems
*/
static startDimsVector(builder, numElems) {
builder.startVector(8, numElems, 8);
}
/**
* @param flatbuffers.Builder builder
* @returns flatbuffers.Offset
*/
static endSparseTensor(builder) {
let offset = builder.endObject();
return offset;
}
static createSparseTensor(builder, valuesOffset, indicesOffset, dimsOffset) {
SparseTensor.startSparseTensor(builder);
SparseTensor.addValues(builder, valuesOffset);
SparseTensor.addIndices(builder, indicesOffset);
SparseTensor.addDims(builder, dimsOffset);
return SparseTensor.endSparseTensor(builder);
}
}
fbs2.SparseTensor = SparseTensor;
})(fbs = experimental2.fbs || (experimental2.fbs = {}));
})(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
})(onnxruntime || (onnxruntime = {}));
((onnxruntime2) => {
let experimental;
((experimental2) => {
let fbs;
((fbs2) => {
class Attribute2 {
constructor() {
this.bb = null;
this.bb_pos = 0;
}
/**
* @param number i
* @param flatbuffers.ByteBuffer bb
* @returns Attribute
*/
__init(i, bb) {
this.bb_pos = i;
this.bb = bb;
return this;
}
/**
* @param flatbuffers.ByteBuffer bb
* @param Attribute= obj
* @returns Attribute
*/
static getRootAsAttribute(bb, obj) {
return (obj || new Attribute2()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
/**
* @param flatbuffers.ByteBuffer bb
* @param Attribute= obj
* @returns Attribute
*/
static getSizePrefixedRootAsAttribute(bb, obj) {
bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
return (obj || new Attribute2()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
name(optionalEncoding) {
let offset = this.bb.__offset(this.bb_pos, 4);
return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
}
docString(optionalEncoding) {
let offset = this.bb.__offset(this.bb_pos, 6);
return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
}
/**
* @returns onnxruntime.experimental.fbs.AttributeType
*/
type() {
let offset = this.bb.__offset(this.bb_pos, 8);
return offset ? (
/** */
this.bb.readInt32(this.bb_pos + offset)
) : 0 /* UNDEFINED */;
}
/**
* @returns number
*/
f() {
let offset = this.bb.__offset(this.bb_pos, 10);
return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0;
}
/**
* @returns flatbuffers.Long
*/
i() {
let offset = this.bb.__offset(this.bb_pos, 12);
return offset ? this.bb.readInt64(this.bb_pos + offset) : this.bb.createLong(0, 0);
}
s(optionalEncoding) {
let offset = this.bb.__offset(this.bb_pos, 14);
return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
}
/**
* @param onnxruntime.experimental.fbs.Tensor= obj
* @returns onnxruntime.experimental.fbs.Tensor|null
*/
t(obj) {
let offset = this.bb.__offset(this.bb_pos, 16);
return offset ? (obj || new onnxruntime2.experimental.fbs.Tensor()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
}
/**
* @param onnxruntime.experimental.fbs.Graph= obj
* @returns onnxruntime.experimental.fbs.Graph|null
*/
g(obj) {
let offset = this.bb.__offset(this.bb_pos, 18);
return offset ? (obj || new onnxruntime2.experimental.fbs.Graph()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
}
/**
* @param number index
* @returns number
*/
floats(index) {
let offset = this.bb.__offset(this.bb_pos, 20);
return offset ? this.bb.readFloat32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
}
/**
* @returns number
*/
floatsLength() {
let offset = this.bb.__offset(this.bb_pos, 20);
return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
}
/**
* @returns Float32Array
*/
floatsArray() {
let offset = this.bb.__offset(this.bb_pos, 20);
return offset ? new Float32Array(
this.bb.bytes().buffer,
this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset),
this.bb.__vector_len(this.bb_pos + offset)
) : null;
}
/**
* @param number index
* @returns flatbuffers.Long
*/
ints(index) {
let offset = this.bb.__offset(this.bb_pos, 22);
return offset ? this.bb.readInt64(this.bb.__vector(this.bb_pos + offset) + index * 8) : this.bb.createLong(0, 0);
}
/**
* @returns number
*/
intsLength() {
let offset = this.bb.__offset(this.bb_pos, 22);
return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
}
strings(index, optionalEncoding) {
let offset = this.bb.__offset(this.bb_pos, 24);
return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;
}
/**
* @returns number
*/
stringsLength() {
let offset = this.bb.__offset(this.bb_pos, 24);
return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
}
/**
* @param number index
* @param onnxruntime.experimental.fbs.Tensor= obj
* @returns onnxruntime.experimental.fbs.Tensor
*/
tensors(index, obj) {
let offset = this.bb.__offset(this.bb_pos, 26);
return offset ? (obj || new onnxruntime2.experimental.fbs.Tensor()).__init(
this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
this.bb
) : null;
}
/**
* @returns number
*/
tensorsLength() {
let offset = this.bb.__offset(this.bb_pos, 26);
return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
}
/**
* @param number index
* @param onnxruntime.experimental.fbs.Graph= obj
* @returns onnxruntime.experimental.fbs.Graph
*/
graphs(index, obj) {
let offset = this.bb.__offset(this.bb_pos, 28);
return offset ? (obj || new onnxruntime2.experimental.fbs.Graph()).__init(
this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
this.bb
) : null;
}
/**
* @returns number
*/
graphsLength() {
let offset = this.bb.__offset(this.bb_pos, 28);
return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
}
/**
* @param flatbuffers.Builder builder
*/
static startAttribute(builder) {
builder.startObject(13);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset nameOffset
*/
static addName(builder, nameOffset) {
builder.addFieldOffset(0, nameOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset docStringOffset
*/
static addDocString(builder, docStringOffset) {
builder.addFieldOffset(1, docStringOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param onnxruntime.experimental.fbs.AttributeType type
*/
static addType(builder, type) {
builder.addFieldInt32(2, type, 0 /* UNDEFINED */);
}
/**
* @param flatbuffers.Builder builder
* @param number f
*/
static addF(builder, f) {
builder.addFieldFloat32(3, f, 0);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Long i
*/
static addI(builder, i) {
builder.addFieldInt64(4, i, builder.createLong(0, 0));
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset sOffset
*/
static addS(builder, sOffset) {
builder.addFieldOffset(5, sOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset tOffset
*/
static addT(builder, tOffset) {
builder.addFieldOffset(6, tOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset gOffset
*/
static addG(builder, gOffset) {
builder.addFieldOffset(7, gOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset floatsOffset
*/
static addFloats(builder, floatsOffset) {
builder.addFieldOffset(8, floatsOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param Array.<number> data
* @returns flatbuffers.Offset
*/
static createFloatsVector(builder, data) {
builder.startVector(4, data.length, 4);
for (let i = data.length - 1; i >= 0; i--) {
builder.addFloat32(data[i]);
}
return builder.endVector();
}
/**
* @param flatbuffers.Builder builder
* @param number numElems
*/
static startFloatsVector(builder, numElems) {
builder.startVector(4, numElems, 4);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset intsOffset
*/
static addInts(builder, intsOffset) {
builder.addFieldOffset(9, intsOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param Array.<flatbuffers.Long> data
* @returns flatbuffers.Offset
*/
static createIntsVector(builder, data) {
builder.startVector(8, data.length, 8);
for (let i = data.length - 1; i >= 0; i--) {
builder.addInt64(data[i]);
}
return builder.endVector();
}
/**
* @param flatbuffers.Builder builder
* @param number numElems
*/
static startIntsVector(builder, numElems) {
builder.startVector(8, numElems, 8);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset stringsOffset
*/
static addStrings(builder, stringsOffset) {
builder.addFieldOffset(10, stringsOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param Array.<flatbuffers.Offset> data
* @returns flatbuffers.Offset
*/
static createStringsVector(builder, data) {
builder.startVector(4, data.length, 4);
for (let i = data.length - 1; i >= 0; i--) {
builder.addOffset(data[i]);
}
return builder.endVector();
}
/**
* @param flatbuffers.Builder builder
* @param number numElems
*/
static startStringsVector(builder, numElems) {
builder.startVector(4, numElems, 4);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset tensorsOffset
*/
static addTensors(builder, tensorsOffset) {
builder.addFieldOffset(11, tensorsOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param Array.<flatbuffers.Offset> data
* @returns flatbuffers.Offset
*/
static createTensorsVector(builder, data) {
builder.startVector(4, data.length, 4);
for (let i = data.length - 1; i >= 0; i--) {
builder.addOffset(data[i]);
}
return builder.endVector();
}
/**
* @param flatbuffers.Builder builder
* @param number numElems
*/
static startTensorsVector(builder, numElems) {
builder.startVector(4, numElems, 4);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset graphsOffset
*/
static addGraphs(builder, graphsOffset) {
builder.addFieldOffset(12, graphsOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param Array.<flatbuffers.Offset> data
* @returns flatbuffers.Offset
*/
static createGraphsVector(builder, data) {
builder.startVector(4, data.length, 4);
for (let i = data.length - 1; i >= 0; i--) {
builder.addOffset(data[i]);
}
return builder.endVector();
}
/**
* @param flatbuffers.Builder builder
* @param number numElems
*/
static startGraphsVector(builder, numElems) {
builder.startVector(4, numElems, 4);
}
/**
* @param flatbuffers.Builder builder
* @returns flatbuffers.Offset
*/
static endAttribute(builder) {
let offset = builder.endObject();
return offset;
}
static createAttribute(builder, nameOffset, docStringOffset, type, f, i, sOffset, tOffset, gOffset, floatsOffset, intsOffset, stringsOffset, tensorsOffset, graphsOffset) {
Attribute2.startAttribute(builder);
Attribute2.addName(builder, nameOffset);
Attribute2.addDocString(builder, docStringOffset);
Attribute2.addType(builder, type);
Attribute2.addF(builder, f);
Attribute2.addI(builder, i);
Attribute2.addS(builder, sOffset);
Attribute2.addT(builder, tOffset);
Attribute2.addG(builder, gOffset);
Attribute2.addFloats(builder, floatsOffset);
Attribute2.addInts(builder, intsOffset);
Attribute2.addStrings(builder, stringsOffset);
Attribute2.addTensors(builder, tensorsOffset);
Attribute2.addGraphs(builder, graphsOffset);
return Attribute2.endAttribute(builder);
}
}
fbs2.Attribute = Attribute2;
})(fbs = experimental2.fbs || (experimental2.fbs = {}));
})(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
})(onnxruntime || (onnxruntime = {}));
((onnxruntime2) => {
let experimental;
((experimental2) => {
let fbs;
((fbs2) => {
class Graph2 {
constructor() {
this.bb = null;
this.bb_pos = 0;
}
/**
* @param number i
* @param flatbuffers.ByteBuffer bb
* @returns Graph
*/
__init(i, bb) {
this.bb_pos = i;
this.bb = bb;
return this;
}
/**
* @param flatbuffers.ByteBuffer bb
* @param Graph= obj
* @returns Graph
*/
static getRootAsGraph(bb, obj) {
return (obj || new Graph2()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
/**
* @param flatbuffers.ByteBuffer bb
* @param Graph= obj
* @returns Graph
*/
static getSizePrefixedRootAsGraph(bb, obj) {
bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
return (obj || new Graph2()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
/**
* @param number index
* @param onnxruntime.experimental.fbs.Tensor= obj
* @returns onnxruntime.experimental.fbs.Tensor
*/
initializers(index, obj) {
let offset = this.bb.__offset(this.bb_pos, 4);
return offset ? (obj || new onnxruntime2.experimental.fbs.Tensor()).__init(
this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
this.bb
) : null;
}
/**
* @returns number
*/
initializersLength() {
let offset = this.bb.__offset(this.bb_pos, 4);
return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
}
/**
* @param number index
* @param onnxruntime.experimental.fbs.ValueInfo= obj
* @returns onnxruntime.experimental.fbs.ValueInfo
*/
nodeArgs(index, obj) {
let offset = this.bb.__offset(this.bb_pos, 6);
return offset ? (obj || new onnxruntime2.experimental.fbs.ValueInfo()).__init(
this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
this.bb
) : null;
}
/**
* @returns number
*/
nodeArgsLength() {
let offset = this.bb.__offset(this.bb_pos, 6);
return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
}
/**
* @param number index
* @param onnxruntime.experimental.fbs.Node= obj
* @returns onnxruntime.experimental.fbs.Node
*/
nodes(index, obj) {
let offset = this.bb.__offset(this.bb_pos, 8);
return offset ? (obj || new onnxruntime2.experimental.fbs.Node()).__init(
this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
this.bb
) : null;
}
/**
* @returns number
*/
nodesLength() {
let offset = this.bb.__offset(this.bb_pos, 8);
return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
}
/**
* @returns number
*/
maxNodeIndex() {
let offset = this.bb.__offset(this.bb_pos, 10);
return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
}
/**
* @param number index
* @param onnxruntime.experimental.fbs.NodeEdge= obj
* @returns onnxruntime.experimental.fbs.NodeEdge
*/
nodeEdges(index, obj) {
let offset = this.bb.__offset(this.bb_pos, 12);
return offset ? (obj || new onnxruntime2.experimental.fbs.NodeEdge()).__init(
this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
this.bb
) : null;
}
/**
* @returns number
*/
nodeEdgesLength() {
let offset = this.bb.__offset(this.bb_pos, 12);
return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
}
inputs(index, optionalEncoding) {
let offset = this.bb.__offset(this.bb_pos, 14);
return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;
}
/**
* @returns number
*/
inputsLength() {
let offset = this.bb.__offset(this.bb_pos, 14);
return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
}
outputs(index, optionalEncoding) {
let offset = this.bb.__offset(this.bb_pos, 16);
return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;
}
/**
* @returns number
*/
outputsLength() {
let offset = this.bb.__offset(this.bb_pos, 16);
return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
}
/**
* @param number index
* @param onnxruntime.experimental.fbs.SparseTensor= obj
* @returns onnxruntime.experimental.fbs.SparseTensor
*/
sparseInitializers(index, obj) {
let offset = this.bb.__offset(this.bb_pos, 18);
return offset ? (obj || new onnxruntime2.experimental.fbs.SparseTensor()).__init(
this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
this.bb
) : null;
}
/**
* @returns number
*/
sparseInitializersLength() {
let offset = this.bb.__offset(this.bb_pos, 18);
return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
}
/**
* @param flatbuffers.Builder builder
*/
static startGraph(builder) {
builder.startObject(8);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset initializersOffset
*/
static addInitializers(builder, initializersOffset) {
builder.addFieldOffset(0, initializersOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param Array.<flatbuffers.Offset> data
* @returns flatbuffers.Offset
*/
static createInitializersVector(builder, data) {
builder.startVector(4, data.length, 4);
for (let i = data.length - 1; i >= 0; i--) {
builder.addOffset(data[i]);
}
return builder.endVector();
}
/**
* @param flatbuffers.Builder builder
* @param number numElems
*/
static startInitializersVector(builder, numElems) {
builder.startVector(4, numElems, 4);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset nodeArgsOffset
*/
static addNodeArgs(builder, nodeArgsOffset) {
builder.addFieldOffset(1, nodeArgsOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param Array.<flatbuffers.Offset> data
* @returns flatbuffers.Offset
*/
static createNodeArgsVector(builder, data) {
builder.startVector(4, data.length, 4);
for (let i = data.length - 1; i >= 0; i--) {
builder.addOffset(data[i]);
}
return builder.endVector();
}
/**
* @param flatbuffers.Builder builder
* @param number numElems
*/
static startNodeArgsVector(builder, numElems) {
builder.startVector(4, numElems, 4);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset nodesOffset
*/
static addNodes(builder, nodesOffset) {
builder.addFieldOffset(2, nodesOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param Array.<flatbuffers.Offset> data
* @returns flatbuffers.Offset
*/
static createNodesVector(builder, data) {
builder.startVector(4, data.length, 4);
for (let i = data.length - 1; i >= 0; i--) {
builder.addOffset(data[i]);
}
return builder.endVector();
}
/**
* @param flatbuffers.Builder builder
* @param number numElems
*/
static startNodesVector(builder, numElems) {
builder.startVector(4, numElems, 4);
}
/**
* @param flatbuffers.Builder builder
* @param number maxNodeIndex
*/
static addMaxNodeIndex(builder, maxNodeIndex) {
builder.addFieldInt32(3, maxNodeIndex, 0);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset nodeEdgesOffset
*/
static addNodeEdges(builder, nodeEdgesOffset) {
builder.addFieldOffset(4, nodeEdgesOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param Array.<flatbuffers.Offset> data
* @returns flatbuffers.Offset
*/
static createNodeEdgesVector(builder, data) {
builder.startVector(4, data.length, 4);
for (let i = data.length - 1; i >= 0; i--) {
builder.addOffset(data[i]);
}
return builder.endVector();
}
/**
* @param flatbuffers.Builder builder
* @param number numElems
*/
static startNodeEdgesVector(builder, numElems) {
builder.startVector(4, numElems, 4);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset inputsOffset
*/
static addInputs(builder, inputsOffset) {
builder.addFieldOffset(5, inputsOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param Array.<flatbuffers.Offset> data
* @returns flatbuffers.Offset
*/
static createInputsVector(builder, data) {
builder.startVector(4, data.length, 4);
for (let i = data.length - 1; i >= 0; i--) {
builder.addOffset(data[i]);
}
return builder.endVector();
}
/**
* @param flatbuffers.Builder builder
* @param number numElems
*/
static startInputsVector(builder, numElems) {
builder.startVector(4, numElems, 4);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset outputsOffset
*/
static addOutputs(builder, outputsOffset) {
builder.addFieldOffset(6, outputsOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param Array.<flatbuffers.Offset> data
* @returns flatbuffers.Offset
*/
static createOutputsVector(builder, data) {
builder.startVector(4, data.length, 4);
for (let i = data.length - 1; i >= 0; i--) {
builder.addOffset(data[i]);
}
return builder.endVector();
}
/**
* @param flatbuffers.Builder builder
* @param number numElems
*/
static startOutputsVector(builder, numElems) {
builder.startVector(4, numElems, 4);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset sparseInitializersOffset
*/
static addSparseInitializers(builder, sparseInitializersOffset) {
builder.addFieldOffset(7, sparseInitializersOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param Array.<flatbuffers.Offset> data
* @returns flatbuffers.Offset
*/
static createSparseInitializersVector(builder, data) {
builder.startVector(4, data.length, 4);
for (let i = data.length - 1; i >= 0; i--) {
builder.addOffset(data[i]);
}
return builder.endVector();
}
/**
* @param flatbuffers.Builder builder
* @param number numElems
*/
static startSparseInitializersVector(builder, numElems) {
builder.startVector(4, numElems, 4);
}
/**
* @param flatbuffers.Builder builder
* @returns flatbuffers.Offset
*/
static endGraph(builder) {
let offset = builder.endObject();
return offset;
}
static createGraph(builder, initializersOffset, nodeArgsOffset, nodesOffset, maxNodeIndex, nodeEdgesOffset, inputsOffset, outputsOffset, sparseInitializersOffset) {
Graph2.startGraph(builder);
Graph2.addInitializers(builder, initializersOffset);
Graph2.addNodeArgs(builder, nodeArgsOffset);
Graph2.addNodes(builder, nodesOffset);
Graph2.addMaxNodeIndex(builder, maxNodeIndex);
Graph2.addNodeEdges(builder, nodeEdgesOffset);
Graph2.addInputs(builder, inputsOffset);
Graph2.addOutputs(builder, outputsOffset);
Graph2.addSparseInitializers(builder, sparseInitializersOffset);
return Graph2.endGraph(builder);
}
}
fbs2.Graph = Graph2;
})(fbs = experimental2.fbs || (experimental2.fbs = {}));
})(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
})(onnxruntime || (onnxruntime = {}));
((onnxruntime2) => {
let experimental;
((experimental2) => {
let fbs;
((fbs2) => {
class Model2 {
constructor() {
this.bb = null;
this.bb_pos = 0;
}
/**
* @param number i
* @param flatbuffers.ByteBuffer bb
* @returns Model
*/
__init(i, bb) {
this.bb_pos = i;
this.bb = bb;
return this;
}
/**
* @param flatbuffers.ByteBuffer bb
* @param Model= obj
* @returns Model
*/
static getRootAsModel(bb, obj) {
return (obj || new Model2()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
/**
* @param flatbuffers.ByteBuffer bb
* @param Model= obj
* @returns Model
*/
static getSizePrefixedRootAsModel(bb, obj) {
bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
return (obj || new Model2()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
/**
* @returns flatbuffers.Long
*/
irVersion() {
let offset = this.bb.__offset(this.bb_pos, 4);
return offset ? this.bb.readInt64(this.bb_pos + offset) : this.bb.createLong(0, 0);
}
/**
* @param number index
* @param onnxruntime.experimental.fbs.OperatorSetId= obj
* @returns onnxruntime.experimental.fbs.OperatorSetId
*/
opsetImport(index, obj) {
let offset = this.bb.__offset(this.bb_pos, 6);
return offset ? (obj || new onnxruntime2.experimental.fbs.OperatorSetId()).__init(
this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
this.bb
) : null;
}
/**
* @returns number
*/
opsetImportLength() {
let offset = this.bb.__offset(this.bb_pos, 6);
return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
}
producerName(optionalEncoding) {
let offset = this.bb.__offset(this.bb_pos, 8);
return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
}
producerVersion(optionalEncoding) {
let offset = this.bb.__offset(this.bb_pos, 10);
return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
}
domain(optionalEncoding) {
let offset = this.bb.__offset(this.bb_pos, 12);
return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
}
/**
* @returns flatbuffers.Long
*/
modelVersion() {
let offset = this.bb.__offset(this.bb_pos, 14);
return offset ? this.bb.readInt64(this.bb_pos + offset) : this.bb.createLong(0, 0);
}
docString(optionalEncoding) {
let offset = this.bb.__offset(this.bb_pos, 16);
return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
}
/**
* @param onnxruntime.experimental.fbs.Graph= obj
* @returns onnxruntime.experimental.fbs.Graph|null
*/
graph(obj) {
let offset = this.bb.__offset(this.bb_pos, 18);
return offset ? (obj || new onnxruntime2.experimental.fbs.Graph()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
}
graphDocString(optionalEncoding) {
let offset = this.bb.__offset(this.bb_pos, 20);
return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
}
/**
* @param flatbuffers.Builder builder
*/
static startModel(builder) {
builder.startObject(9);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Long irVersion
*/
static addIrVersion(builder, irVersion) {
builder.addFieldInt64(0, irVersion, builder.createLong(0, 0));
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset opsetImportOffset
*/
static addOpsetImport(builder, opsetImportOffset) {
builder.addFieldOffset(1, opsetImportOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param Array.<flatbuffers.Offset> data
* @returns flatbuffers.Offset
*/
static createOpsetImportVector(builder, data) {
builder.startVector(4, data.length, 4);
for (let i = data.length - 1; i >= 0; i--) {
builder.addOffset(data[i]);
}
return builder.endVector();
}
/**
* @param flatbuffers.Builder builder
* @param number numElems
*/
static startOpsetImportVector(builder, numElems) {
builder.startVector(4, numElems, 4);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset producerNameOffset
*/
static addProducerName(builder, producerNameOffset) {
builder.addFieldOffset(2, producerNameOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset producerVersionOffset
*/
static addProducerVersion(builder, producerVersionOffset) {
builder.addFieldOffset(3, producerVersionOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset domainOffset
*/
static addDomain(builder, domainOffset) {
builder.addFieldOffset(4, domainOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Long modelVersion
*/
static addModelVersion(builder, modelVersion) {
builder.addFieldInt64(5, modelVersion, builder.createLong(0, 0));
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset docStringOffset
*/
static addDocString(builder, docStringOffset) {
builder.addFieldOffset(6, docStringOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset graphOffset
*/
static addGraph(builder, graphOffset) {
builder.addFieldOffset(7, graphOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset graphDocStringOffset
*/
static addGraphDocString(builder, graphDocStringOffset) {
builder.addFieldOffset(8, graphDocStringOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @returns flatbuffers.Offset
*/
static endModel(builder) {
let offset = builder.endObject();
return offset;
}
static createModel(builder, irVersion, opsetImportOffset, producerNameOffset, producerVersionOffset, domainOffset, modelVersion, docStringOffset, graphOffset, graphDocStringOffset) {
Model2.startModel(builder);
Model2.addIrVersion(builder, irVersion);
Model2.addOpsetImport(builder, opsetImportOffset);
Model2.addProducerName(builder, producerNameOffset);
Model2.addProducerVersion(builder, producerVersionOffset);
Model2.addDomain(builder, domainOffset);
Model2.addModelVersion(builder, modelVersion);
Model2.addDocString(builder, docStringOffset);
Model2.addGraph(builder, graphOffset);
Model2.addGraphDocString(builder, graphDocStringOffset);
return Model2.endModel(builder);
}
}
fbs2.Model = Model2;
})(fbs = experimental2.fbs || (experimental2.fbs = {}));
})(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
})(onnxruntime || (onnxruntime = {}));
((onnxruntime2) => {
let experimental;
((experimental2) => {
let fbs;
((fbs2) => {
class KernelCreateInfos {
constructor() {
this.bb = null;
this.bb_pos = 0;
}
/**
* @param number i
* @param flatbuffers.ByteBuffer bb
* @returns KernelCreateInfos
*/
__init(i, bb) {
this.bb_pos = i;
this.bb = bb;
return this;
}
/**
* @param flatbuffers.ByteBuffer bb
* @param KernelCreateInfos= obj
* @returns KernelCreateInfos
*/
static getRootAsKernelCreateInfos(bb, obj) {
return (obj || new KernelCreateInfos()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
/**
* @param flatbuffers.ByteBuffer bb
* @param KernelCreateInfos= obj
* @returns KernelCreateInfos
*/
static getSizePrefixedRootAsKernelCreateInfos(bb, obj) {
bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
return (obj || new KernelCreateInfos()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
/**
* @param number index
* @returns number
*/
nodeIndices(index) {
let offset = this.bb.__offset(this.bb_pos, 4);
return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
}
/**
* @returns number
*/
nodeIndicesLength() {
let offset = this.bb.__offset(this.bb_pos, 4);
return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
}
/**
* @returns Uint32Array
*/
nodeIndicesArray() {
let offset = this.bb.__offset(this.bb_pos, 4);
return offset ? new Uint32Array(
this.bb.bytes().buffer,
this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset),
this.bb.__vector_len(this.bb_pos + offset)
) : null;
}
/**
* @param number index
* @returns flatbuffers.Long
*/
kernelDefHashes(index) {
let offset = this.bb.__offset(this.bb_pos, 6);
return offset ? this.bb.readUint64(this.bb.__vector(this.bb_pos + offset) + index * 8) : this.bb.createLong(0, 0);
}
/**
* @returns number
*/
kernelDefHashesLength() {
let offset = this.bb.__offset(this.bb_pos, 6);
return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
}
/**
* @param flatbuffers.Builder builder
*/
static startKernelCreateInfos(builder) {
builder.startObject(2);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset nodeIndicesOffset
*/
static addNodeIndices(builder, nodeIndicesOffset) {
builder.addFieldOffset(0, nodeIndicesOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param Array.<number> data
* @returns flatbuffers.Offset
*/
static createNodeIndicesVector(builder, data) {
builder.startVector(4, data.length, 4);
for (let i = data.length - 1; i >= 0; i--) {
builder.addInt32(data[i]);
}
return builder.endVector();
}
/**
* @param flatbuffers.Builder builder
* @param number numElems
*/
static startNodeIndicesVector(builder, numElems) {
builder.startVector(4, numElems, 4);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset kernelDefHashesOffset
*/
static addKernelDefHashes(builder, kernelDefHashesOffset) {
builder.addFieldOffset(1, kernelDefHashesOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param Array.<flatbuffers.Long> data
* @returns flatbuffers.Offset
*/
static createKernelDefHashesVector(builder, data) {
builder.startVector(8, data.length, 8);
for (let i = data.length - 1; i >= 0; i--) {
builder.addInt64(data[i]);
}
return builder.endVector();
}
/**
* @param flatbuffers.Builder builder
* @param number numElems
*/
static startKernelDefHashesVector(builder, numElems) {
builder.startVector(8, numElems, 8);
}
/**
* @param flatbuffers.Builder builder
* @returns flatbuffers.Offset
*/
static endKernelCreateInfos(builder) {
let offset = builder.endObject();
return offset;
}
static createKernelCreateInfos(builder, nodeIndicesOffset, kernelDefHashesOffset) {
KernelCreateInfos.startKernelCreateInfos(builder);
KernelCreateInfos.addNodeIndices(builder, nodeIndicesOffset);
KernelCreateInfos.addKernelDefHashes(builder, kernelDefHashesOffset);
return KernelCreateInfos.endKernelCreateInfos(builder);
}
}
fbs2.KernelCreateInfos = KernelCreateInfos;
})(fbs = experimental2.fbs || (experimental2.fbs = {}));
})(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
})(onnxruntime || (onnxruntime = {}));
((onnxruntime2) => {
let experimental;
((experimental2) => {
let fbs;
((fbs2) => {
class SubGraphSessionState {
constructor() {
this.bb = null;
this.bb_pos = 0;
}
/**
* @param number i
* @param flatbuffers.ByteBuffer bb
* @returns SubGraphSessionState
*/
__init(i, bb) {
this.bb_pos = i;
this.bb = bb;
return this;
}
/**
* @param flatbuffers.ByteBuffer bb
* @param SubGraphSessionState= obj
* @returns SubGraphSessionState
*/
static getRootAsSubGraphSessionState(bb, obj) {
return (obj || new SubGraphSessionState()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
/**
* @param flatbuffers.ByteBuffer bb
* @param SubGraphSessionState= obj
* @returns SubGraphSessionState
*/
static getSizePrefixedRootAsSubGraphSessionState(bb, obj) {
bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
return (obj || new SubGraphSessionState()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
graphId(optionalEncoding) {
let offset = this.bb.__offset(this.bb_pos, 4);
return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
}
/**
* @param onnxruntime.experimental.fbs.SessionState= obj
* @returns onnxruntime.experimental.fbs.SessionState|null
*/
sessionState(obj) {
let offset = this.bb.__offset(this.bb_pos, 6);
return offset ? (obj || new onnxruntime2.experimental.fbs.SessionState()).__init(
this.bb.__indirect(this.bb_pos + offset),
this.bb
) : null;
}
/**
* @param flatbuffers.Builder builder
*/
static startSubGraphSessionState(builder) {
builder.startObject(2);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset graphIdOffset
*/
static addGraphId(builder, graphIdOffset) {
builder.addFieldOffset(0, graphIdOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset sessionStateOffset
*/
static addSessionState(builder, sessionStateOffset) {
builder.addFieldOffset(1, sessionStateOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @returns flatbuffers.Offset
*/
static endSubGraphSessionState(builder) {
let offset = builder.endObject();
builder.requiredField(offset, 4);
return offset;
}
static createSubGraphSessionState(builder, graphIdOffset, sessionStateOffset) {
SubGraphSessionState.startSubGraphSessionState(builder);
SubGraphSessionState.addGraphId(builder, graphIdOffset);
SubGraphSessionState.addSessionState(builder, sessionStateOffset);
return SubGraphSessionState.endSubGraphSessionState(builder);
}
}
fbs2.SubGraphSessionState = SubGraphSessionState;
})(fbs = experimental2.fbs || (experimental2.fbs = {}));
})(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
})(onnxruntime || (onnxruntime = {}));
((onnxruntime2) => {
let experimental;
((experimental2) => {
let fbs;
((fbs2) => {
class SessionState {
constructor() {
this.bb = null;
this.bb_pos = 0;
}
/**
* @param number i
* @param flatbuffers.ByteBuffer bb
* @returns SessionState
*/
__init(i, bb) {
this.bb_pos = i;
this.bb = bb;
return this;
}
/**
* @param flatbuffers.ByteBuffer bb
* @param SessionState= obj
* @returns SessionState
*/
static getRootAsSessionState(bb, obj) {
return (obj || new SessionState()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
/**
* @param flatbuffers.ByteBuffer bb
* @param SessionState= obj
* @returns SessionState
*/
static getSizePrefixedRootAsSessionState(bb, obj) {
bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
return (obj || new SessionState()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
/**
* @param onnxruntime.experimental.fbs.KernelCreateInfos= obj
* @returns onnxruntime.experimental.fbs.KernelCreateInfos|null
*/
kernels(obj) {
let offset = this.bb.__offset(this.bb_pos, 4);
return offset ? (obj || new onnxruntime2.experimental.fbs.KernelCreateInfos()).__init(
this.bb.__indirect(this.bb_pos + offset),
this.bb
) : null;
}
/**
* @param number index
* @param onnxruntime.experimental.fbs.SubGraphSessionState= obj
* @returns onnxruntime.experimental.fbs.SubGraphSessionState
*/
subGraphSessionStates(index, obj) {
let offset = this.bb.__offset(this.bb_pos, 6);
return offset ? (obj || new onnxruntime2.experimental.fbs.SubGraphSessionState()).__init(
this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
this.bb
) : null;
}
/**
* @returns number
*/
subGraphSessionStatesLength() {
let offset = this.bb.__offset(this.bb_pos, 6);
return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
}
/**
* @param flatbuffers.Builder builder
*/
static startSessionState(builder) {
builder.startObject(2);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset kernelsOffset
*/
static addKernels(builder, kernelsOffset) {
builder.addFieldOffset(0, kernelsOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset subGraphSessionStatesOffset
*/
static addSubGraphSessionStates(builder, subGraphSessionStatesOffset) {
builder.addFieldOffset(1, subGraphSessionStatesOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param Array.<flatbuffers.Offset> data
* @returns flatbuffers.Offset
*/
static createSubGraphSessionStatesVector(builder, data) {
builder.startVector(4, data.length, 4);
for (let i = data.length - 1; i >= 0; i--) {
builder.addOffset(data[i]);
}
return builder.endVector();
}
/**
* @param flatbuffers.Builder builder
* @param number numElems
*/
static startSubGraphSessionStatesVector(builder, numElems) {
builder.startVector(4, numElems, 4);
}
/**
* @param flatbuffers.Builder builder
* @returns flatbuffers.Offset
*/
static endSessionState(builder) {
let offset = builder.endObject();
return offset;
}
static createSessionState(builder, kernelsOffset, subGraphSessionStatesOffset) {
SessionState.startSessionState(builder);
SessionState.addKernels(builder, kernelsOffset);
SessionState.addSubGraphSessionStates(builder, subGraphSessionStatesOffset);
return SessionState.endSessionState(builder);
}
}
fbs2.SessionState = SessionState;
})(fbs = experimental2.fbs || (experimental2.fbs = {}));
})(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
})(onnxruntime || (onnxruntime = {}));
((onnxruntime2) => {
let experimental;
((experimental2) => {
let fbs;
((fbs2) => {
class InferenceSession7 {
constructor() {
this.bb = null;
this.bb_pos = 0;
}
/**
* @param number i
* @param flatbuffers.ByteBuffer bb
* @returns InferenceSession
*/
__init(i, bb) {
this.bb_pos = i;
this.bb = bb;
return this;
}
/**
* @param flatbuffers.ByteBuffer bb
* @param InferenceSession= obj
* @returns InferenceSession
*/
static getRootAsInferenceSession(bb, obj) {
return (obj || new InferenceSession7()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
/**
* @param flatbuffers.ByteBuffer bb
* @param InferenceSession= obj
* @returns InferenceSession
*/
static getSizePrefixedRootAsInferenceSession(bb, obj) {
bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
return (obj || new InferenceSession7()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
/**
* @param flatbuffers.ByteBuffer bb
* @returns boolean
*/
static bufferHasIdentifier(bb) {
return bb.__has_identifier("ORTM");
}
ortVersion(optionalEncoding) {
let offset = this.bb.__offset(this.bb_pos, 4);
return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
}
/**
* @param onnxruntime.experimental.fbs.Model= obj
* @returns onnxruntime.experimental.fbs.Model|null
*/
model(obj) {
let offset = this.bb.__offset(this.bb_pos, 6);
return offset ? (obj || new onnxruntime2.experimental.fbs.Model()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
}
/**
* @param onnxruntime.experimental.fbs.SessionState= obj
* @returns onnxruntime.experimental.fbs.SessionState|null
*/
sessionState(obj) {
let offset = this.bb.__offset(this.bb_pos, 8);
return offset ? (obj || new onnxruntime2.experimental.fbs.SessionState()).__init(
this.bb.__indirect(this.bb_pos + offset),
this.bb
) : null;
}
/**
* @param flatbuffers.Builder builder
*/
static startInferenceSession(builder) {
builder.startObject(3);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset ortVersionOffset
*/
static addOrtVersion(builder, ortVersionOffset) {
builder.addFieldOffset(0, ortVersionOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset modelOffset
*/
static addModel(builder, modelOffset) {
builder.addFieldOffset(1, modelOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset sessionStateOffset
*/
static addSessionState(builder, sessionStateOffset) {
builder.addFieldOffset(2, sessionStateOffset, 0);
}
/**
* @param flatbuffers.Builder builder
* @returns flatbuffers.Offset
*/
static endInferenceSession(builder) {
let offset = builder.endObject();
return offset;
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset offset
*/
static finishInferenceSessionBuffer(builder, offset) {
builder.finish(offset, "ORTM");
}
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset offset
*/
static finishSizePrefixedInferenceSessionBuffer(builder, offset) {
builder.finish(offset, "ORTM", true);
}
static createInferenceSession(builder, ortVersionOffset, modelOffset, sessionStateOffset) {
InferenceSession7.startInferenceSession(builder);
InferenceSession7.addOrtVersion(builder, ortVersionOffset);
InferenceSession7.addModel(builder, modelOffset);
InferenceSession7.addSessionState(builder, sessionStateOffset);
return InferenceSession7.endInferenceSession(builder);
}
}
fbs2.InferenceSession = InferenceSession7;
})(fbs = experimental2.fbs || (experimental2.fbs = {}));
})(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
})(onnxruntime || (onnxruntime = {}));
}
});
// web/node_modules/@protobufjs/aspromise/index.js
var require_aspromise = __commonJS({
"web/node_modules/@protobufjs/aspromise/index.js"(exports2, module2) {
"use strict";
module2.exports = asPromise;
function asPromise(fn, ctx) {
var params = new Array(arguments.length - 1), offset = 0, index = 2, pending = true;
while (index < arguments.length)
params[offset++] = arguments[index++];
return new Promise(function executor(resolve, reject) {
params[offset] = function callback(err) {
if (pending) {
pending = false;
if (err)
reject(err);
else {
var params2 = new Array(arguments.length - 1), offset2 = 0;
while (offset2 < params2.length)
params2[offset2++] = arguments[offset2];
resolve.apply(null, params2);
}
}
};
try {
fn.apply(ctx || null, params);
} catch (err) {
if (pending) {
pending = false;
reject(err);
}
}
});
}
}
});
// web/node_modules/@protobufjs/base64/index.js
var require_base64 = __commonJS({
"web/node_modules/@protobufjs/base64/index.js"(exports2) {
"use strict";
var base64 = exports2;
base64.length = function length(string) {
var p = string.length;
if (!p)
return 0;
var n = 0;
while (--p % 4 > 1 && string.charAt(p) === "=")
++n;
return Math.ceil(string.length * 3) / 4 - n;
};
var b64 = new Array(64);
var s64 = new Array(123);
for (i = 0; i < 64; )
s64[b64[i] = i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i - 59 | 43] = i++;
var i;
base64.encode = function encode(buffer, start, end) {
var parts = null, chunk = [];
var i2 = 0, j = 0, t;
while (start < end) {
var b = buffer[start++];
switch (j) {
case 0:
chunk[i2++] = b64[b >> 2];
t = (b & 3) << 4;
j = 1;
break;
case 1:
chunk[i2++] = b64[t | b >> 4];
t = (b & 15) << 2;
j = 2;
break;
case 2:
chunk[i2++] = b64[t | b >> 6];
chunk[i2++] = b64[b & 63];
j = 0;
break;
}
if (i2 > 8191) {
(parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
i2 = 0;
}
}
if (j) {
chunk[i2++] = b64[t];
chunk[i2++] = 61;
if (j === 1)
chunk[i2++] = 61;
}
if (parts) {
if (i2)
parts.push(String.fromCharCode.apply(String, chunk.slice(0, i2)));
return parts.join("");
}
return String.fromCharCode.apply(String, chunk.slice(0, i2));
};
var invalidEncoding = "invalid encoding";
base64.decode = function decode(string, buffer, offset) {
var start = offset;
var j = 0, t;
for (var i2 = 0; i2 < string.length; ) {
var c = string.charCodeAt(i2++);
if (c === 61 && j > 1)
break;
if ((c = s64[c]) === void 0)
throw Error(invalidEncoding);
switch (j) {
case 0:
t = c;
j = 1;
break;
case 1:
buffer[offset++] = t << 2 | (c & 48) >> 4;
t = c;
j = 2;
break;
case 2:
buffer[offset++] = (t & 15) << 4 | (c & 60) >> 2;
t = c;
j = 3;
break;
case 3:
buffer[offset++] = (t & 3) << 6 | c;
j = 0;
break;
}
}
if (j === 1)
throw Error(invalidEncoding);
return offset - start;
};
base64.test = function test(string) {
return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(string);
};
}
});
// web/node_modules/@protobufjs/eventemitter/index.js
var require_eventemitter = __commonJS({
"web/node_modules/@protobufjs/eventemitter/index.js"(exports2, module2) {
"use strict";
module2.exports = EventEmitter;
function EventEmitter() {
this._listeners = {};
}
EventEmitter.prototype.on = function on(evt, fn, ctx) {
(this._listeners[evt] || (this._listeners[evt] = [])).push({
fn,
ctx: ctx || this
});
return this;
};
EventEmitter.prototype.off = function off(evt, fn) {
if (evt === void 0)
this._listeners = {};
else {
if (fn === void 0)
this._listeners[evt] = [];
else {
var listeners = this._listeners[evt];
for (var i = 0; i < listeners.length; )
if (listeners[i].fn === fn)
listeners.splice(i, 1);
else
++i;
}
}
return this;
};
EventEmitter.prototype.emit = function emit(evt) {
var listeners = this._listeners[evt];
if (listeners) {
var args = [], i = 1;
for (; i < arguments.length; )
args.push(arguments[i++]);
for (i = 0; i < listeners.length; )
listeners[i].fn.apply(listeners[i++].ctx, args);
}
return this;
};
}
});
// web/node_modules/@protobufjs/float/index.js
var require_float = __commonJS({
"web/node_modules/@protobufjs/float/index.js"(exports2, module2) {
"use strict";
module2.exports = factory(factory);
function factory(exports3) {
if (typeof Float32Array !== "undefined")
(function() {
var f32 = new Float32Array([-0]), f8b = new Uint8Array(f32.buffer), le = f8b[3] === 128;
function writeFloat_f32_cpy(val, buf, pos) {
f32[0] = val;
buf[pos] = f8b[0];
buf[pos + 1] = f8b[1];
buf[pos + 2] = f8b[2];
buf[pos + 3] = f8b[3];
}
function writeFloat_f32_rev(val, buf, pos) {
f32[0] = val;
buf[pos] = f8b[3];
buf[pos + 1] = f8b[2];
buf[pos + 2] = f8b[1];
buf[pos + 3] = f8b[0];
}
exports3.writeFloatLE = le ? writeFloat_f32_cpy : writeFloat_f32_rev;
exports3.writeFloatBE = le ? writeFloat_f32_rev : writeFloat_f32_cpy;
function readFloat_f32_cpy(buf, pos) {
f8b[0] = buf[pos];
f8b[1] = buf[pos + 1];
f8b[2] = buf[pos + 2];
f8b[3] = buf[pos + 3];
return f32[0];
}
function readFloat_f32_rev(buf, pos) {
f8b[3] = buf[pos];
f8b[2] = buf[pos + 1];
f8b[1] = buf[pos + 2];
f8b[0] = buf[pos + 3];
return f32[0];
}
exports3.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev;
exports3.readFloatBE = le ? readFloat_f32_rev : readFloat_f32_cpy;
})();
else
(function() {
function writeFloat_ieee754(writeUint, val, buf, pos) {
var sign = val < 0 ? 1 : 0;
if (sign)
val = -val;
if (val === 0)
writeUint(1 / val > 0 ? (
/* positive */
0
) : (
/* negative 0 */
2147483648
), buf, pos);
else if (isNaN(val))
writeUint(2143289344, buf, pos);
else if (val > 34028234663852886e22)
writeUint((sign << 31 | 2139095040) >>> 0, buf, pos);
else if (val < 11754943508222875e-54)
writeUint((sign << 31 | Math.round(val / 1401298464324817e-60)) >>> 0, buf, pos);
else {
var exponent = Math.floor(Math.log(val) / Math.LN2), mantissa = Math.round(val * Math.pow(2, -exponent) * 8388608) & 8388607;
writeUint((sign << 31 | exponent + 127 << 23 | mantissa) >>> 0, buf, pos);
}
}
exports3.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);
exports3.writeFloatBE = writeFloat_ieee754.bind(null, writeUintBE);
function readFloat_ieee754(readUint, buf, pos) {
var uint = readUint(buf, pos), sign = (uint >> 31) * 2 + 1, exponent = uint >>> 23 & 255, mantissa = uint & 8388607;
return exponent === 255 ? mantissa ? NaN : sign * Infinity : exponent === 0 ? sign * 1401298464324817e-60 * mantissa : sign * Math.pow(2, exponent - 150) * (mantissa + 8388608);
}
exports3.readFloatLE = readFloat_ieee754.bind(null, readUintLE);
exports3.readFloatBE = readFloat_ieee754.bind(null, readUintBE);
})();
if (typeof Float64Array !== "undefined")
(function() {
var f64 = new Float64Array([-0]), f8b = new Uint8Array(f64.buffer), le = f8b[7] === 128;
function writeDouble_f64_cpy(val, buf, pos) {
f64[0] = val;
buf[pos] = f8b[0];
buf[pos + 1] = f8b[1];
buf[pos + 2] = f8b[2];
buf[pos + 3] = f8b[3];
buf[pos + 4] = f8b[4];
buf[pos + 5] = f8b[5];
buf[pos + 6] = f8b[6];
buf[pos + 7] = f8b[7];
}
function writeDouble_f64_rev(val, buf, pos) {
f64[0] = val;
buf[pos] = f8b[7];
buf[pos + 1] = f8b[6];
buf[pos + 2] = f8b[5];
buf[pos + 3] = f8b[4];
buf[pos + 4] = f8b[3];
buf[pos + 5] = f8b[2];
buf[pos + 6] = f8b[1];
buf[pos + 7] = f8b[0];
}
exports3.writeDoubleLE = le ? writeDouble_f64_cpy : writeDouble_f64_rev;
exports3.writeDoubleBE = le ? writeDouble_f64_rev : writeDouble_f64_cpy;
function readDouble_f64_cpy(buf, pos) {
f8b[0] = buf[pos];
f8b[1] = buf[pos + 1];
f8b[2] = buf[pos + 2];
f8b[3] = buf[pos + 3];
f8b[4] = buf[pos + 4];
f8b[5] = buf[pos + 5];
f8b[6] = buf[pos + 6];
f8b[7] = buf[pos + 7];
return f64[0];
}
function readDouble_f64_rev(buf, pos) {
f8b[7] = buf[pos];
f8b[6] = buf[pos + 1];
f8b[5] = buf[pos + 2];
f8b[4] = buf[pos + 3];
f8b[3] = buf[pos + 4];
f8b[2] = buf[pos + 5];
f8b[1] = buf[pos + 6];
f8b[0] = buf[pos + 7];
return f64[0];
}
exports3.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;
exports3.readDoubleBE = le ? readDouble_f64_rev : readDouble_f64_cpy;
})();
else
(function() {
function writeDouble_ieee754(writeUint, off0, off1, val, buf, pos) {
var sign = val < 0 ? 1 : 0;
if (sign)
val = -val;
if (val === 0) {
writeUint(0, buf, pos + off0);
writeUint(1 / val > 0 ? (
/* positive */
0
) : (
/* negative 0 */
2147483648
), buf, pos + off1);
} else if (isNaN(val)) {
writeUint(0, buf, pos + off0);
writeUint(2146959360, buf, pos + off1);
} else if (val > 17976931348623157e292) {
writeUint(0, buf, pos + off0);
writeUint((sign << 31 | 2146435072) >>> 0, buf, pos + off1);
} else {
var mantissa;
if (val < 22250738585072014e-324) {
mantissa = val / 5e-324;
writeUint(mantissa >>> 0, buf, pos + off0);
writeUint((sign << 31 | mantissa / 4294967296) >>> 0, buf, pos + off1);
} else {
var exponent = Math.floor(Math.log(val) / Math.LN2);
if (exponent === 1024)
exponent = 1023;
mantissa = val * Math.pow(2, -exponent);
writeUint(mantissa * 4503599627370496 >>> 0, buf, pos + off0);
writeUint((sign << 31 | exponent + 1023 << 20 | mantissa * 1048576 & 1048575) >>> 0, buf, pos + off1);
}
}
}
exports3.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);
exports3.writeDoubleBE = writeDouble_ieee754.bind(null, writeUintBE, 4, 0);
function readDouble_ieee754(readUint, off0, off1, buf, pos) {
var lo = readUint(buf, pos + off0), hi = readUint(buf, pos + off1);
var sign = (hi >> 31) * 2 + 1, exponent = hi >>> 20 & 2047, mantissa = 4294967296 * (hi & 1048575) + lo;
return exponent === 2047 ? mantissa ? NaN : sign * Infinity : exponent === 0 ? sign * 5e-324 * mantissa : sign * Math.pow(2, exponent - 1075) * (mantissa + 4503599627370496);
}
exports3.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4);
exports3.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 4, 0);
})();
return exports3;
}
function writeUintLE(val, buf, pos) {
buf[pos] = val & 255;
buf[pos + 1] = val >>> 8 & 255;
buf[pos + 2] = val >>> 16 & 255;
buf[pos + 3] = val >>> 24;
}
function writeUintBE(val, buf, pos) {
buf[pos] = val >>> 24;
buf[pos + 1] = val >>> 16 & 255;
buf[pos + 2] = val >>> 8 & 255;
buf[pos + 3] = val & 255;
}
function readUintLE(buf, pos) {
return (buf[pos] | buf[pos + 1] << 8 | buf[pos + 2] << 16 | buf[pos + 3] << 24) >>> 0;
}
function readUintBE(buf, pos) {
return (buf[pos] << 24 | buf[pos + 1] << 16 | buf[pos + 2] << 8 | buf[pos + 3]) >>> 0;
}
}
});
// web/node_modules/@protobufjs/inquire/index.js
var require_inquire = __commonJS({
"web/node_modules/@protobufjs/inquire/index.js"(exports, module) {
"use strict";
module.exports = inquire;
function inquire(moduleName) {
try {
var mod = eval("quire".replace(/^/, "re"))(moduleName);
if (mod && (mod.length || Object.keys(mod).length))
return mod;
} catch (e) {
}
return null;
}
}
});
// web/node_modules/@protobufjs/utf8/index.js
var require_utf8 = __commonJS({
"web/node_modules/@protobufjs/utf8/index.js"(exports2) {
"use strict";
var utf8 = exports2;
utf8.length = function utf8_length(string) {
var len = 0, c = 0;
for (var i = 0; i < string.length; ++i) {
c = string.charCodeAt(i);
if (c < 128)
len += 1;
else if (c < 2048)
len += 2;
else if ((c & 64512) === 55296 && (string.charCodeAt(i + 1) & 64512) === 56320) {
++i;
len += 4;
} else
len += 3;
}
return len;
};
utf8.read = function utf8_read(buffer, start, end) {
var len = end - start;
if (len < 1)
return "";
var parts = null, chunk = [], i = 0, t;
while (start < end) {
t = buffer[start++];
if (t < 128)
chunk[i++] = t;
else if (t > 191 && t < 224)
chunk[i++] = (t & 31) << 6 | buffer[start++] & 63;
else if (t > 239 && t < 365) {
t = ((t & 7) << 18 | (buffer[start++] & 63) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63) - 65536;
chunk[i++] = 55296 + (t >> 10);
chunk[i++] = 56320 + (t & 1023);
} else
chunk[i++] = (t & 15) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63;
if (i > 8191) {
(parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
i = 0;
}
}
if (parts) {
if (i)
parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
return parts.join("");
}
return String.fromCharCode.apply(String, chunk.slice(0, i));
};
utf8.write = function utf8_write(string, buffer, offset) {
var start = offset, c1, c2;
for (var i = 0; i < string.length; ++i) {
c1 = string.charCodeAt(i);
if (c1 < 128) {
buffer[offset++] = c1;
} else if (c1 < 2048) {
buffer[offset++] = c1 >> 6 | 192;
buffer[offset++] = c1 & 63 | 128;
} else if ((c1 & 64512) === 55296 && ((c2 = string.charCodeAt(i + 1)) & 64512) === 56320) {
c1 = 65536 + ((c1 & 1023) << 10) + (c2 & 1023);
++i;
buffer[offset++] = c1 >> 18 | 240;
buffer[offset++] = c1 >> 12 & 63 | 128;
buffer[offset++] = c1 >> 6 & 63 | 128;
buffer[offset++] = c1 & 63 | 128;
} else {
buffer[offset++] = c1 >> 12 | 224;
buffer[offset++] = c1 >> 6 & 63 | 128;
buffer[offset++] = c1 & 63 | 128;
}
}
return offset - start;
};
}
});
// web/node_modules/@protobufjs/pool/index.js
var require_pool = __commonJS({
"web/node_modules/@protobufjs/pool/index.js"(exports2, module2) {
"use strict";
module2.exports = pool;
function pool(alloc, slice2, size) {
var SIZE = size || 8192;
var MAX = SIZE >>> 1;
var slab = null;
var offset = SIZE;
return function pool_alloc(size2) {
if (size2 < 1 || size2 > MAX)
return alloc(size2);
if (offset + size2 > SIZE) {
slab = alloc(SIZE);
offset = 0;
}
var buf = slice2.call(slab, offset, offset += size2);
if (offset & 7)
offset = (offset | 7) + 1;
return buf;
};
}
}
});
// web/node_modules/protobufjs/src/util/longbits.js
var require_longbits = __commonJS({
"web/node_modules/protobufjs/src/util/longbits.js"(exports2, module2) {
"use strict";
module2.exports = LongBits;
var util = require_minimal();
function LongBits(lo, hi) {
this.lo = lo >>> 0;
this.hi = hi >>> 0;
}
var zero = LongBits.zero = new LongBits(0, 0);
zero.toNumber = function() {
return 0;
};
zero.zzEncode = zero.zzDecode = function() {
return this;
};
zero.length = function() {
return 1;
};
var zeroHash = LongBits.zeroHash = "\0\0\0\0\0\0\0\0";
LongBits.fromNumber = function fromNumber2(value) {
if (value === 0)
return zero;
var sign = value < 0;
if (sign)
value = -value;
var lo = value >>> 0, hi = (value - lo) / 4294967296 >>> 0;
if (sign) {
hi = ~hi >>> 0;
lo = ~lo >>> 0;
if (++lo > 4294967295) {
lo = 0;
if (++hi > 4294967295)
hi = 0;
}
}
return new LongBits(lo, hi);
};
LongBits.from = function from(value) {
if (typeof value === "number")
return LongBits.fromNumber(value);
if (util.isString(value)) {
if (util.Long)
value = util.Long.fromString(value);
else
return LongBits.fromNumber(parseInt(value, 10));
}
return value.low || value.high ? new LongBits(value.low >>> 0, value.high >>> 0) : zero;
};
LongBits.prototype.toNumber = function toNumber2(unsigned) {
if (!unsigned && this.hi >>> 31) {
var lo = ~this.lo + 1 >>> 0, hi = ~this.hi >>> 0;
if (!lo)
hi = hi + 1 >>> 0;
return -(lo + hi * 4294967296);
}
return this.lo + this.hi * 4294967296;
};
LongBits.prototype.toLong = function toLong(unsigned) {
return util.Long ? new util.Long(this.lo | 0, this.hi | 0, Boolean(unsigned)) : { low: this.lo | 0, high: this.hi | 0, unsigned: Boolean(unsigned) };
};
var charCodeAt = String.prototype.charCodeAt;
LongBits.fromHash = function fromHash(hash) {
if (hash === zeroHash)
return zero;
return new LongBits(
(charCodeAt.call(hash, 0) | charCodeAt.call(hash, 1) << 8 | charCodeAt.call(hash, 2) << 16 | charCodeAt.call(hash, 3) << 24) >>> 0,
(charCodeAt.call(hash, 4) | charCodeAt.call(hash, 5) << 8 | charCodeAt.call(hash, 6) << 16 | charCodeAt.call(hash, 7) << 24) >>> 0
);
};
LongBits.prototype.toHash = function toHash() {
return String.fromCharCode(
this.lo & 255,
this.lo >>> 8 & 255,
this.lo >>> 16 & 255,
this.lo >>> 24,
this.hi & 255,
this.hi >>> 8 & 255,
this.hi >>> 16 & 255,
this.hi >>> 24
);
};
LongBits.prototype.zzEncode = function zzEncode() {
var mask = this.hi >> 31;
this.hi = ((this.hi << 1 | this.lo >>> 31) ^ mask) >>> 0;
this.lo = (this.lo << 1 ^ mask) >>> 0;
return this;
};
LongBits.prototype.zzDecode = function zzDecode() {
var mask = -(this.lo & 1);
this.lo = ((this.lo >>> 1 | this.hi << 31) ^ mask) >>> 0;
this.hi = (this.hi >>> 1 ^ mask) >>> 0;
return this;
};
LongBits.prototype.length = function length() {
var part0 = this.lo, part1 = (this.lo >>> 28 | this.hi << 4) >>> 0, part2 = this.hi >>> 24;
return part2 === 0 ? part1 === 0 ? part0 < 16384 ? part0 < 128 ? 1 : 2 : part0 < 2097152 ? 3 : 4 : part1 < 16384 ? part1 < 128 ? 5 : 6 : part1 < 2097152 ? 7 : 8 : part2 < 128 ? 9 : 10;
};
}
});
// web/node_modules/protobufjs/src/util/minimal.js
var require_minimal = __commonJS({
"web/node_modules/protobufjs/src/util/minimal.js"(exports2) {
"use strict";
var util = exports2;
util.asPromise = require_aspromise();
util.base64 = require_base64();
util.EventEmitter = require_eventemitter();
util.float = require_float();
util.inquire = require_inquire();
util.utf8 = require_utf8();
util.pool = require_pool();
util.LongBits = require_longbits();
util.isNode = Boolean(typeof global !== "undefined" && global && global.process && global.process.versions && global.process.versions.node);
util.global = util.isNode && global || typeof window !== "undefined" && window || typeof self !== "undefined" && self || exports2;
util.emptyArray = Object.freeze ? Object.freeze([]) : (
/* istanbul ignore next */
[]
);
util.emptyObject = Object.freeze ? Object.freeze({}) : (
/* istanbul ignore next */
{}
);
util.isInteger = Number.isInteger || /* istanbul ignore next */
function isInteger(value) {
return typeof value === "number" && isFinite(value) && Math.floor(value) === value;
};
util.isString = function isString(value) {
return typeof value === "string" || value instanceof String;
};
util.isObject = function isObject(value) {
return value && typeof value === "object";
};
util.isset = /**
* Checks if a property on a message is considered to be present.
* @param {Object} obj Plain object or message instance
* @param {string} prop Property name
* @returns {boolean} `true` if considered to be present, otherwise `false`
*/
util.isSet = function isSet(obj, prop) {
var value = obj[prop];
if (value != null && obj.hasOwnProperty(prop))
return typeof value !== "object" || (Array.isArray(value) ? value.length : Object.keys(value).length) > 0;
return false;
};
util.Buffer = function() {
try {
var Buffer2 = util.inquire("buffer").Buffer;
return Buffer2.prototype.utf8Write ? Buffer2 : (
/* istanbul ignore next */
null
);
} catch (e) {
return null;
}
}();
util._Buffer_from = null;
util._Buffer_allocUnsafe = null;
util.newBuffer = function newBuffer(sizeOrArray) {
return typeof sizeOrArray === "number" ? util.Buffer ? util._Buffer_allocUnsafe(sizeOrArray) : new util.Array(sizeOrArray) : util.Buffer ? util._Buffer_from(sizeOrArray) : typeof Uint8Array === "undefined" ? sizeOrArray : new Uint8Array(sizeOrArray);
};
util.Array = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
util.Long = /* istanbul ignore next */
util.global.dcodeIO && /* istanbul ignore next */
util.global.dcodeIO.Long || /* istanbul ignore next */
util.global.Long || util.inquire("long");
util.key2Re = /^true|false|0|1$/;
util.key32Re = /^-?(?:0|[1-9][0-9]*)$/;
util.key64Re = /^(?:[\\x00-\\xff]{8}|-?(?:0|[1-9][0-9]*))$/;
util.longToHash = function longToHash(value) {
return value ? util.LongBits.from(value).toHash() : util.LongBits.zeroHash;
};
util.longFromHash = function longFromHash(hash, unsigned) {
var bits = util.LongBits.fromHash(hash);
if (util.Long)
return util.Long.fromBits(bits.lo, bits.hi, unsigned);
return bits.toNumber(Boolean(unsigned));
};
function merge(dst, src, ifNotSet) {
for (var keys = Object.keys(src), i = 0; i < keys.length; ++i)
if (dst[keys[i]] === void 0 || !ifNotSet)
dst[keys[i]] = src[keys[i]];
return dst;
}
util.merge = merge;
util.lcFirst = function lcFirst(str) {
return str.charAt(0).toLowerCase() + str.substring(1);
};
function newError(name2) {
function CustomError(message, properties) {
if (!(this instanceof CustomError))
return new CustomError(message, properties);
Object.defineProperty(this, "message", { get: function() {
return message;
} });
if (Error.captureStackTrace)
Error.captureStackTrace(this, CustomError);
else
Object.defineProperty(this, "stack", { value: new Error().stack || "" });
if (properties)
merge(this, properties);
}
CustomError.prototype = Object.create(Error.prototype, {
constructor: {
value: CustomError,
writable: true,
enumerable: false,
configurable: true
},
name: {
get: function get() {
return name2;
},
set: void 0,
enumerable: false,
// configurable: false would accurately preserve the behavior of
// the original, but I'm guessing that was not intentional.
// For an actual error subclass, this property would
// be configurable.
configurable: true
},
toString: {
value: function value() {
return this.name + ": " + this.message;
},
writable: true,
enumerable: false,
configurable: true
}
});
return CustomError;
}
util.newError = newError;
util.ProtocolError = newError("ProtocolError");
util.oneOfGetter = function getOneOf(fieldNames) {
var fieldMap = {};
for (var i = 0; i < fieldNames.length; ++i)
fieldMap[fieldNames[i]] = 1;
return function() {
for (var keys = Object.keys(this), i2 = keys.length - 1; i2 > -1; --i2)
if (fieldMap[keys[i2]] === 1 && this[keys[i2]] !== void 0 && this[keys[i2]] !== null)
return keys[i2];
};
};
util.oneOfSetter = function setOneOf(fieldNames) {
return function(name2) {
for (var i = 0; i < fieldNames.length; ++i)
if (fieldNames[i] !== name2)
delete this[fieldNames[i]];
};
};
util.toJSONOptions = {
longs: String,
enums: String,
bytes: String,
json: true
};
util._configure = function() {
var Buffer2 = util.Buffer;
if (!Buffer2) {
util._Buffer_from = util._Buffer_allocUnsafe = null;
return;
}
util._Buffer_from = Buffer2.from !== Uint8Array.from && Buffer2.from || /* istanbul ignore next */
function Buffer_from(value, encoding) {
return new Buffer2(value, encoding);
};
util._Buffer_allocUnsafe = Buffer2.allocUnsafe || /* istanbul ignore next */
function Buffer_allocUnsafe(size) {
return new Buffer2(size);
};
};
}
});
// web/node_modules/protobufjs/src/writer.js
var require_writer = __commonJS({
"web/node_modules/protobufjs/src/writer.js"(exports2, module2) {
"use strict";
module2.exports = Writer;
var util = require_minimal();
var BufferWriter;
var LongBits = util.LongBits;
var base64 = util.base64;
var utf8 = util.utf8;
function Op(fn, len, val) {
this.fn = fn;
this.len = len;
this.next = void 0;
this.val = val;
}
function noop() {
}
function State(writer) {
this.head = writer.head;
this.tail = writer.tail;
this.len = writer.len;
this.next = writer.states;
}
function Writer() {
this.len = 0;
this.head = new Op(noop, 0, 0);
this.tail = this.head;
this.states = null;
}
var create = function create2() {
return util.Buffer ? function create_buffer_setup() {
return (Writer.create = function create_buffer() {
return new BufferWriter();
})();
} : function create_array() {
return new Writer();
};
};
Writer.create = create();
Writer.alloc = function alloc(size) {
return new util.Array(size);
};
if (util.Array !== Array)
Writer.alloc = util.pool(Writer.alloc, util.Array.prototype.subarray);
Writer.prototype._push = function push(fn, len, val) {
this.tail = this.tail.next = new Op(fn, len, val);
this.len += len;
return this;
};
function writeByte(val, buf, pos) {
buf[pos] = val & 255;
}
function writeVarint32(val, buf, pos) {
while (val > 127) {
buf[pos++] = val & 127 | 128;
val >>>= 7;
}
buf[pos] = val;
}
function VarintOp(len, val) {
this.len = len;
this.next = void 0;
this.val = val;
}
VarintOp.prototype = Object.create(Op.prototype);
VarintOp.prototype.fn = writeVarint32;
Writer.prototype.uint32 = function write_uint32(value) {
this.len += (this.tail = this.tail.next = new VarintOp(
(value = value >>> 0) < 128 ? 1 : value < 16384 ? 2 : value < 2097152 ? 3 : value < 268435456 ? 4 : 5,
value
)).len;
return this;
};
Writer.prototype.int32 = function write_int32(value) {
return value < 0 ? this._push(writeVarint64, 10, LongBits.fromNumber(value)) : this.uint32(value);
};
Writer.prototype.sint32 = function write_sint32(value) {
return this.uint32((value << 1 ^ value >> 31) >>> 0);
};
function writeVarint64(val, buf, pos) {
while (val.hi) {
buf[pos++] = val.lo & 127 | 128;
val.lo = (val.lo >>> 7 | val.hi << 25) >>> 0;
val.hi >>>= 7;
}
while (val.lo > 127) {
buf[pos++] = val.lo & 127 | 128;
val.lo = val.lo >>> 7;
}
buf[pos++] = val.lo;
}
Writer.prototype.uint64 = function write_uint64(value) {
var bits = LongBits.from(value);
return this._push(writeVarint64, bits.length(), bits);
};
Writer.prototype.int64 = Writer.prototype.uint64;
Writer.prototype.sint64 = function write_sint64(value) {
var bits = LongBits.from(value).zzEncode();
return this._push(writeVarint64, bits.length(), bits);
};
Writer.prototype.bool = function write_bool(value) {
return this._push(writeByte, 1, value ? 1 : 0);
};
function writeFixed32(val, buf, pos) {
buf[pos] = val & 255;
buf[pos + 1] = val >>> 8 & 255;
buf[pos + 2] = val >>> 16 & 255;
buf[pos + 3] = val >>> 24;
}
Writer.prototype.fixed32 = function write_fixed32(value) {
return this._push(writeFixed32, 4, value >>> 0);
};
Writer.prototype.sfixed32 = Writer.prototype.fixed32;
Writer.prototype.fixed64 = function write_fixed64(value) {
var bits = LongBits.from(value);
return this._push(writeFixed32, 4, bits.lo)._push(writeFixed32, 4, bits.hi);
};
Writer.prototype.sfixed64 = Writer.prototype.fixed64;
Writer.prototype.float = function write_float(value) {
return this._push(util.float.writeFloatLE, 4, value);
};
Writer.prototype.double = function write_double(value) {
return this._push(util.float.writeDoubleLE, 8, value);
};
var writeBytes = util.Array.prototype.set ? function writeBytes_set(val, buf, pos) {
buf.set(val, pos);
} : function writeBytes_for(val, buf, pos) {
for (var i = 0; i < val.length; ++i)
buf[pos + i] = val[i];
};
Writer.prototype.bytes = function write_bytes(value) {
var len = value.length >>> 0;
if (!len)
return this._push(writeByte, 1, 0);
if (util.isString(value)) {
var buf = Writer.alloc(len = base64.length(value));
base64.decode(value, buf, 0);
value = buf;
}
return this.uint32(len)._push(writeBytes, len, value);
};
Writer.prototype.string = function write_string(value) {
var len = utf8.length(value);
return len ? this.uint32(len)._push(utf8.write, len, value) : this._push(writeByte, 1, 0);
};
Writer.prototype.fork = function fork() {
this.states = new State(this);
this.head = this.tail = new Op(noop, 0, 0);
this.len = 0;
return this;
};
Writer.prototype.reset = function reset() {
if (this.states) {
this.head = this.states.head;
this.tail = this.states.tail;
this.len = this.states.len;
this.states = this.states.next;
} else {
this.head = this.tail = new Op(noop, 0, 0);
this.len = 0;
}
return this;
};
Writer.prototype.ldelim = function ldelim() {
var head = this.head, tail = this.tail, len = this.len;
this.reset().uint32(len);
if (len) {
this.tail.next = head.next;
this.tail = tail;
this.len += len;
}
return this;
};
Writer.prototype.finish = function finish() {
var head = this.head.next, buf = this.constructor.alloc(this.len), pos = 0;
while (head) {
head.fn(head.val, buf, pos);
pos += head.len;
head = head.next;
}
return buf;
};
Writer._configure = function(BufferWriter_) {
BufferWriter = BufferWriter_;
Writer.create = create();
BufferWriter._configure();
};
}
});
// web/node_modules/protobufjs/src/writer_buffer.js
var require_writer_buffer = __commonJS({
"web/node_modules/protobufjs/src/writer_buffer.js"(exports2, module2) {
"use strict";
module2.exports = BufferWriter;
var Writer = require_writer();
(BufferWriter.prototype = Object.create(Writer.prototype)).constructor = BufferWriter;
var util = require_minimal();
function BufferWriter() {
Writer.call(this);
}
BufferWriter._configure = function() {
BufferWriter.alloc = util._Buffer_allocUnsafe;
BufferWriter.writeBytesBuffer = util.Buffer && util.Buffer.prototype instanceof Uint8Array && util.Buffer.prototype.set.name === "set" ? function writeBytesBuffer_set(val, buf, pos) {
buf.set(val, pos);
} : function writeBytesBuffer_copy(val, buf, pos) {
if (val.copy)
val.copy(buf, pos, 0, val.length);
else
for (var i = 0; i < val.length; )
buf[pos++] = val[i++];
};
};
BufferWriter.prototype.bytes = function write_bytes_buffer(value) {
if (util.isString(value))
value = util._Buffer_from(value, "base64");
var len = value.length >>> 0;
this.uint32(len);
if (len)
this._push(BufferWriter.writeBytesBuffer, len, value);
return this;
};
function writeStringBuffer(val, buf, pos) {
if (val.length < 40)
util.utf8.write(val, buf, pos);
else if (buf.utf8Write)
buf.utf8Write(val, pos);
else
buf.write(val, pos);
}
BufferWriter.prototype.string = function write_string_buffer(value) {
var len = util.Buffer.byteLength(value);
this.uint32(len);
if (len)
this._push(writeStringBuffer, len, value);
return this;
};
BufferWriter._configure();
}
});
// web/node_modules/protobufjs/src/reader.js
var require_reader = __commonJS({
"web/node_modules/protobufjs/src/reader.js"(exports2, module2) {
"use strict";
module2.exports = Reader;
var util = require_minimal();
var BufferReader;
var LongBits = util.LongBits;
var utf8 = util.utf8;
function indexOutOfRange(reader, writeLength) {
return RangeError("index out of range: " + reader.pos + " + " + (writeLength || 1) + " > " + reader.len);
}
function Reader(buffer) {
this.buf = buffer;
this.pos = 0;
this.len = buffer.length;
}
var create_array = typeof Uint8Array !== "undefined" ? function create_typed_array(buffer) {
if (buffer instanceof Uint8Array || Array.isArray(buffer))
return new Reader(buffer);
throw Error("illegal buffer");
} : function create_array2(buffer) {
if (Array.isArray(buffer))
return new Reader(buffer);
throw Error("illegal buffer");
};
var create = function create2() {
return util.Buffer ? function create_buffer_setup(buffer) {
return (Reader.create = function create_buffer(buffer2) {
return util.Buffer.isBuffer(buffer2) ? new BufferReader(buffer2) : create_array(buffer2);
})(buffer);
} : create_array;
};
Reader.create = create();
Reader.prototype._slice = util.Array.prototype.subarray || /* istanbul ignore next */
util.Array.prototype.slice;
Reader.prototype.uint32 = function read_uint32_setup() {
var value = 4294967295;
return function read_uint32() {
value = (this.buf[this.pos] & 127) >>> 0;
if (this.buf[this.pos++] < 128)
return value;
value = (value | (this.buf[this.pos] & 127) << 7) >>> 0;
if (this.buf[this.pos++] < 128)
return value;
value = (value | (this.buf[this.pos] & 127) << 14) >>> 0;
if (this.buf[this.pos++] < 128)
return value;
value = (value | (this.buf[this.pos] & 127) << 21) >>> 0;
if (this.buf[this.pos++] < 128)
return value;
value = (value | (this.buf[this.pos] & 15) << 28) >>> 0;
if (this.buf[this.pos++] < 128)
return value;
if ((this.pos += 5) > this.len) {
this.pos = this.len;
throw indexOutOfRange(this, 10);
}
return value;
};
}();
Reader.prototype.int32 = function read_int32() {
return this.uint32() | 0;
};
Reader.prototype.sint32 = function read_sint32() {
var value = this.uint32();
return value >>> 1 ^ -(value & 1) | 0;
};
function readLongVarint() {
var bits = new LongBits(0, 0);
var i = 0;
if (this.len - this.pos > 4) {
for (; i < 4; ++i) {
bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;
if (this.buf[this.pos++] < 128)
return bits;
}
bits.lo = (bits.lo | (this.buf[this.pos] & 127) << 28) >>> 0;
bits.hi = (bits.hi | (this.buf[this.pos] & 127) >> 4) >>> 0;
if (this.buf[this.pos++] < 128)
return bits;
i = 0;
} else {
for (; i < 3; ++i) {
if (this.pos >= this.len)
throw indexOutOfRange(this);
bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;
if (this.buf[this.pos++] < 128)
return bits;
}
bits.lo = (bits.lo | (this.buf[this.pos++] & 127) << i * 7) >>> 0;
return bits;
}
if (this.len - this.pos > 4) {
for (; i < 5; ++i) {
bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;
if (this.buf[this.pos++] < 128)
return bits;
}
} else {
for (; i < 5; ++i) {
if (this.pos >= this.len)
throw indexOutOfRange(this);
bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;
if (this.buf[this.pos++] < 128)
return bits;
}
}
throw Error("invalid varint encoding");
}
Reader.prototype.bool = function read_bool() {
return this.uint32() !== 0;
};
function readFixed32_end(buf, end) {
return (buf[end - 4] | buf[end - 3] << 8 | buf[end - 2] << 16 | buf[end - 1] << 24) >>> 0;
}
Reader.prototype.fixed32 = function read_fixed32() {
if (this.pos + 4 > this.len)
throw indexOutOfRange(this, 4);
return readFixed32_end(this.buf, this.pos += 4);
};
Reader.prototype.sfixed32 = function read_sfixed32() {
if (this.pos + 4 > this.len)
throw indexOutOfRange(this, 4);
return readFixed32_end(this.buf, this.pos += 4) | 0;
};
function readFixed64() {
if (this.pos + 8 > this.len)
throw indexOutOfRange(this, 8);
return new LongBits(readFixed32_end(this.buf, this.pos += 4), readFixed32_end(this.buf, this.pos += 4));
}
Reader.prototype.float = function read_float() {
if (this.pos + 4 > this.len)
throw indexOutOfRange(this, 4);
var value = util.float.readFloatLE(this.buf, this.pos);
this.pos += 4;
return value;
};
Reader.prototype.double = function read_double() {
if (this.pos + 8 > this.len)
throw indexOutOfRange(this, 4);
var value = util.float.readDoubleLE(this.buf, this.pos);
this.pos += 8;
return value;
};
Reader.prototype.bytes = function read_bytes() {
var length = this.uint32(), start = this.pos, end = this.pos + length;
if (end > this.len)
throw indexOutOfRange(this, length);
this.pos += length;
if (Array.isArray(this.buf))
return this.buf.slice(start, end);
if (start === end) {
var nativeBuffer = util.Buffer;
return nativeBuffer ? nativeBuffer.alloc(0) : new this.buf.constructor(0);
}
return this._slice.call(this.buf, start, end);
};
Reader.prototype.string = function read_string() {
var bytes = this.bytes();
return utf8.read(bytes, 0, bytes.length);
};
Reader.prototype.skip = function skip(length) {
if (typeof length === "number") {
if (this.pos + length > this.len)
throw indexOutOfRange(this, length);
this.pos += length;
} else {
do {
if (this.pos >= this.len)
throw indexOutOfRange(this);
} while (this.buf[this.pos++] & 128);
}
return this;
};
Reader.prototype.skipType = function(wireType) {
switch (wireType) {
case 0:
this.skip();
break;
case 1:
this.skip(8);
break;
case 2:
this.skip(this.uint32());
break;
case 3:
while ((wireType = this.uint32() & 7) !== 4) {
this.skipType(wireType);
}
break;
case 5:
this.skip(4);
break;
default:
throw Error("invalid wire type " + wireType + " at offset " + this.pos);
}
return this;
};
Reader._configure = function(BufferReader_) {
BufferReader = BufferReader_;
Reader.create = create();
BufferReader._configure();
var fn = util.Long ? "toLong" : (
/* istanbul ignore next */
"toNumber"
);
util.merge(Reader.prototype, {
int64: function read_int64() {
return readLongVarint.call(this)[fn](false);
},
uint64: function read_uint64() {
return readLongVarint.call(this)[fn](true);
},
sint64: function read_sint64() {
return readLongVarint.call(this).zzDecode()[fn](false);
},
fixed64: function read_fixed64() {
return readFixed64.call(this)[fn](true);
},
sfixed64: function read_sfixed64() {
return readFixed64.call(this)[fn](false);
}
});
};
}
});
// web/node_modules/protobufjs/src/reader_buffer.js
var require_reader_buffer = __commonJS({
"web/node_modules/protobufjs/src/reader_buffer.js"(exports2, module2) {
"use strict";
module2.exports = BufferReader;
var Reader = require_reader();
(BufferReader.prototype = Object.create(Reader.prototype)).constructor = BufferReader;
var util = require_minimal();
function BufferReader(buffer) {
Reader.call(this, buffer);
}
BufferReader._configure = function() {
if (util.Buffer)
BufferReader.prototype._slice = util.Buffer.prototype.slice;
};
BufferReader.prototype.string = function read_string_buffer() {
var len = this.uint32();
return this.buf.utf8Slice ? this.buf.utf8Slice(this.pos, this.pos = Math.min(this.pos + len, this.len)) : this.buf.toString("utf-8", this.pos, this.pos = Math.min(this.pos + len, this.len));
};
BufferReader._configure();
}
});
// web/node_modules/protobufjs/src/rpc/service.js
var require_service = __commonJS({
"web/node_modules/protobufjs/src/rpc/service.js"(exports2, module2) {
"use strict";
module2.exports = Service;
var util = require_minimal();
(Service.prototype = Object.create(util.EventEmitter.prototype)).constructor = Service;
function Service(rpcImpl, requestDelimited, responseDelimited) {
if (typeof rpcImpl !== "function")
throw TypeError("rpcImpl must be a function");
util.EventEmitter.call(this);
this.rpcImpl = rpcImpl;
this.requestDelimited = Boolean(requestDelimited);
this.responseDelimited = Boolean(responseDelimited);
}
Service.prototype.rpcCall = function rpcCall(method, requestCtor, responseCtor, request, callback) {
if (!request)
throw TypeError("request must be specified");
var self2 = this;
if (!callback)
return util.asPromise(rpcCall, self2, method, requestCtor, responseCtor, request);
if (!self2.rpcImpl) {
setTimeout(function() {
callback(Error("already ended"));
}, 0);
return void 0;
}
try {
return self2.rpcImpl(
method,
requestCtor[self2.requestDelimited ? "encodeDelimited" : "encode"](request).finish(),
function rpcCallback(err, response) {
if (err) {
self2.emit("error", err, method);
return callback(err);
}
if (response === null) {
self2.end(
/* endedByRPC */
true
);
return void 0;
}
if (!(response instanceof responseCtor)) {
try {
response = responseCtor[self2.responseDelimited ? "decodeDelimited" : "decode"](response);
} catch (err2) {
self2.emit("error", err2, method);
return callback(err2);
}
}
self2.emit("data", response, method);
return callback(null, response);
}
);
} catch (err) {
self2.emit("error", err, method);
setTimeout(function() {
callback(err);
}, 0);
return void 0;
}
};
Service.prototype.end = function end(endedByRPC) {
if (this.rpcImpl) {
if (!endedByRPC)
this.rpcImpl(null, null, null);
this.rpcImpl = null;
this.emit("end").off();
}
return this;
};
}
});
// web/node_modules/protobufjs/src/rpc.js
var require_rpc = __commonJS({
"web/node_modules/protobufjs/src/rpc.js"(exports2) {
"use strict";
var rpc = exports2;
rpc.Service = require_service();
}
});
// web/node_modules/protobufjs/src/roots.js
var require_roots = __commonJS({
"web/node_modules/protobufjs/src/roots.js"(exports2, module2) {
"use strict";
module2.exports = {};
}
});
// web/node_modules/protobufjs/src/index-minimal.js
var require_index_minimal = __commonJS({
"web/node_modules/protobufjs/src/index-minimal.js"(exports2) {
"use strict";
var protobuf = exports2;
protobuf.build = "minimal";
protobuf.Writer = require_writer();
protobuf.BufferWriter = require_writer_buffer();
protobuf.Reader = require_reader();
protobuf.BufferReader = require_reader_buffer();
protobuf.util = require_minimal();
protobuf.rpc = require_rpc();
protobuf.roots = require_roots();
protobuf.configure = configure;
function configure() {
protobuf.util._configure();
protobuf.Writer._configure(protobuf.BufferWriter);
protobuf.Reader._configure(protobuf.BufferReader);
}
configure();
}
});
// web/node_modules/protobufjs/minimal.js
var require_minimal2 = __commonJS({
"web/node_modules/protobufjs/minimal.js"(exports2, module2) {
"use strict";
module2.exports = require_index_minimal();
}
});
// web/lib/onnxjs/ort-schema/protobuf/onnx.js
var require_onnx = __commonJS({
"web/lib/onnxjs/ort-schema/protobuf/onnx.js"(exports2, module2) {
"use strict";
var $protobuf = require_minimal2();
var $Reader = $protobuf.Reader;
var $Writer = $protobuf.Writer;
var $util = $protobuf.util;
var $root = $protobuf.roots["default"] || ($protobuf.roots["default"] = {});
$root.onnx = function() {
var onnx6 = {};
onnx6.Version = function() {
var valuesById = {}, values = Object.create(valuesById);
values[valuesById[0] = "_START_VERSION"] = 0;
values[valuesById[1] = "IR_VERSION_2017_10_10"] = 1;
values[valuesById[2] = "IR_VERSION_2017_10_30"] = 2;
values[valuesById[3] = "IR_VERSION_2017_11_3"] = 3;
values[valuesById[4] = "IR_VERSION_2019_1_22"] = 4;
values[valuesById[5] = "IR_VERSION_2019_3_18"] = 5;
values[valuesById[6] = "IR_VERSION_2019_9_19"] = 6;
values[valuesById[7] = "IR_VERSION_2020_5_8"] = 7;
values[valuesById[8] = "IR_VERSION_2021_7_30"] = 8;
values[valuesById[9] = "IR_VERSION"] = 9;
return values;
}();
onnx6.AttributeProto = function() {
function AttributeProto(properties) {
this.floats = [];
this.ints = [];
this.strings = [];
this.tensors = [];
this.graphs = [];
this.sparseTensors = [];
this.typeProtos = [];
if (properties) {
for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
if (properties[keys[i]] != null)
this[keys[i]] = properties[keys[i]];
}
}
AttributeProto.prototype.name = "";
AttributeProto.prototype.refAttrName = "";
AttributeProto.prototype.docString = "";
AttributeProto.prototype.type = 0;
AttributeProto.prototype.f = 0;
AttributeProto.prototype.i = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;
AttributeProto.prototype.s = $util.newBuffer([]);
AttributeProto.prototype.t = null;
AttributeProto.prototype.g = null;
AttributeProto.prototype.sparseTensor = null;
AttributeProto.prototype.tp = null;
AttributeProto.prototype.floats = $util.emptyArray;
AttributeProto.prototype.ints = $util.emptyArray;
AttributeProto.prototype.strings = $util.emptyArray;
AttributeProto.prototype.tensors = $util.emptyArray;
AttributeProto.prototype.graphs = $util.emptyArray;
AttributeProto.prototype.sparseTensors = $util.emptyArray;
AttributeProto.prototype.typeProtos = $util.emptyArray;
AttributeProto.create = function create(properties) {
return new AttributeProto(properties);
};
AttributeProto.encode = function encode(message, writer) {
if (!writer)
writer = $Writer.create();
if (message.name != null && Object.hasOwnProperty.call(message, "name"))
writer.uint32(
/* id 1, wireType 2 =*/
10
).string(message.name);
if (message.f != null && Object.hasOwnProperty.call(message, "f"))
writer.uint32(
/* id 2, wireType 5 =*/
21
).float(message.f);
if (message.i != null && Object.hasOwnProperty.call(message, "i"))
writer.uint32(
/* id 3, wireType 0 =*/
24
).int64(message.i);
if (message.s != null && Object.hasOwnProperty.call(message, "s"))
writer.uint32(
/* id 4, wireType 2 =*/
34
).bytes(message.s);
if (message.t != null && Object.hasOwnProperty.call(message, "t"))
$root.onnx.TensorProto.encode(message.t, writer.uint32(
/* id 5, wireType 2 =*/
42
).fork()).ldelim();
if (message.g != null && Object.hasOwnProperty.call(message, "g"))
$root.onnx.GraphProto.encode(message.g, writer.uint32(
/* id 6, wireType 2 =*/
50
).fork()).ldelim();
if (message.floats != null && message.floats.length) {
writer.uint32(
/* id 7, wireType 2 =*/
58
).fork();
for (var i = 0; i < message.floats.length; ++i)
writer.float(message.floats[i]);
writer.ldelim();
}
if (message.ints != null && message.ints.length) {
writer.uint32(
/* id 8, wireType 2 =*/
66
).fork();
for (var i = 0; i < message.ints.length; ++i)
writer.int64(message.ints[i]);
writer.ldelim();
}
if (message.strings != null && message.strings.length)
for (var i = 0; i < message.strings.length; ++i)
writer.uint32(
/* id 9, wireType 2 =*/
74
).bytes(message.strings[i]);
if (message.tensors != null && message.tensors.length)
for (var i = 0; i < message.tensors.length; ++i)
$root.onnx.TensorProto.encode(message.tensors[i], writer.uint32(
/* id 10, wireType 2 =*/
82
).fork()).ldelim();
if (message.graphs != null && message.graphs.length)
for (var i = 0; i < message.graphs.length; ++i)
$root.onnx.GraphProto.encode(message.graphs[i], writer.uint32(
/* id 11, wireType 2 =*/
90
).fork()).ldelim();
if (message.docString != null && Object.hasOwnProperty.call(message, "docString"))
writer.uint32(
/* id 13, wireType 2 =*/
106
).string(message.docString);
if (message.tp != null && Object.hasOwnProperty.call(message, "tp"))
$root.onnx.TypeProto.encode(message.tp, writer.uint32(
/* id 14, wireType 2 =*/
114
).fork()).ldelim();
if (message.typeProtos != null && message.typeProtos.length)
for (var i = 0; i < message.typeProtos.length; ++i)
$root.onnx.TypeProto.encode(
message.typeProtos[i],
writer.uint32(
/* id 15, wireType 2 =*/
122
).fork()
).ldelim();
if (message.type != null && Object.hasOwnProperty.call(message, "type"))
writer.uint32(
/* id 20, wireType 0 =*/
160
).int32(message.type);
if (message.refAttrName != null && Object.hasOwnProperty.call(message, "refAttrName"))
writer.uint32(
/* id 21, wireType 2 =*/
170
).string(message.refAttrName);
if (message.sparseTensor != null && Object.hasOwnProperty.call(message, "sparseTensor"))
$root.onnx.SparseTensorProto.encode(
message.sparseTensor,
writer.uint32(
/* id 22, wireType 2 =*/
178
).fork()
).ldelim();
if (message.sparseTensors != null && message.sparseTensors.length)
for (var i = 0; i < message.sparseTensors.length; ++i)
$root.onnx.SparseTensorProto.encode(
message.sparseTensors[i],
writer.uint32(
/* id 23, wireType 2 =*/
186
).fork()
).ldelim();
return writer;
};
AttributeProto.encodeDelimited = function encodeDelimited(message, writer) {
return this.encode(message, writer).ldelim();
};
AttributeProto.decode = function decode(reader, length) {
if (!(reader instanceof $Reader))
reader = $Reader.create(reader);
var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.onnx.AttributeProto();
while (reader.pos < end) {
var tag = reader.uint32();
switch (tag >>> 3) {
case 1: {
message.name = reader.string();
break;
}
case 21: {
message.refAttrName = reader.string();
break;
}
case 13: {
message.docString = reader.string();
break;
}
case 20: {
message.type = reader.int32();
break;
}
case 2: {
message.f = reader.float();
break;
}
case 3: {
message.i = reader.int64();
break;
}
case 4: {
message.s = reader.bytes();
break;
}
case 5: {
message.t = $root.onnx.TensorProto.decode(reader, reader.uint32());
break;
}
case 6: {
message.g = $root.onnx.GraphProto.decode(reader, reader.uint32());
break;
}
case 22: {
message.sparseTensor = $root.onnx.SparseTensorProto.decode(reader, reader.uint32());
break;
}
case 14: {
message.tp = $root.onnx.TypeProto.decode(reader, reader.uint32());
break;
}
case 7: {
if (!(message.floats && message.floats.length))
message.floats = [];
if ((tag & 7) === 2) {
var end2 = reader.uint32() + reader.pos;
while (reader.pos < end2)
message.floats.push(reader.float());
} else
message.floats.push(reader.float());
break;
}
case 8: {
if (!(message.ints && message.ints.length))
message.ints = [];
if ((tag & 7) === 2) {
var end2 = reader.uint32() + reader.pos;
while (reader.pos < end2)
message.ints.push(reader.int64());
} else
message.ints.push(reader.int64());
break;
}
case 9: {
if (!(message.strings && message.strings.length))
message.strings = [];
message.strings.push(reader.bytes());
break;
}
case 10: {
if (!(message.tensors && message.tensors.length))
message.tensors = [];
message.tensors.push($root.onnx.TensorProto.decode(reader, reader.uint32()));
break;
}
case 11: {
if (!(message.graphs && message.graphs.length))
message.graphs = [];
message.graphs.push($root.onnx.GraphProto.decode(reader, reader.uint32()));
break;
}
case 23: {
if (!(message.sparseTensors && message.sparseTensors.length))
message.sparseTensors = [];
message.sparseTensors.push($root.onnx.SparseTensorProto.decode(reader, reader.uint32()));
break;
}
case 15: {
if (!(message.typeProtos && message.typeProtos.length))
message.typeProtos = [];
message.typeProtos.push($root.onnx.TypeProto.decode(reader, reader.uint32()));
break;
}
default:
reader.skipType(tag & 7);
break;
}
}
return message;
};
AttributeProto.decodeDelimited = function decodeDelimited(reader) {
if (!(reader instanceof $Reader))
reader = new $Reader(reader);
return this.decode(reader, reader.uint32());
};
AttributeProto.verify = function verify(message) {
if (typeof message !== "object" || message === null)
return "object expected";
if (message.name != null && message.hasOwnProperty("name")) {
if (!$util.isString(message.name))
return "name: string expected";
}
if (message.refAttrName != null && message.hasOwnProperty("refAttrName")) {
if (!$util.isString(message.refAttrName))
return "refAttrName: string expected";
}
if (message.docString != null && message.hasOwnProperty("docString")) {
if (!$util.isString(message.docString))
return "docString: string expected";
}
if (message.type != null && message.hasOwnProperty("type"))
switch (message.type) {
default:
return "type: enum value expected";
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
case 11:
case 13:
case 6:
case 7:
case 8:
case 9:
case 10:
case 12:
case 14:
break;
}
if (message.f != null && message.hasOwnProperty("f")) {
if (typeof message.f !== "number")
return "f: number expected";
}
if (message.i != null && message.hasOwnProperty("i")) {
if (!$util.isInteger(message.i) && !(message.i && $util.isInteger(message.i.low) && $util.isInteger(message.i.high)))
return "i: integer|Long expected";
}
if (message.s != null && message.hasOwnProperty("s")) {
if (!(message.s && typeof message.s.length === "number" || $util.isString(message.s)))
return "s: buffer expected";
}
if (message.t != null && message.hasOwnProperty("t")) {
var error = $root.onnx.TensorProto.verify(message.t);
if (error)
return "t." + error;
}
if (message.g != null && message.hasOwnProperty("g")) {
var error = $root.onnx.GraphProto.verify(message.g);
if (error)
return "g." + error;
}
if (message.sparseTensor != null && message.hasOwnProperty("sparseTensor")) {
var error = $root.onnx.SparseTensorProto.verify(message.sparseTensor);
if (error)
return "sparseTensor." + error;
}
if (message.tp != null && message.hasOwnProperty("tp")) {
var error = $root.onnx.TypeProto.verify(message.tp);
if (error)
return "tp." + error;
}
if (message.floats != null && message.hasOwnProperty("floats")) {
if (!Array.isArray(message.floats))
return "floats: array expected";
for (var i = 0; i < message.floats.length; ++i)
if (typeof message.floats[i] !== "number")
return "floats: number[] expected";
}
if (message.ints != null && message.hasOwnProperty("ints")) {
if (!Array.isArray(message.ints))
return "ints: array expected";
for (var i = 0; i < message.ints.length; ++i)
if (!$util.isInteger(message.ints[i]) && !(message.ints[i] && $util.isInteger(message.ints[i].low) && $util.isInteger(message.ints[i].high)))
return "ints: integer|Long[] expected";
}
if (message.strings != null && message.hasOwnProperty("strings")) {
if (!Array.isArray(message.strings))
return "strings: array expected";
for (var i = 0; i < message.strings.length; ++i)
if (!(message.strings[i] && typeof message.strings[i].length === "number" || $util.isString(message.strings[i])))
return "strings: buffer[] expected";
}
if (message.tensors != null && message.hasOwnProperty("tensors")) {
if (!Array.isArray(message.tensors))
return "tensors: array expected";
for (var i = 0; i < message.tensors.length; ++i) {
var error = $root.onnx.TensorProto.verify(message.tensors[i]);
if (error)
return "tensors." + error;
}
}
if (message.graphs != null && message.hasOwnProperty("graphs")) {
if (!Array.isArray(message.graphs))
return "graphs: array expected";
for (var i = 0; i < message.graphs.length; ++i) {
var error = $root.onnx.GraphProto.verify(message.graphs[i]);
if (error)
return "graphs." + error;
}
}
if (message.sparseTensors != null && message.hasOwnProperty("sparseTensors")) {
if (!Array.isArray(message.sparseTensors))
return "sparseTensors: array expected";
for (var i = 0; i < message.sparseTensors.length; ++i) {
var error = $root.onnx.SparseTensorProto.verify(message.sparseTensors[i]);
if (error)
return "sparseTensors." + error;
}
}
if (message.typeProtos != null && message.hasOwnProperty("typeProtos")) {
if (!Array.isArray(message.typeProtos))
return "typeProtos: array expected";
for (var i = 0; i < message.typeProtos.length; ++i) {
var error = $root.onnx.TypeProto.verify(message.typeProtos[i]);
if (error)
return "typeProtos." + error;
}
}
return null;
};
AttributeProto.fromObject = function fromObject(object) {
if (object instanceof $root.onnx.AttributeProto)
return object;
var message = new $root.onnx.AttributeProto();
if (object.name != null)
message.name = String(object.name);
if (object.refAttrName != null)
message.refAttrName = String(object.refAttrName);
if (object.docString != null)
message.docString = String(object.docString);
switch (object.type) {
default:
if (typeof object.type === "number") {
message.type = object.type;
break;
}
break;
case "UNDEFINED":
case 0:
message.type = 0;
break;
case "FLOAT":
case 1:
message.type = 1;
break;
case "INT":
case 2:
message.type = 2;
break;
case "STRING":
case 3:
message.type = 3;
break;
case "TENSOR":
case 4:
message.type = 4;
break;
case "GRAPH":
case 5:
message.type = 5;
break;
case "SPARSE_TENSOR":
case 11:
message.type = 11;
break;
case "TYPE_PROTO":
case 13:
message.type = 13;
break;
case "FLOATS":
case 6:
message.type = 6;
break;
case "INTS":
case 7:
message.type = 7;
break;
case "STRINGS":
case 8:
message.type = 8;
break;
case "TENSORS":
case 9:
message.type = 9;
break;
case "GRAPHS":
case 10:
message.type = 10;
break;
case "SPARSE_TENSORS":
case 12:
message.type = 12;
break;
case "TYPE_PROTOS":
case 14:
message.type = 14;
break;
}
if (object.f != null)
message.f = Number(object.f);
if (object.i != null) {
if ($util.Long)
(message.i = $util.Long.fromValue(object.i)).unsigned = false;
else if (typeof object.i === "string")
message.i = parseInt(object.i, 10);
else if (typeof object.i === "number")
message.i = object.i;
else if (typeof object.i === "object")
message.i = new $util.LongBits(object.i.low >>> 0, object.i.high >>> 0).toNumber();
}
if (object.s != null) {
if (typeof object.s === "string")
$util.base64.decode(object.s, message.s = $util.newBuffer($util.base64.length(object.s)), 0);
else if (object.s.length >= 0)
message.s = object.s;
}
if (object.t != null) {
if (typeof object.t !== "object")
throw TypeError(".onnx.AttributeProto.t: object expected");
message.t = $root.onnx.TensorProto.fromObject(object.t);
}
if (object.g != null) {
if (typeof object.g !== "object")
throw TypeError(".onnx.AttributeProto.g: object expected");
message.g = $root.onnx.GraphProto.fromObject(object.g);
}
if (object.sparseTensor != null) {
if (typeof object.sparseTensor !== "object")
throw TypeError(".onnx.AttributeProto.sparseTensor: object expected");
message.sparseTensor = $root.onnx.SparseTensorProto.fromObject(object.sparseTensor);
}
if (object.tp != null) {
if (typeof object.tp !== "object")
throw TypeError(".onnx.AttributeProto.tp: object expected");
message.tp = $root.onnx.TypeProto.fromObject(object.tp);
}
if (object.floats) {
if (!Array.isArray(object.floats))
throw TypeError(".onnx.AttributeProto.floats: array expected");
message.floats = [];
for (var i = 0; i < object.floats.length; ++i)
message.floats[i] = Number(object.floats[i]);
}
if (object.ints) {
if (!Array.isArray(object.ints))
throw TypeError(".onnx.AttributeProto.ints: array expected");
message.ints = [];
for (var i = 0; i < object.ints.length; ++i)
if ($util.Long)
(message.ints[i] = $util.Long.fromValue(object.ints[i])).unsigned = false;
else if (typeof object.ints[i] === "string")
message.ints[i] = parseInt(object.ints[i], 10);
else if (typeof object.ints[i] === "number")
message.ints[i] = object.ints[i];
else if (typeof object.ints[i] === "object")
message.ints[i] = new $util.LongBits(object.ints[i].low >>> 0, object.ints[i].high >>> 0).toNumber();
}
if (object.strings) {
if (!Array.isArray(object.strings))
throw TypeError(".onnx.AttributeProto.strings: array expected");
message.strings = [];
for (var i = 0; i < object.strings.length; ++i)
if (typeof object.strings[i] === "string")
$util.base64.decode(
object.strings[i],
message.strings[i] = $util.newBuffer($util.base64.length(object.strings[i])),
0
);
else if (object.strings[i].length >= 0)
message.strings[i] = object.strings[i];
}
if (object.tensors) {
if (!Array.isArray(object.tensors))
throw TypeError(".onnx.AttributeProto.tensors: array expected");
message.tensors = [];
for (var i = 0; i < object.tensors.length; ++i) {
if (typeof object.tensors[i] !== "object")
throw TypeError(".onnx.AttributeProto.tensors: object expected");
message.tensors[i] = $root.onnx.TensorProto.fromObject(object.tensors[i]);
}
}
if (object.graphs) {
if (!Array.isArray(object.graphs))
throw TypeError(".onnx.AttributeProto.graphs: array expected");
message.graphs = [];
for (var i = 0; i < object.graphs.length; ++i) {
if (typeof object.graphs[i] !== "object")
throw TypeError(".onnx.AttributeProto.graphs: object expected");
message.graphs[i] = $root.onnx.GraphProto.fromObject(object.graphs[i]);
}
}
if (object.sparseTensors) {
if (!Array.isArray(object.sparseTensors))
throw TypeError(".onnx.AttributeProto.sparseTensors: array expected");
message.sparseTensors = [];
for (var i = 0; i < object.sparseTensors.length; ++i) {
if (typeof object.sparseTensors[i] !== "object")
throw TypeError(".onnx.AttributeProto.sparseTensors: object expected");
message.sparseTensors[i] = $root.onnx.SparseTensorProto.fromObject(object.sparseTensors[i]);
}
}
if (object.typeProtos) {
if (!Array.isArray(object.typeProtos))
throw TypeError(".onnx.AttributeProto.typeProtos: array expected");
message.typeProtos = [];
for (var i = 0; i < object.typeProtos.length; ++i) {
if (typeof object.typeProtos[i] !== "object")
throw TypeError(".onnx.AttributeProto.typeProtos: object expected");
message.typeProtos[i] = $root.onnx.TypeProto.fromObject(object.typeProtos[i]);
}
}
return message;
};
AttributeProto.toObject = function toObject(message, options) {
if (!options)
options = {};
var object = {};
if (options.arrays || options.defaults) {
object.floats = [];
object.ints = [];
object.strings = [];
object.tensors = [];
object.graphs = [];
object.typeProtos = [];
object.sparseTensors = [];
}
if (options.defaults) {
object.name = "";
object.f = 0;
if ($util.Long) {
var long = new $util.Long(0, 0, false);
object.i = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
} else
object.i = options.longs === String ? "0" : 0;
if (options.bytes === String)
object.s = "";
else {
object.s = [];
if (options.bytes !== Array)
object.s = $util.newBuffer(object.s);
}
object.t = null;
object.g = null;
object.docString = "";
object.tp = null;
object.type = options.enums === String ? "UNDEFINED" : 0;
object.refAttrName = "";
object.sparseTensor = null;
}
if (message.name != null && message.hasOwnProperty("name"))
object.name = message.name;
if (message.f != null && message.hasOwnProperty("f"))
object.f = options.json && !isFinite(message.f) ? String(message.f) : message.f;
if (message.i != null && message.hasOwnProperty("i"))
if (typeof message.i === "number")
object.i = options.longs === String ? String(message.i) : message.i;
else
object.i = options.longs === String ? $util.Long.prototype.toString.call(message.i) : options.longs === Number ? new $util.LongBits(message.i.low >>> 0, message.i.high >>> 0).toNumber() : message.i;
if (message.s != null && message.hasOwnProperty("s"))
object.s = options.bytes === String ? $util.base64.encode(message.s, 0, message.s.length) : options.bytes === Array ? Array.prototype.slice.call(message.s) : message.s;
if (message.t != null && message.hasOwnProperty("t"))
object.t = $root.onnx.TensorProto.toObject(message.t, options);
if (message.g != null && message.hasOwnProperty("g"))
object.g = $root.onnx.GraphProto.toObject(message.g, options);
if (message.floats && message.floats.length) {
object.floats = [];
for (var j = 0; j < message.floats.length; ++j)
object.floats[j] = options.json && !isFinite(message.floats[j]) ? String(message.floats[j]) : message.floats[j];
}
if (message.ints && message.ints.length) {
object.ints = [];
for (var j = 0; j < message.ints.length; ++j)
if (typeof message.ints[j] === "number")
object.ints[j] = options.longs === String ? String(message.ints[j]) : message.ints[j];
else
object.ints[j] = options.longs === String ? $util.Long.prototype.toString.call(message.ints[j]) : options.longs === Number ? new $util.LongBits(message.ints[j].low >>> 0, message.ints[j].high >>> 0).toNumber() : message.ints[j];
}
if (message.strings && message.strings.length) {
object.strings = [];
for (var j = 0; j < message.strings.length; ++j)
object.strings[j] = options.bytes === String ? $util.base64.encode(message.strings[j], 0, message.strings[j].length) : options.bytes === Array ? Array.prototype.slice.call(message.strings[j]) : message.strings[j];
}
if (message.tensors && message.tensors.length) {
object.tensors = [];
for (var j = 0; j < message.tensors.length; ++j)
object.tensors[j] = $root.onnx.TensorProto.toObject(message.tensors[j], options);
}
if (message.graphs && message.graphs.length) {
object.graphs = [];
for (var j = 0; j < message.graphs.length; ++j)
object.graphs[j] = $root.onnx.GraphProto.toObject(message.graphs[j], options);
}
if (message.docString != null && message.hasOwnProperty("docString"))
object.docString = message.docString;
if (message.tp != null && message.hasOwnProperty("tp"))
object.tp = $root.onnx.TypeProto.toObject(message.tp, options);
if (message.typeProtos && message.typeProtos.length) {
object.typeProtos = [];
for (var j = 0; j < message.typeProtos.length; ++j)
object.typeProtos[j] = $root.onnx.TypeProto.toObject(message.typeProtos[j], options);
}
if (message.type != null && message.hasOwnProperty("type"))
object.type = options.enums === String ? $root.onnx.AttributeProto.AttributeType[message.type] === void 0 ? message.type : $root.onnx.AttributeProto.AttributeType[message.type] : message.type;
if (message.refAttrName != null && message.hasOwnProperty("refAttrName"))
object.refAttrName = message.refAttrName;
if (message.sparseTensor != null && message.hasOwnProperty("sparseTensor"))
object.sparseTensor = $root.onnx.SparseTensorProto.toObject(message.sparseTensor, options);
if (message.sparseTensors && message.sparseTensors.length) {
object.sparseTensors = [];
for (var j = 0; j < message.sparseTensors.length; ++j)
object.sparseTensors[j] = $root.onnx.SparseTensorProto.toObject(message.sparseTensors[j], options);
}
return object;
};
AttributeProto.prototype.toJSON = function toJSON() {
return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
};
AttributeProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
if (typeUrlPrefix === void 0) {
typeUrlPrefix = "type.googleapis.com";
}
return typeUrlPrefix + "/onnx.AttributeProto";
};
AttributeProto.AttributeType = function() {
var valuesById = {}, values = Object.create(valuesById);
values[valuesById[0] = "UNDEFINED"] = 0;
values[valuesById[1] = "FLOAT"] = 1;
values[valuesById[2] = "INT"] = 2;
values[valuesById[3] = "STRING"] = 3;
values[valuesById[4] = "TENSOR"] = 4;
values[valuesById[5] = "GRAPH"] = 5;
values[valuesById[11] = "SPARSE_TENSOR"] = 11;
values[valuesById[13] = "TYPE_PROTO"] = 13;
values[valuesById[6] = "FLOATS"] = 6;
values[valuesById[7] = "INTS"] = 7;
values[valuesById[8] = "STRINGS"] = 8;
values[valuesById[9] = "TENSORS"] = 9;
values[valuesById[10] = "GRAPHS"] = 10;
values[valuesById[12] = "SPARSE_TENSORS"] = 12;
values[valuesById[14] = "TYPE_PROTOS"] = 14;
return values;
}();
return AttributeProto;
}();
onnx6.ValueInfoProto = function() {
function ValueInfoProto(properties) {
if (properties) {
for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
if (properties[keys[i]] != null)
this[keys[i]] = properties[keys[i]];
}
}
ValueInfoProto.prototype.name = "";
ValueInfoProto.prototype.type = null;
ValueInfoProto.prototype.docString = "";
ValueInfoProto.create = function create(properties) {
return new ValueInfoProto(properties);
};
ValueInfoProto.encode = function encode(message, writer) {
if (!writer)
writer = $Writer.create();
if (message.name != null && Object.hasOwnProperty.call(message, "name"))
writer.uint32(
/* id 1, wireType 2 =*/
10
).string(message.name);
if (message.type != null && Object.hasOwnProperty.call(message, "type"))
$root.onnx.TypeProto.encode(message.type, writer.uint32(
/* id 2, wireType 2 =*/
18
).fork()).ldelim();
if (message.docString != null && Object.hasOwnProperty.call(message, "docString"))
writer.uint32(
/* id 3, wireType 2 =*/
26
).string(message.docString);
return writer;
};
ValueInfoProto.encodeDelimited = function encodeDelimited(message, writer) {
return this.encode(message, writer).ldelim();
};
ValueInfoProto.decode = function decode(reader, length) {
if (!(reader instanceof $Reader))
reader = $Reader.create(reader);
var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.onnx.ValueInfoProto();
while (reader.pos < end) {
var tag = reader.uint32();
switch (tag >>> 3) {
case 1: {
message.name = reader.string();
break;
}
case 2: {
message.type = $root.onnx.TypeProto.decode(reader, reader.uint32());
break;
}
case 3: {
message.docString = reader.string();
break;
}
default:
reader.skipType(tag & 7);
break;
}
}
return message;
};
ValueInfoProto.decodeDelimited = function decodeDelimited(reader) {
if (!(reader instanceof $Reader))
reader = new $Reader(reader);
return this.decode(reader, reader.uint32());
};
ValueInfoProto.verify = function verify(message) {
if (typeof message !== "object" || message === null)
return "object expected";
if (message.name != null && message.hasOwnProperty("name")) {
if (!$util.isString(message.name))
return "name: string expected";
}
if (message.type != null && message.hasOwnProperty("type")) {
var error = $root.onnx.TypeProto.verify(message.type);
if (error)
return "type." + error;
}
if (message.docString != null && message.hasOwnProperty("docString")) {
if (!$util.isString(message.docString))
return "docString: string expected";
}
return null;
};
ValueInfoProto.fromObject = function fromObject(object) {
if (object instanceof $root.onnx.ValueInfoProto)
return object;
var message = new $root.onnx.ValueInfoProto();
if (object.name != null)
message.name = String(object.name);
if (object.type != null) {
if (typeof object.type !== "object")
throw TypeError(".onnx.ValueInfoProto.type: object expected");
message.type = $root.onnx.TypeProto.fromObject(object.type);
}
if (object.docString != null)
message.docString = String(object.docString);
return message;
};
ValueInfoProto.toObject = function toObject(message, options) {
if (!options)
options = {};
var object = {};
if (options.defaults) {
object.name = "";
object.type = null;
object.docString = "";
}
if (message.name != null && message.hasOwnProperty("name"))
object.name = message.name;
if (message.type != null && message.hasOwnProperty("type"))
object.type = $root.onnx.TypeProto.toObject(message.type, options);
if (message.docString != null && message.hasOwnProperty("docString"))
object.docString = message.docString;
return object;
};
ValueInfoProto.prototype.toJSON = function toJSON() {
return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
};
ValueInfoProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
if (typeUrlPrefix === void 0) {
typeUrlPrefix = "type.googleapis.com";
}
return typeUrlPrefix + "/onnx.ValueInfoProto";
};
return ValueInfoProto;
}();
onnx6.NodeProto = function() {
function NodeProto(properties) {
this.input = [];
this.output = [];
this.attribute = [];
if (properties) {
for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
if (properties[keys[i]] != null)
this[keys[i]] = properties[keys[i]];
}
}
NodeProto.prototype.input = $util.emptyArray;
NodeProto.prototype.output = $util.emptyArray;
NodeProto.prototype.name = "";
NodeProto.prototype.opType = "";
NodeProto.prototype.domain = "";
NodeProto.prototype.attribute = $util.emptyArray;
NodeProto.prototype.docString = "";
NodeProto.create = function create(properties) {
return new NodeProto(properties);
};
NodeProto.encode = function encode(message, writer) {
if (!writer)
writer = $Writer.create();
if (message.input != null && message.input.length)
for (var i = 0; i < message.input.length; ++i)
writer.uint32(
/* id 1, wireType 2 =*/
10
).string(message.input[i]);
if (message.output != null && message.output.length)
for (var i = 0; i < message.output.length; ++i)
writer.uint32(
/* id 2, wireType 2 =*/
18
).string(message.output[i]);
if (message.name != null && Object.hasOwnProperty.call(message, "name"))
writer.uint32(
/* id 3, wireType 2 =*/
26
).string(message.name);
if (message.opType != null && Object.hasOwnProperty.call(message, "opType"))
writer.uint32(
/* id 4, wireType 2 =*/
34
).string(message.opType);
if (message.attribute != null && message.attribute.length)
for (var i = 0; i < message.attribute.length; ++i)
$root.onnx.AttributeProto.encode(
message.attribute[i],
writer.uint32(
/* id 5, wireType 2 =*/
42
).fork()
).ldelim();
if (message.docString != null && Object.hasOwnProperty.call(message, "docString"))
writer.uint32(
/* id 6, wireType 2 =*/
50
).string(message.docString);
if (message.domain != null && Object.hasOwnProperty.call(message, "domain"))
writer.uint32(
/* id 7, wireType 2 =*/
58
).string(message.domain);
return writer;
};
NodeProto.encodeDelimited = function encodeDelimited(message, writer) {
return this.encode(message, writer).ldelim();
};
NodeProto.decode = function decode(reader, length) {
if (!(reader instanceof $Reader))
reader = $Reader.create(reader);
var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.onnx.NodeProto();
while (reader.pos < end) {
var tag = reader.uint32();
switch (tag >>> 3) {
case 1: {
if (!(message.input && message.input.length))
message.input = [];
message.input.push(reader.string());
break;
}
case 2: {
if (!(message.output && message.output.length))
message.output = [];
message.output.push(reader.string());
break;
}
case 3: {
message.name = reader.string();
break;
}
case 4: {
message.opType = reader.string();
break;
}
case 7: {
message.domain = reader.string();
break;
}
case 5: {
if (!(message.attribute && message.attribute.length))
message.attribute = [];
message.attribute.push($root.onnx.AttributeProto.decode(reader, reader.uint32()));
break;
}
case 6: {
message.docString = reader.string();
break;
}
default:
reader.skipType(tag & 7);
break;
}
}
return message;
};
NodeProto.decodeDelimited = function decodeDelimited(reader) {
if (!(reader instanceof $Reader))
reader = new $Reader(reader);
return this.decode(reader, reader.uint32());
};
NodeProto.verify = function verify(message) {
if (typeof message !== "object" || message === null)
return "object expected";
if (message.input != null && message.hasOwnProperty("input")) {
if (!Array.isArray(message.input))
return "input: array expected";
for (var i = 0; i < message.input.length; ++i)
if (!$util.isString(message.input[i]))
return "input: string[] expected";
}
if (message.output != null && message.hasOwnProperty("output")) {
if (!Array.isArray(message.output))
return "output: array expected";
for (var i = 0; i < message.output.length; ++i)
if (!$util.isString(message.output[i]))
return "output: string[] expected";
}
if (message.name != null && message.hasOwnProperty("name")) {
if (!$util.isString(message.name))
return "name: string expected";
}
if (message.opType != null && message.hasOwnProperty("opType")) {
if (!$util.isString(message.opType))
return "opType: string expected";
}
if (message.domain != null && message.hasOwnProperty("domain")) {
if (!$util.isString(message.domain))
return "domain: string expected";
}
if (message.attribute != null && message.hasOwnProperty("attribute")) {
if (!Array.isArray(message.attribute))
return "attribute: array expected";
for (var i = 0; i < message.attribute.length; ++i) {
var error = $root.onnx.AttributeProto.verify(message.attribute[i]);
if (error)
return "attribute." + error;
}
}
if (message.docString != null && message.hasOwnProperty("docString")) {
if (!$util.isString(message.docString))
return "docString: string expected";
}
return null;
};
NodeProto.fromObject = function fromObject(object) {
if (object instanceof $root.onnx.NodeProto)
return object;
var message = new $root.onnx.NodeProto();
if (object.input) {
if (!Array.isArray(object.input))
throw TypeError(".onnx.NodeProto.input: array expected");
message.input = [];
for (var i = 0; i < object.input.length; ++i)
message.input[i] = String(object.input[i]);
}
if (object.output) {
if (!Array.isArray(object.output))
throw TypeError(".onnx.NodeProto.output: array expected");
message.output = [];
for (var i = 0; i < object.output.length; ++i)
message.output[i] = String(object.output[i]);
}
if (object.name != null)
message.name = String(object.name);
if (object.opType != null)
message.opType = String(object.opType);
if (object.domain != null)
message.domain = String(object.domain);
if (object.attribute) {
if (!Array.isArray(object.attribute))
throw TypeError(".onnx.NodeProto.attribute: array expected");
message.attribute = [];
for (var i = 0; i < object.attribute.length; ++i) {
if (typeof object.attribute[i] !== "object")
throw TypeError(".onnx.NodeProto.attribute: object expected");
message.attribute[i] = $root.onnx.AttributeProto.fromObject(object.attribute[i]);
}
}
if (object.docString != null)
message.docString = String(object.docString);
return message;
};
NodeProto.toObject = function toObject(message, options) {
if (!options)
options = {};
var object = {};
if (options.arrays || options.defaults) {
object.input = [];
object.output = [];
object.attribute = [];
}
if (options.defaults) {
object.name = "";
object.opType = "";
object.docString = "";
object.domain = "";
}
if (message.input && message.input.length) {
object.input = [];
for (var j = 0; j < message.input.length; ++j)
object.input[j] = message.input[j];
}
if (message.output && message.output.length) {
object.output = [];
for (var j = 0; j < message.output.length; ++j)
object.output[j] = message.output[j];
}
if (message.name != null && message.hasOwnProperty("name"))
object.name = message.name;
if (message.opType != null && message.hasOwnProperty("opType"))
object.opType = message.opType;
if (message.attribute && message.attribute.length) {
object.attribute = [];
for (var j = 0; j < message.attribute.length; ++j)
object.attribute[j] = $root.onnx.AttributeProto.toObject(message.attribute[j], options);
}
if (message.docString != null && message.hasOwnProperty("docString"))
object.docString = message.docString;
if (message.domain != null && message.hasOwnProperty("domain"))
object.domain = message.domain;
return object;
};
NodeProto.prototype.toJSON = function toJSON() {
return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
};
NodeProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
if (typeUrlPrefix === void 0) {
typeUrlPrefix = "type.googleapis.com";
}
return typeUrlPrefix + "/onnx.NodeProto";
};
return NodeProto;
}();
onnx6.TrainingInfoProto = function() {
function TrainingInfoProto(properties) {
this.initializationBinding = [];
this.updateBinding = [];
if (properties) {
for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
if (properties[keys[i]] != null)
this[keys[i]] = properties[keys[i]];
}
}
TrainingInfoProto.prototype.initialization = null;
TrainingInfoProto.prototype.algorithm = null;
TrainingInfoProto.prototype.initializationBinding = $util.emptyArray;
TrainingInfoProto.prototype.updateBinding = $util.emptyArray;
TrainingInfoProto.create = function create(properties) {
return new TrainingInfoProto(properties);
};
TrainingInfoProto.encode = function encode(message, writer) {
if (!writer)
writer = $Writer.create();
if (message.initialization != null && Object.hasOwnProperty.call(message, "initialization"))
$root.onnx.GraphProto.encode(message.initialization, writer.uint32(
/* id 1, wireType 2 =*/
10
).fork()).ldelim();
if (message.algorithm != null && Object.hasOwnProperty.call(message, "algorithm"))
$root.onnx.GraphProto.encode(message.algorithm, writer.uint32(
/* id 2, wireType 2 =*/
18
).fork()).ldelim();
if (message.initializationBinding != null && message.initializationBinding.length)
for (var i = 0; i < message.initializationBinding.length; ++i)
$root.onnx.StringStringEntryProto.encode(
message.initializationBinding[i],
writer.uint32(
/* id 3, wireType 2 =*/
26
).fork()
).ldelim();
if (message.updateBinding != null && message.updateBinding.length)
for (var i = 0; i < message.updateBinding.length; ++i)
$root.onnx.StringStringEntryProto.encode(
message.updateBinding[i],
writer.uint32(
/* id 4, wireType 2 =*/
34
).fork()
).ldelim();
return writer;
};
TrainingInfoProto.encodeDelimited = function encodeDelimited(message, writer) {
return this.encode(message, writer).ldelim();
};
TrainingInfoProto.decode = function decode(reader, length) {
if (!(reader instanceof $Reader))
reader = $Reader.create(reader);
var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.onnx.TrainingInfoProto();
while (reader.pos < end) {
var tag = reader.uint32();
switch (tag >>> 3) {
case 1: {
message.initialization = $root.onnx.GraphProto.decode(reader, reader.uint32());
break;
}
case 2: {
message.algorithm = $root.onnx.GraphProto.decode(reader, reader.uint32());
break;
}
case 3: {
if (!(message.initializationBinding && message.initializationBinding.length))
message.initializationBinding = [];
message.initializationBinding.push($root.onnx.StringStringEntryProto.decode(reader, reader.uint32()));
break;
}
case 4: {
if (!(message.updateBinding && message.updateBinding.length))
message.updateBinding = [];
message.updateBinding.push($root.onnx.StringStringEntryProto.decode(reader, reader.uint32()));
break;
}
default:
reader.skipType(tag & 7);
break;
}
}
return message;
};
TrainingInfoProto.decodeDelimited = function decodeDelimited(reader) {
if (!(reader instanceof $Reader))
reader = new $Reader(reader);
return this.decode(reader, reader.uint32());
};
TrainingInfoProto.verify = function verify(message) {
if (typeof message !== "object" || message === null)
return "object expected";
if (message.initialization != null && message.hasOwnProperty("initialization")) {
var error = $root.onnx.GraphProto.verify(message.initialization);
if (error)
return "initialization." + error;
}
if (message.algorithm != null && message.hasOwnProperty("algorithm")) {
var error = $root.onnx.GraphProto.verify(message.algorithm);
if (error)
return "algorithm." + error;
}
if (message.initializationBinding != null && message.hasOwnProperty("initializationBinding")) {
if (!Array.isArray(message.initializationBinding))
return "initializationBinding: array expected";
for (var i = 0; i < message.initializationBinding.length; ++i) {
var error = $root.onnx.StringStringEntryProto.verify(message.initializationBinding[i]);
if (error)
return "initializationBinding." + error;
}
}
if (message.updateBinding != null && message.hasOwnProperty("updateBinding")) {
if (!Array.isArray(message.updateBinding))
return "updateBinding: array expected";
for (var i = 0; i < message.updateBinding.length; ++i) {
var error = $root.onnx.StringStringEntryProto.verify(message.updateBinding[i]);
if (error)
return "updateBinding." + error;
}
}
return null;
};
TrainingInfoProto.fromObject = function fromObject(object) {
if (object instanceof $root.onnx.TrainingInfoProto)
return object;
var message = new $root.onnx.TrainingInfoProto();
if (object.initialization != null) {
if (typeof object.initialization !== "object")
throw TypeError(".onnx.TrainingInfoProto.initialization: object expected");
message.initialization = $root.onnx.GraphProto.fromObject(object.initialization);
}
if (object.algorithm != null) {
if (typeof object.algorithm !== "object")
throw TypeError(".onnx.TrainingInfoProto.algorithm: object expected");
message.algorithm = $root.onnx.GraphProto.fromObject(object.algorithm);
}
if (object.initializationBinding) {
if (!Array.isArray(object.initializationBinding))
throw TypeError(".onnx.TrainingInfoProto.initializationBinding: array expected");
message.initializationBinding = [];
for (var i = 0; i < object.initializationBinding.length; ++i) {
if (typeof object.initializationBinding[i] !== "object")
throw TypeError(".onnx.TrainingInfoProto.initializationBinding: object expected");
message.initializationBinding[i] = $root.onnx.StringStringEntryProto.fromObject(
object.initializationBinding[i]
);
}
}
if (object.updateBinding) {
if (!Array.isArray(object.updateBinding))
throw TypeError(".onnx.TrainingInfoProto.updateBinding: array expected");
message.updateBinding = [];
for (var i = 0; i < object.updateBinding.length; ++i) {
if (typeof object.updateBinding[i] !== "object")
throw TypeError(".onnx.TrainingInfoProto.updateBinding: object expected");
message.updateBinding[i] = $root.onnx.StringStringEntryProto.fromObject(object.updateBinding[i]);
}
}
return message;
};
TrainingInfoProto.toObject = function toObject(message, options) {
if (!options)
options = {};
var object = {};
if (options.arrays || options.defaults) {
object.initializationBinding = [];
object.updateBinding = [];
}
if (options.defaults) {
object.initialization = null;
object.algorithm = null;
}
if (message.initialization != null && message.hasOwnProperty("initialization"))
object.initialization = $root.onnx.GraphProto.toObject(message.initialization, options);
if (message.algorithm != null && message.hasOwnProperty("algorithm"))
object.algorithm = $root.onnx.GraphProto.toObject(message.algorithm, options);
if (message.initializationBinding && message.initializationBinding.length) {
object.initializationBinding = [];
for (var j = 0; j < message.initializationBinding.length; ++j)
object.initializationBinding[j] = $root.onnx.StringStringEntryProto.toObject(
message.initializationBinding[j],
options
);
}
if (message.updateBinding && message.updateBinding.length) {
object.updateBinding = [];
for (var j = 0; j < message.updateBinding.length; ++j)
object.updateBinding[j] = $root.onnx.StringStringEntryProto.toObject(message.updateBinding[j], options);
}
return object;
};
TrainingInfoProto.prototype.toJSON = function toJSON() {
return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
};
TrainingInfoProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
if (typeUrlPrefix === void 0) {
typeUrlPrefix = "type.googleapis.com";
}
return typeUrlPrefix + "/onnx.TrainingInfoProto";
};
return TrainingInfoProto;
}();
onnx6.ModelProto = function() {
function ModelProto(properties) {
this.opsetImport = [];
this.metadataProps = [];
this.trainingInfo = [];
this.functions = [];
if (properties) {
for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
if (properties[keys[i]] != null)
this[keys[i]] = properties[keys[i]];
}
}
ModelProto.prototype.irVersion = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;
ModelProto.prototype.opsetImport = $util.emptyArray;
ModelProto.prototype.producerName = "";
ModelProto.prototype.producerVersion = "";
ModelProto.prototype.domain = "";
ModelProto.prototype.modelVersion = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;
ModelProto.prototype.docString = "";
ModelProto.prototype.graph = null;
ModelProto.prototype.metadataProps = $util.emptyArray;
ModelProto.prototype.trainingInfo = $util.emptyArray;
ModelProto.prototype.functions = $util.emptyArray;
ModelProto.create = function create(properties) {
return new ModelProto(properties);
};
ModelProto.encode = function encode(message, writer) {
if (!writer)
writer = $Writer.create();
if (message.irVersion != null && Object.hasOwnProperty.call(message, "irVersion"))
writer.uint32(
/* id 1, wireType 0 =*/
8
).int64(message.irVersion);
if (message.producerName != null && Object.hasOwnProperty.call(message, "producerName"))
writer.uint32(
/* id 2, wireType 2 =*/
18
).string(message.producerName);
if (message.producerVersion != null && Object.hasOwnProperty.call(message, "producerVersion"))
writer.uint32(
/* id 3, wireType 2 =*/
26
).string(message.producerVersion);
if (message.domain != null && Object.hasOwnProperty.call(message, "domain"))
writer.uint32(
/* id 4, wireType 2 =*/
34
).string(message.domain);
if (message.modelVersion != null && Object.hasOwnProperty.call(message, "modelVersion"))
writer.uint32(
/* id 5, wireType 0 =*/
40
).int64(message.modelVersion);
if (message.docString != null && Object.hasOwnProperty.call(message, "docString"))
writer.uint32(
/* id 6, wireType 2 =*/
50
).string(message.docString);
if (message.graph != null && Object.hasOwnProperty.call(message, "graph"))
$root.onnx.GraphProto.encode(message.graph, writer.uint32(
/* id 7, wireType 2 =*/
58
).fork()).ldelim();
if (message.opsetImport != null && message.opsetImport.length)
for (var i = 0; i < message.opsetImport.length; ++i)
$root.onnx.OperatorSetIdProto.encode(
message.opsetImport[i],
writer.uint32(
/* id 8, wireType 2 =*/
66
).fork()
).ldelim();
if (message.metadataProps != null && message.metadataProps.length)
for (var i = 0; i < message.metadataProps.length; ++i)
$root.onnx.StringStringEntryProto.encode(
message.metadataProps[i],
writer.uint32(
/* id 14, wireType 2 =*/
114
).fork()
).ldelim();
if (message.trainingInfo != null && message.trainingInfo.length)
for (var i = 0; i < message.trainingInfo.length; ++i)
$root.onnx.TrainingInfoProto.encode(
message.trainingInfo[i],
writer.uint32(
/* id 20, wireType 2 =*/
162
).fork()
).ldelim();
if (message.functions != null && message.functions.length)
for (var i = 0; i < message.functions.length; ++i)
$root.onnx.FunctionProto.encode(
message.functions[i],
writer.uint32(
/* id 25, wireType 2 =*/
202
).fork()
).ldelim();
return writer;
};
ModelProto.encodeDelimited = function encodeDelimited(message, writer) {
return this.encode(message, writer).ldelim();
};
ModelProto.decode = function decode(reader, length) {
if (!(reader instanceof $Reader))
reader = $Reader.create(reader);
var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.onnx.ModelProto();
while (reader.pos < end) {
var tag = reader.uint32();
switch (tag >>> 3) {
case 1: {
message.irVersion = reader.int64();
break;
}
case 8: {
if (!(message.opsetImport && message.opsetImport.length))
message.opsetImport = [];
message.opsetImport.push($root.onnx.OperatorSetIdProto.decode(reader, reader.uint32()));
break;
}
case 2: {
message.producerName = reader.string();
break;
}
case 3: {
message.producerVersion = reader.string();
break;
}
case 4: {
message.domain = reader.string();
break;
}
case 5: {
message.modelVersion = reader.int64();
break;
}
case 6: {
message.docString = reader.string();
break;
}
case 7: {
message.graph = $root.onnx.GraphProto.decode(reader, reader.uint32());
break;
}
case 14: {
if (!(message.metadataProps && message.metadataProps.length))
message.metadataProps = [];
message.metadataProps.push($root.onnx.StringStringEntryProto.decode(reader, reader.uint32()));
break;
}
case 20: {
if (!(message.trainingInfo && message.trainingInfo.length))
message.trainingInfo = [];
message.trainingInfo.push($root.onnx.TrainingInfoProto.decode(reader, reader.uint32()));
break;
}
case 25: {
if (!(message.functions && message.functions.length))
message.functions = [];
message.functions.push($root.onnx.FunctionProto.decode(reader, reader.uint32()));
break;
}
default:
reader.skipType(tag & 7);
break;
}
}
return message;
};
ModelProto.decodeDelimited = function decodeDelimited(reader) {
if (!(reader instanceof $Reader))
reader = new $Reader(reader);
return this.decode(reader, reader.uint32());
};
ModelProto.verify = function verify(message) {
if (typeof message !== "object" || message === null)
return "object expected";
if (message.irVersion != null && message.hasOwnProperty("irVersion")) {
if (!$util.isInteger(message.irVersion) && !(message.irVersion && $util.isInteger(message.irVersion.low) && $util.isInteger(message.irVersion.high)))
return "irVersion: integer|Long expected";
}
if (message.opsetImport != null && message.hasOwnProperty("opsetImport")) {
if (!Array.isArray(message.opsetImport))
return "opsetImport: array expected";
for (var i = 0; i < message.opsetImport.length; ++i) {
var error = $root.onnx.OperatorSetIdProto.verify(message.opsetImport[i]);
if (error)
return "opsetImport." + error;
}
}
if (message.producerName != null && message.hasOwnProperty("producerName")) {
if (!$util.isString(message.producerName))
return "producerName: string expected";
}
if (message.producerVersion != null && message.hasOwnProperty("producerVersion")) {
if (!$util.isString(message.producerVersion))
return "producerVersion: string expected";
}
if (message.domain != null && message.hasOwnProperty("domain")) {
if (!$util.isString(message.domain))
return "domain: string expected";
}
if (message.modelVersion != null && message.hasOwnProperty("modelVersion")) {
if (!$util.isInteger(message.modelVersion) && !(message.modelVersion && $util.isInteger(message.modelVersion.low) && $util.isInteger(message.modelVersion.high)))
return "modelVersion: integer|Long expected";
}
if (message.docString != null && message.hasOwnProperty("docString")) {
if (!$util.isString(message.docString))
return "docString: string expected";
}
if (message.graph != null && message.hasOwnProperty("graph")) {
var error = $root.onnx.GraphProto.verify(message.graph);
if (error)
return "graph." + error;
}
if (message.metadataProps != null && message.hasOwnProperty("metadataProps")) {
if (!Array.isArray(message.metadataProps))
return "metadataProps: array expected";
for (var i = 0; i < message.metadataProps.length; ++i) {
var error = $root.onnx.StringStringEntryProto.verify(message.metadataProps[i]);
if (error)
return "metadataProps." + error;
}
}
if (message.trainingInfo != null && message.hasOwnProperty("trainingInfo")) {
if (!Array.isArray(message.trainingInfo))
return "trainingInfo: array expected";
for (var i = 0; i < message.trainingInfo.length; ++i) {
var error = $root.onnx.TrainingInfoProto.verify(message.trainingInfo[i]);
if (error)
return "trainingInfo." + error;
}
}
if (message.functions != null && message.hasOwnProperty("functions")) {
if (!Array.isArray(message.functions))
return "functions: array expected";
for (var i = 0; i < message.functions.length; ++i) {
var error = $root.onnx.FunctionProto.verify(message.functions[i]);
if (error)
return "functions." + error;
}
}
return null;
};
ModelProto.fromObject = function fromObject(object) {
if (object instanceof $root.onnx.ModelProto)
return object;
var message = new $root.onnx.ModelProto();
if (object.irVersion != null) {
if ($util.Long)
(message.irVersion = $util.Long.fromValue(object.irVersion)).unsigned = false;
else if (typeof object.irVersion === "string")
message.irVersion = parseInt(object.irVersion, 10);
else if (typeof object.irVersion === "number")
message.irVersion = object.irVersion;
else if (typeof object.irVersion === "object")
message.irVersion = new $util.LongBits(object.irVersion.low >>> 0, object.irVersion.high >>> 0).toNumber();
