diff --git "a/ort/ort.webgl.mjs" "b/ort/ort.webgl.mjs"
new file mode 100644--- /dev/null
+++ "b/ort/ort.webgl.mjs"
@@ -0,0 +1,25754 @@
+/*!
+ * ONNX Runtime Web v1.30.0
+ * 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, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __commonJS = (cb, mod) => function __require2() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+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 = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __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 || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// common/dist/esm/backend-impl.js
+var backends, backendsSortedByPriority, registerBackend, tryResolveAndInitializeBackend, resolveBackendAndExecutionProviders;
+var init_backend_impl = __esm({
+  "common/dist/esm/backend-impl.js"() {
+    "use strict";
+    backends = /* @__PURE__ */ new Map();
+    backendsSortedByPriority = [];
+    registerBackend = (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.30.0";
+  }
+});
+
+// common/dist/esm/env-impl.js
+var logLevelValue, env;
+var init_env_impl = __esm({
+  "common/dist/esm/env-impl.js"() {
+    "use strict";
+    init_version();
+    logLevelValue = "warning";
+    env = {
+      wasm: {},
+      webgl: {},
+      webgpu: {},
+      versions: { common: version },
+      set logLevel(value) {
+        if (value === void 0) {
+          return;
+        }
+        if (typeof value !== "string" || ["verbose", "info", "warning", "error", "fatal"].indexOf(value) === -1) {
+          throw new Error(`Unsupported logging level: ${value}`);
+        }
+        logLevelValue = value;
+      },
+      get logLevel() {
+        return logLevelValue;
+      }
+    };
+    Object.defineProperty(env, "logLevel", { enumerable: true });
+  }
+});
+
+// common/dist/esm/env.js
+var env2;
+var init_env = __esm({
+  "common/dist/esm/env.js"() {
+    "use strict";
+    init_env_impl();
+    env2 = env;
+  }
+});
+
+// common/dist/esm/tensor-conversion-impl.js
+var tensorToDataURL, tensorToImageData;
+var init_tensor_conversion_impl = __esm({
+  "common/dist/esm/tensor-conversion-impl.js"() {
+    "use strict";
+    tensorToDataURL = (tensor, options) => {
+      const canvas = typeof document !== "undefined" ? document.createElement("canvas") : new OffscreenCanvas(1, 1);
+      canvas.width = tensor.dims[3];
+      canvas.height = tensor.dims[2];
+      const pixels2DContext = canvas.getContext("2d");
+      if (pixels2DContext != null) {
+        let width;
+        let height;
+        if (options?.tensorLayout !== void 0 && options.tensorLayout === "NHWC") {
+          width = tensor.dims[2];
+          height = tensor.dims[3];
+        } else {
+          width = tensor.dims[3];
+          height = tensor.dims[2];
+        }
+        const inputformat = options?.format !== void 0 ? options.format : "RGB";
+        const norm = options?.norm;
+        let normMean;
+        let normBias;
+        if (norm === void 0 || norm.mean === void 0) {
+          normMean = [255, 255, 255, 255];
+        } else {
+          if (typeof norm.mean === "number") {
+            normMean = [norm.mean, norm.mean, norm.mean, norm.mean];
+          } else {
+            normMean = [norm.mean[0], norm.mean[1], norm.mean[2], 0];
+            if (norm.mean[3] !== void 0) {
+              normMean[3] = norm.mean[3];
+            }
+          }
+        }
+        if (norm === void 0 || norm.bias === void 0) {
+          normBias = [0, 0, 0, 0];
+        } else {
+          if (typeof norm.bias === "number") {
+            normBias = [norm.bias, norm.bias, norm.bias, norm.bias];
+          } else {
+            normBias = [norm.bias[0], norm.bias[1], norm.bias[2], 0];
+            if (norm.bias[3] !== void 0) {
+              normBias[3] = norm.bias[3];
+            }
+          }
+        }
+        const stride = height * width;
+        let rTensorPointer = 0, gTensorPointer = stride, bTensorPointer = stride * 2, aTensorPointer = -1;
+        if (inputformat === "RGBA") {
+          rTensorPointer = 0;
+          gTensorPointer = stride;
+          bTensorPointer = stride * 2;
+          aTensorPointer = stride * 3;
+        } else if (inputformat === "RGB") {
+          rTensorPointer = 0;
+          gTensorPointer = stride;
+          bTensorPointer = stride * 2;
+        } else if (inputformat === "RBG") {
+          rTensorPointer = 0;
+          bTensorPointer = stride;
+          gTensorPointer = stride * 2;
+        }
+        for (let i = 0; i < height; i++) {
+          for (let j = 0; j < width; j++) {
+            const R = (tensor.data[rTensorPointer++] - normBias[0]) * normMean[0];
+            const G = (tensor.data[gTensorPointer++] - normBias[1]) * normMean[1];
+            const B = (tensor.data[bTensorPointer++] - normBias[2]) * normMean[2];
+            const A = aTensorPointer === -1 ? 255 : (tensor.data[aTensorPointer++] - normBias[3]) * normMean[3];
+            pixels2DContext.fillStyle = "rgba(" + R + "," + G + "," + B + "," + A + ")";
+            pixels2DContext.fillRect(j, i, 1, 1);
+          }
+        }
+        if ("toDataURL" in canvas) {
+          return canvas.toDataURL();
+        } else {
+          throw new Error("toDataURL is not supported");
+        }
+      } else {
+        throw new Error("Can not access image data");
+      }
+    };
+    tensorToImageData = (tensor, options) => {
+      const pixels2DContext = typeof document !== "undefined" ? document.createElement("canvas").getContext("2d") : new OffscreenCanvas(1, 1).getContext("2d");
+      let image;
+      if (pixels2DContext != null) {
+        let width;
+        let height;
+        let channels;
+        if (options?.tensorLayout !== void 0 && options.tensorLayout === "NHWC") {
+          width = tensor.dims[2];
+          height = tensor.dims[1];
+          channels = tensor.dims[3];
+        } else {
+          width = tensor.dims[3];
+          height = tensor.dims[2];
+          channels = tensor.dims[1];
+        }
+        const inputformat = options !== void 0 ? options.format !== void 0 ? options.format : "RGB" : "RGB";
+        const norm = options?.norm;
+        let normMean;
+        let normBias;
+        if (norm === void 0 || norm.mean === void 0) {
+          normMean = [255, 255, 255, 255];
+        } else {
+          if (typeof norm.mean === "number") {
+            normMean = [norm.mean, norm.mean, norm.mean, norm.mean];
+          } else {
+            normMean = [norm.mean[0], norm.mean[1], norm.mean[2], 255];
+            if (norm.mean[3] !== void 0) {
+              normMean[3] = norm.mean[3];
+            }
+          }
+        }
+        if (norm === void 0 || norm.bias === void 0) {
+          normBias = [0, 0, 0, 0];
+        } else {
+          if (typeof norm.bias === "number") {
+            normBias = [norm.bias, norm.bias, norm.bias, norm.bias];
+          } else {
+            normBias = [norm.bias[0], norm.bias[1], norm.bias[2], 0];
+            if (norm.bias[3] !== void 0) {
+              normBias[3] = norm.bias[3];
+            }
+          }
+        }
+        const stride = height * width;
+        if (options !== void 0) {
+          if (options.format !== void 0 && channels === 4 && options.format !== "RGBA" || channels === 3 && options.format !== "RGB" && options.format !== "BGR") {
+            throw new Error("Tensor format doesn't match input tensor dims");
+          }
+        }
+        const step = 4;
+        let rImagePointer = 0, gImagePointer = 1, bImagePointer = 2, aImagePointer = 3;
+        let rTensorPointer = 0, gTensorPointer = stride, bTensorPointer = stride * 2, aTensorPointer = -1;
+        if (inputformat === "RGBA") {
+          rTensorPointer = 0;
+          gTensorPointer = stride;
+          bTensorPointer = stride * 2;
+          aTensorPointer = stride * 3;
+        } else if (inputformat === "RGB") {
+          rTensorPointer = 0;
+          gTensorPointer = stride;
+          bTensorPointer = stride * 2;
+        } else if (inputformat === "RBG") {
+          rTensorPointer = 0;
+          bTensorPointer = stride;
+          gTensorPointer = stride * 2;
+        }
+        image = pixels2DContext.createImageData(width, height);
+        for (let i = 0; i < height * width; rImagePointer += step, gImagePointer += step, bImagePointer += step, aImagePointer += step, i++) {
+          image.data[rImagePointer] = (tensor.data[rTensorPointer++] - normBias[0]) * normMean[0];
+          image.data[gImagePointer] = (tensor.data[gTensorPointer++] - normBias[1]) * normMean[1];
+          image.data[bImagePointer] = (tensor.data[bTensorPointer++] - normBias[2]) * normMean[2];
+          image.data[aImagePointer] = aTensorPointer === -1 ? 255 : (tensor.data[aTensorPointer++] - normBias[3]) * normMean[3];
+        }
+      } else {
+        throw new Error("Can not access image data");
+      }
+      return image;
+    };
+  }
+});
+
+// common/dist/esm/tensor-factory-impl.js
+var bufferToTensor, tensorFromImage, tensorFromTexture, tensorFromGpuBuffer, tensorFromMLTensor, tensorFromPinnedBuffer;
+var init_tensor_factory_impl = __esm({
+  "common/dist/esm/tensor-factory-impl.js"() {
+    "use strict";
+    init_tensor_impl();
+    bufferToTensor = (buffer, options) => {
+      if (buffer === void 0) {
+        throw new Error("Image buffer must be defined");
+      }
+      if (options.height === void 0 || options.width === void 0) {
+        throw new Error("Image height and width must be defined");
+      }
+      if (options.tensorLayout === "NHWC") {
+        throw new Error("NHWC Tensor layout is not supported yet");
+      }
+      const { height, width } = options;
+      const norm = options.norm ?? { mean: 255, bias: 0 };
+      let normMean;
+      let normBias;
+      if (typeof norm.mean === "number") {
+        normMean = [norm.mean, norm.mean, norm.mean, norm.mean];
+      } else {
+        normMean = [norm.mean[0], norm.mean[1], norm.mean[2], norm.mean[3] ?? 255];
+      }
+      if (typeof norm.bias === "number") {
+        normBias = [norm.bias, norm.bias, norm.bias, norm.bias];
+      } else {
+        normBias = [norm.bias[0], norm.bias[1], norm.bias[2], norm.bias[3] ?? 0];
+      }
+      const inputformat = options.format !== void 0 ? options.format : "RGBA";
+      const outputformat = options.tensorFormat !== void 0 ? options.tensorFormat !== void 0 ? options.tensorFormat : "RGB" : "RGB";
+      const stride = height * width;
+      const float32Data = outputformat === "RGBA" ? new Float32Array(stride * 4) : new Float32Array(stride * 3);
+      let step = 4, rImagePointer = 0, gImagePointer = 1, bImagePointer = 2, aImagePointer = 3;
+      let rTensorPointer = 0, gTensorPointer = stride, bTensorPointer = stride * 2, aTensorPointer = -1;
+      if (inputformat === "RGB") {
+        step = 3;
+        rImagePointer = 0;
+        gImagePointer = 1;
+        bImagePointer = 2;
+        aImagePointer = -1;
+      }
+      if (outputformat === "RGBA") {
+        aTensorPointer = stride * 3;
+      } else if (outputformat === "RBG") {
+        rTensorPointer = 0;
+        bTensorPointer = stride;
+        gTensorPointer = stride * 2;
+      } else if (outputformat === "BGR") {
+        bTensorPointer = 0;
+        gTensorPointer = stride;
+        rTensorPointer = stride * 2;
+      }
+      for (let i = 0; i < stride; i++, rImagePointer += step, bImagePointer += step, gImagePointer += step, aImagePointer += step) {
+        float32Data[rTensorPointer++] = (buffer[rImagePointer] + normBias[0]) / normMean[0];
+        float32Data[gTensorPointer++] = (buffer[gImagePointer] + normBias[1]) / normMean[1];
+        float32Data[bTensorPointer++] = (buffer[bImagePointer] + normBias[2]) / normMean[2];
+        if (aTensorPointer !== -1 && aImagePointer !== -1) {
+          float32Data[aTensorPointer++] = (buffer[aImagePointer] + normBias[3]) / normMean[3];
+        }
+      }
+      const outputTensor = outputformat === "RGBA" ? new Tensor("float32", float32Data, [1, 4, height, width]) : new Tensor("float32", float32Data, [1, 3, height, width]);
+      return outputTensor;
+    };
+    tensorFromImage = async (image, options) => {
+      const isHTMLImageEle = typeof HTMLImageElement !== "undefined" && image instanceof HTMLImageElement;
+      const isImageDataEle = typeof ImageData !== "undefined" && image instanceof ImageData;
+      const isImageBitmap = typeof ImageBitmap !== "undefined" && image instanceof ImageBitmap;
+      const isString = typeof image === "string";
+      let data;
+      let bufferToTensorOptions = options ?? {};
+      const 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 Float16Array = globalThis.Float16Array;
+        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" && type !== "uint4" && type !== "int4") {
+                throw new TypeError(`unsupported type "${type}" to create tensor from MLTensor`);
+              }
+              this.mlTensorData = arg0.mlTensor;
+              this.downloader = arg0.download;
+              this.disposer = arg0.dispose;
+              break;
+            }
+            default:
+              throw new Error(`Tensor constructor: unsupported location '${this.dataLocation}'`);
+          }
+        } else {
+          let data;
+          let maybeDims;
+          if (typeof arg0 === "string") {
+            type = arg0;
+            maybeDims = arg2;
+            if (arg0 === "string") {
+              if (!Array.isArray(arg1)) {
+                throw new TypeError("A string tensor's data must be a string array.");
+              }
+              data = arg1;
+            } else {
+              const typedArrayConstructor = NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.get(arg0);
+              if (typedArrayConstructor === void 0) {
+                throw new TypeError(`Unsupported tensor type: ${arg0}.`);
+              }
+              if (Array.isArray(arg1)) {
+                if (arg0 === "float16" && typedArrayConstructor === Uint16Array || arg0 === "uint4" || arg0 === "int4") {
+                  throw new TypeError(`Creating a ${arg0} tensor from number array is not supported. Please use ${typedArrayConstructor.name} as data.`);
+                } else if (arg0 === "uint64" || arg0 === "int64") {
+                  data = typedArrayConstructor.from(arg1, BigInt);
+                } else {
+                  data = typedArrayConstructor.from(arg1);
+                }
+              } else if (arg1 instanceof typedArrayConstructor) {
+                data = arg1;
+              } else if (arg1 instanceof Uint8ClampedArray) {
+                if (arg0 === "uint8") {
+                  data = Uint8Array.from(arg1);
+                } else {
+                  throw new TypeError(`A Uint8ClampedArray tensor's data must be type of uint8`);
+                }
+              } else if (arg0 === "float16" && arg1 instanceof Uint16Array && typedArrayConstructor !== Uint16Array) {
+                data = new globalThis.Float16Array(arg1.buffer, arg1.byteOffset, arg1.length);
+              } else {
+                throw new TypeError(`A ${type} tensor's data must be type of ${typedArrayConstructor}`);
+              }
+            }
+          } else {
+            maybeDims = arg1;
+            if (Array.isArray(arg0)) {
+              if (arg0.length === 0) {
+                throw new TypeError("Tensor type cannot be inferred from an empty array.");
+              }
+              const firstElementType = typeof arg0[0];
+              if (firstElementType === "string") {
+                type = "string";
+                data = arg0;
+              } else if (firstElementType === "boolean") {
+                type = "bool";
+                data = Uint8Array.from(arg0);
+              } else {
+                throw new TypeError(`Invalid element type of data array: ${firstElementType}.`);
+              }
+            } else if (arg0 instanceof Uint8ClampedArray) {
+              type = "uint8";
+              data = Uint8Array.from(arg0);
+            } else {
+              const mappedType = NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.get(arg0.constructor);
+              if (mappedType === void 0) {
+                throw new TypeError(`Unsupported type for tensor data: ${arg0.constructor}.`);
+              }
+              type = mappedType;
+              data = arg0;
+            }
+          }
+          if (maybeDims === void 0) {
+            maybeDims = [data.length];
+          } else if (!Array.isArray(maybeDims)) {
+            throw new TypeError("A tensor's dims must be a number array");
+          }
+          dims = maybeDims;
+          this.cpuData = data;
+          this.dataLocation = "cpu";
+        }
+        const size = calculateSize(dims);
+        if (this.cpuData && size !== this.cpuData.length) {
+          if ((type === "uint4" || type === "int4") && Math.ceil(size / 2) === this.cpuData.length) {
+          } else {
+            throw new Error(`Tensor's size(${size}) does not match data length(${this.cpuData.length}).`);
+          }
+        }
+        this.type = type;
+        this.dims = dims;
+        this.size = size;
+      }
+      // #endregion
+      // #region factory
+      static async fromImage(image, options) {
+        return tensorFromImage(image, options);
+      }
+      static fromTexture(texture, options) {
+        return tensorFromTexture(texture, options);
+      }
+      static fromGpuBuffer(gpuBuffer, options) {
+        return tensorFromGpuBuffer(gpuBuffer, options);
+      }
+      static fromMLTensor(mlTensor, options) {
+        return tensorFromMLTensor(mlTensor, options);
+      }
+      static fromPinnedBuffer(type, buffer, dims) {
+        return tensorFromPinnedBuffer(type, buffer, dims);
+      }
+      // #endregion
+      // #region conversions
+      toDataURL(options) {
+        return tensorToDataURL(this, options);
+      }
+      toImageData(options) {
+        return tensorToImageData(this, options);
+      }
+      // #endregion
+      // #region properties
+      get data() {
+        this.ensureValid();
+        if (!this.cpuData) {
+          throw new Error("The data is not on CPU. Use `getData()` to download GPU data to CPU, or use `texture` or `gpuBuffer` property to access the GPU data directly.");
+        }
+        return this.cpuData;
+      }
+      get location() {
+        return this.dataLocation;
+      }
+      get texture() {
+        this.ensureValid();
+        if (!this.gpuTextureData) {
+          throw new Error("The data is not stored as a WebGL texture.");
+        }
+        return this.gpuTextureData;
+      }
+      get gpuBuffer() {
+        this.ensureValid();
+        if (!this.gpuBufferData) {
+          throw new Error("The data is not stored as a WebGPU buffer.");
+        }
+        return this.gpuBufferData;
+      }
+      get mlTensor() {
+        this.ensureValid();
+        if (!this.mlTensorData) {
+          throw new Error("The data is not stored as a WebNN MLTensor.");
+        }
+        return this.mlTensorData;
+      }
+      // #endregion
+      // #region methods
+      async getData(releaseData) {
+        this.ensureValid();
+        switch (this.dataLocation) {
+          case "cpu":
+          case "cpu-pinned":
+            return this.data;
+          case "texture":
+          case "gpu-buffer":
+          case "ml-tensor": {
+            if (!this.downloader) {
+              throw new Error("The current tensor is not created with a specified data downloader.");
+            }
+            if (this.isDownloading) {
+              throw new Error("The current tensor is being downloaded.");
+            }
+            try {
+              this.isDownloading = true;
+              const data = await this.downloader();
+              this.downloader = void 0;
+              this.dataLocation = "cpu";
+              this.cpuData = data;
+              if (releaseData && this.disposer) {
+                this.disposer();
+                this.disposer = void 0;
+              }
+              return data;
+            } finally {
+              this.isDownloading = false;
+            }
+          }
+          default:
+            throw new Error(`cannot get data from location: ${this.dataLocation}`);
+        }
+      }
+      dispose() {
+        if (this.isDownloading) {
+          throw new Error("The current tensor is being downloaded.");
+        }
+        if (this.disposer) {
+          this.disposer();
+          this.disposer = void 0;
+        }
+        this.cpuData = void 0;
+        this.gpuTextureData = void 0;
+        this.gpuBufferData = void 0;
+        this.mlTensorData = void 0;
+        this.downloader = void 0;
+        this.isDownloading = void 0;
+        this.dataLocation = "none";
+      }
+      // #endregion
+      // #region tensor utilities
+      ensureValid() {
+        if (this.dataLocation === "none") {
+          throw new Error("The tensor is disposed.");
+        }
+      }
+      reshape(dims) {
+        this.ensureValid();
+        if (this.downloader || this.disposer) {
+          throw new Error("Cannot reshape a tensor that owns GPU resource.");
+        }
+        return tensorReshape(this, dims);
+      }
+    };
+  }
+});
+
+// common/dist/esm/tensor.js
+var Tensor2;
+var init_tensor = __esm({
+  "common/dist/esm/tensor.js"() {
+    "use strict";
+    init_tensor_impl();
+    Tensor2 = Tensor;
+  }
+});
+
+// common/dist/esm/trace.js
+var TRACE, TRACE_FUNC, TRACE_FUNC_BEGIN, TRACE_FUNC_END, TRACE_EVENT_BEGIN, TRACE_EVENT_END;
+var init_trace = __esm({
+  "common/dist/esm/trace.js"() {
+    "use strict";
+    init_env_impl();
+    TRACE = (deviceType, label) => {
+      if (typeof env.trace === "undefined" ? !env.wasm.trace : !env.trace) {
+        return;
+      }
+      console.timeStamp(`${deviceType}::ORT::${label}`);
+    };
+    TRACE_FUNC = (msg, extraMsg) => {
+      const stack = new Error().stack?.split(/\r\n|\r|\n/g) || [];
+      let hasTraceFunc = false;
+      for (let i = 0; i < stack.length; i++) {
+        if (hasTraceFunc && !stack[i].includes("TRACE_FUNC")) {
+          let label = `FUNC_${msg}::${stack[i].trim().split(" ")[1]}`;
+          if (extraMsg) {
+            label += `::${extraMsg}`;
+          }
+          TRACE("CPU", label);
+          return;
+        }
+        if (stack[i].includes("TRACE_FUNC")) {
+          hasTraceFunc = true;
+        }
+      }
+    };
+    TRACE_FUNC_BEGIN = (extraMsg) => {
+      if (typeof env.trace === "undefined" ? !env.wasm.trace : !env.trace) {
+        return;
+      }
+      TRACE_FUNC("BEGIN", extraMsg);
+    };
+    TRACE_FUNC_END = (extraMsg) => {
+      if (typeof env.trace === "undefined" ? !env.wasm.trace : !env.trace) {
+        return;
+      }
+      TRACE_FUNC("END", extraMsg);
+    };
+    TRACE_EVENT_BEGIN = (extraMsg) => {
+      if (typeof env.trace === "undefined" ? !env.wasm.trace : !env.trace) {
+        return;
+      }
+      console.time(`ORT::${extraMsg}`);
+    };
+    TRACE_EVENT_END = (extraMsg) => {
+      if (typeof env.trace === "undefined" ? !env.wasm.trace : !env.trace) {
+        return;
+      }
+      console.timeEnd(`ORT::${extraMsg}`);
+    };
+  }
+});
+
+// common/dist/esm/inference-session-impl.js
+var InferenceSession;
+var init_inference_session_impl = __esm({
+  "common/dist/esm/inference-session-impl.js"() {
+    "use strict";
+    init_backend_impl();
+    init_tensor();
+    init_trace();
+    InferenceSession = class _InferenceSession {
+      constructor(handler) {
+        this.handler = handler;
+      }
+      async run(feeds, arg1, arg2) {
+        TRACE_FUNC_BEGIN();
+        TRACE_EVENT_BEGIN("InferenceSession.run");
+        const fetches = {};
+        let options = {};
+        if (typeof feeds !== "object" || feeds === null || feeds instanceof Tensor2 || Array.isArray(feeds)) {
+          throw new TypeError("'feeds' must be an object that use input names as keys and OnnxValue as corresponding values.");
+        }
+        let isFetchesEmpty = true;
+        if (typeof arg1 === "object") {
+          if (arg1 === null) {
+            throw new TypeError("Unexpected argument[1]: cannot be null.");
+          }
+          if (arg1 instanceof Tensor2) {
+            throw new TypeError("'fetches' cannot be a Tensor");
+          }
+          if (Array.isArray(arg1)) {
+            if (arg1.length === 0) {
+              throw new TypeError("'fetches' cannot be an empty array.");
+            }
+            isFetchesEmpty = false;
+            for (const 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_EVENT_END("InferenceSession.run");
+        TRACE_FUNC_END();
+        return returnValue;
+      }
+      async release() {
+        return this.handler.dispose();
+      }
+      static async create(arg0, arg1, arg2, arg3) {
+        TRACE_FUNC_BEGIN();
+        TRACE_EVENT_BEGIN("InferenceSession.create");
+        let filePathOrUint8Array;
+        let options = {};
+        if (typeof arg0 === "string") {
+          filePathOrUint8Array = arg0;
+          if (typeof arg1 === "object" && arg1 !== null) {
+            options = arg1;
+          } else if (typeof arg1 !== "undefined") {
+            throw new TypeError("'options' must be an object.");
+          }
+        } else if (arg0 instanceof Uint8Array) {
+          filePathOrUint8Array = arg0;
+          if (typeof arg1 === "object" && arg1 !== null) {
+            options = arg1;
+          } else if (typeof arg1 !== "undefined") {
+            throw new TypeError("'options' must be an object.");
+          }
+        } else if (arg0 instanceof ArrayBuffer || typeof SharedArrayBuffer !== "undefined" && arg0 instanceof SharedArrayBuffer) {
+          const buffer = arg0;
+          let byteOffset = 0;
+          let byteLength = arg0.byteLength;
+          if (typeof arg1 === "object" && arg1 !== null) {
+            options = arg1;
+          } else if (typeof arg1 === "number") {
+            byteOffset = arg1;
+            if (!Number.isSafeInteger(byteOffset)) {
+              throw new RangeError("'byteOffset' must be an integer.");
+            }
+            if (byteOffset < 0 || byteOffset >= buffer.byteLength) {
+              throw new RangeError(`'byteOffset' is out of range [0, ${buffer.byteLength}).`);
+            }
+            byteLength = arg0.byteLength - byteOffset;
+            if (typeof arg2 === "number") {
+              byteLength = arg2;
+              if (!Number.isSafeInteger(byteLength)) {
+                throw new RangeError("'byteLength' must be an integer.");
+              }
+              if (byteLength <= 0 || byteOffset + byteLength > buffer.byteLength) {
+                throw new RangeError(`'byteLength' is out of range (0, ${buffer.byteLength - byteOffset}].`);
+              }
+              if (typeof arg3 === "object" && arg3 !== null) {
+                options = arg3;
+              } else if (typeof arg3 !== "undefined") {
+                throw new TypeError("'options' must be an object.");
+              }
+            } else if (typeof arg2 !== "undefined") {
+              throw new TypeError("'byteLength' must be a number.");
+            }
+          } else if (typeof arg1 !== "undefined") {
+            throw new TypeError("'options' must be an object.");
+          }
+          filePathOrUint8Array = new Uint8Array(buffer, byteOffset, byteLength);
+        } else {
+          throw new TypeError("Unexpected argument[0]: must be 'path' or 'buffer'.");
+        }
+        const [backend2, optionsWithValidatedEPs] = await resolveBackendAndExecutionProviders(options);
+        const handler = await backend2.createInferenceSessionHandler(filePathOrUint8Array, optionsWithValidatedEPs);
+        TRACE_EVENT_END("InferenceSession.create");
+        TRACE_FUNC_END();
+        return new _InferenceSession(handler);
+      }
+      startProfiling() {
+        this.handler.startProfiling();
+      }
+      endProfiling() {
+        this.handler.endProfiling();
+      }
+      get inputNames() {
+        return this.handler.inputNames;
+      }
+      get outputNames() {
+        return this.handler.outputNames;
+      }
+      get inputMetadata() {
+        return this.handler.inputMetadata;
+      }
+      get outputMetadata() {
+        return this.handler.outputMetadata;
+      }
+    };
+  }
+});
+
+// common/dist/esm/inference-session.js
+var InferenceSession2;
+var init_inference_session = __esm({
+  "common/dist/esm/inference-session.js"() {
+    "use strict";
+    init_inference_session_impl();
+    InferenceSession2 = InferenceSession;
+  }
+});
+
+// common/dist/esm/tensor-conversion.js
+var init_tensor_conversion = __esm({
+  "common/dist/esm/tensor-conversion.js"() {
+    "use strict";
+  }
+});
+
+// common/dist/esm/tensor-factory.js
+var init_tensor_factory = __esm({
+  "common/dist/esm/tensor-factory.js"() {
+    "use strict";
+  }
+});
+
+// common/dist/esm/onnx-model.js
+var init_onnx_model = __esm({
+  "common/dist/esm/onnx-model.js"() {
+    "use strict";
+  }
+});
+
+// common/dist/esm/onnx-value.js
+var init_onnx_value = __esm({
+  "common/dist/esm/onnx-value.js"() {
+    "use strict";
+  }
+});
+
+// common/dist/esm/index.js
+var esm_exports = {};
+__export(esm_exports, {
+  InferenceSession: () => InferenceSession2,
+  TRACE: () => TRACE,
+  TRACE_EVENT_BEGIN: () => TRACE_EVENT_BEGIN,
+  TRACE_EVENT_END: () => TRACE_EVENT_END,
+  TRACE_FUNC_BEGIN: () => TRACE_FUNC_BEGIN,
+  TRACE_FUNC_END: () => TRACE_FUNC_END,
+  Tensor: () => Tensor2,
+  env: () => env2,
+  registerBackend: () => registerBackend
+});
+var init_esm = __esm({
+  "common/dist/esm/index.js"() {
+    "use strict";
+    init_backend();
+    init_env();
+    init_inference_session();
+    init_tensor();
+    init_tensor_conversion();
+    init_tensor_factory();
+    init_trace();
+    init_onnx_model();
+    init_onnx_value();
+  }
+});
+
+// web/lib/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"(exports) {
+    "use strict";
+    exports.__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;
+      })()
+    );
+    exports.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([
+            // \0asm
+            0,
+            97,
+            115,
+            109,
+            // version 1
+            1,
+            0,
+            0,
+            0,
+            // section "type"
+            1,
+            13,
+            2,
+            // 0, () => i32
+            96,
+            0,
+            1,
+            127,
+            // 1, (i32, i32, i32, i32) => i32
+            96,
+            4,
+            127,
+            127,
+            127,
+            127,
+            1,
+            127,
+            // section "function"
+            3,
+            7,
+            6,
+            // 0, type 0
+            0,
+            // 1, type 1
+            1,
+            // 2, type 1
+            1,
+            // 3, type 1
+            1,
+            // 4, type 1
+            1,
+            // 5, type 1
+            1,
+            // section "global"
+            6,
+            6,
+            1,
+            // 0, "high", mutable i32
+            127,
+            1,
+            65,
+            0,
+            11,
+            // section "export"
+            7,
+            50,
+            6,
+            // 0, "mul"
+            3,
+            109,
+            117,
+            108,
+            0,
+            1,
+            // 1, "div_s"
+            5,
+            100,
+            105,
+            118,
+            95,
+            115,
+            0,
+            2,
+            // 2, "div_u"
+            5,
+            100,
+            105,
+            118,
+            95,
+            117,
+            0,
+            3,
+            // 3, "rem_s"
+            5,
+            114,
+            101,
+            109,
+            95,
+            115,
+            0,
+            4,
+            // 4, "rem_u"
+            5,
+            114,
+            101,
+            109,
+            95,
+            117,
+            0,
+            5,
+            // 5, "get_high"
+            8,
+            103,
+            101,
+            116,
+            95,
+            104,
+            105,
+            103,
+            104,
+            0,
+            0,
+            // section "code"
+            10,
+            191,
+            1,
+            6,
+            // 0, "get_high"
+            4,
+            0,
+            35,
+            0,
+            11,
+            // 1, "mul"
+            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,
+            // 2, "div_s"
+            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,
+            // 3, "div_u"
+            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,
+            // 4, "rem_s"
+            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,
+            // 5, "rem_u"
+            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 {
+    }
+    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.isSafeInteger = function isSafeInteger() {
+      var top11Bits = this.high >> 21;
+      if (!top11Bits) return true;
+      if (this.unsigned) return false;
+      return top11Bits === -1 && !(this.low === 0 && this.high === -2097152);
+    };
+    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
+      );
+    };
+    if (typeof BigInt === "function") {
+      Long.fromBigInt = function fromBigInt(value, unsigned) {
+        var lowBits = Number(BigInt.asIntN(32, value));
+        var highBits = Number(BigInt.asIntN(32, value >> BigInt(32)));
+        return fromBits(lowBits, highBits, unsigned);
+      };
+      Long.fromValue = function fromValueWithBigInt(value, unsigned) {
+        if (typeof value === "bigint") return Long.fromBigInt(value, unsigned);
+        return fromValue(value, unsigned);
+      };
+      LongPrototype.toBigInt = function toBigInt() {
+        var lowBigInt = BigInt(this.low >>> 0);
+        var highBigInt = BigInt(this.unsigned ? this.high >>> 0 : this.high);
+        return highBigInt << BigInt(32) | lowBigInt;
+      };
+    }
+    long_default = Long;
+  }
+});
+
+// web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/arg-type.js
+var require_arg_type = __commonJS({
+  "web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/arg-type.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ArgType = void 0;
+    var ArgType2;
+    (function(ArgType3) {
+      ArgType3[ArgType3["INPUT"] = 0] = "INPUT";
+      ArgType3[ArgType3["OUTPUT"] = 1] = "OUTPUT";
+    })(ArgType2 || (exports.ArgType = ArgType2 = {}));
+  }
+});
+
+// web/node_modules/flatbuffers/js/constants.js
+var require_constants = __commonJS({
+  "web/node_modules/flatbuffers/js/constants.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.SIZE_PREFIX_LENGTH = exports.FILE_IDENTIFIER_LENGTH = exports.SIZEOF_INT = exports.SIZEOF_SHORT = void 0;
+    exports.SIZEOF_SHORT = 2;
+    exports.SIZEOF_INT = 4;
+    exports.FILE_IDENTIFIER_LENGTH = 4;
+    exports.SIZE_PREFIX_LENGTH = 4;
+  }
+});
+
+// web/node_modules/flatbuffers/js/utils.js
+var require_utils = __commonJS({
+  "web/node_modules/flatbuffers/js/utils.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isLittleEndian = exports.float64 = exports.float32 = exports.int32 = void 0;
+    exports.int32 = new Int32Array(2);
+    exports.float32 = new Float32Array(exports.int32.buffer);
+    exports.float64 = new Float64Array(exports.int32.buffer);
+    exports.isLittleEndian = new Uint16Array(new Uint8Array([1, 0]).buffer)[0] === 1;
+  }
+});
+
+// web/node_modules/flatbuffers/js/encoding.js
+var require_encoding = __commonJS({
+  "web/node_modules/flatbuffers/js/encoding.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Encoding = void 0;
+    var Encoding;
+    (function(Encoding2) {
+      Encoding2[Encoding2["UTF8_BYTES"] = 1] = "UTF8_BYTES";
+      Encoding2[Encoding2["UTF16_STRING"] = 2] = "UTF16_STRING";
+    })(Encoding || (exports.Encoding = Encoding = {}));
+  }
+});
+
+// web/node_modules/flatbuffers/js/byte-buffer.js
+var require_byte_buffer = __commonJS({
+  "web/node_modules/flatbuffers/js/byte-buffer.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ByteBuffer = void 0;
+    var constants_js_1 = require_constants();
+    var encoding_js_1 = require_encoding();
+    var utils_js_1 = require_utils();
+    var ByteBuffer2 = class _ByteBuffer {
+      /**
+       * Create a new ByteBuffer with a given array of bytes (`Uint8Array`)
+       */
+      constructor(bytes_) {
+        this.bytes_ = bytes_;
+        this.position_ = 0;
+        this.text_decoder_ = new TextDecoder();
+      }
+      /**
+       * Create and allocate a new ByteBuffer with a given size.
+       */
+      static allocate(byte_size) {
+        return new _ByteBuffer(new Uint8Array(byte_size));
+      }
+      clear() {
+        this.position_ = 0;
+      }
+      /**
+       * Get the underlying `Uint8Array`.
+       */
+      bytes() {
+        return this.bytes_;
+      }
+      /**
+       * Get the buffer's position.
+       */
+      position() {
+        return this.position_;
+      }
+      /**
+       * Set the buffer's position.
+       */
+      setPosition(position) {
+        this.position_ = position;
+      }
+      /**
+       * Get the buffer's capacity.
+       */
+      capacity() {
+        return this.bytes_.length;
+      }
+      readInt8(offset) {
+        return this.readUint8(offset) << 24 >> 24;
+      }
+      readUint8(offset) {
+        return this.bytes_[offset];
+      }
+      readInt16(offset) {
+        return this.readUint16(offset) << 16 >> 16;
+      }
+      readUint16(offset) {
+        return this.bytes_[offset] | this.bytes_[offset + 1] << 8;
+      }
+      readInt32(offset) {
+        return this.bytes_[offset] | this.bytes_[offset + 1] << 8 | this.bytes_[offset + 2] << 16 | this.bytes_[offset + 3] << 24;
+      }
+      readUint32(offset) {
+        return this.readInt32(offset) >>> 0;
+      }
+      readInt64(offset) {
+        return BigInt.asIntN(64, BigInt(this.readUint32(offset)) + (BigInt(this.readUint32(offset + 4)) << BigInt(32)));
+      }
+      readUint64(offset) {
+        return BigInt.asUintN(64, BigInt(this.readUint32(offset)) + (BigInt(this.readUint32(offset + 4)) << BigInt(32)));
+      }
+      readFloat32(offset) {
+        utils_js_1.int32[0] = this.readInt32(offset);
+        return utils_js_1.float32[0];
+      }
+      readFloat64(offset) {
+        utils_js_1.int32[utils_js_1.isLittleEndian ? 0 : 1] = this.readInt32(offset);
+        utils_js_1.int32[utils_js_1.isLittleEndian ? 1 : 0] = this.readInt32(offset + 4);
+        return utils_js_1.float64[0];
+      }
+      writeInt8(offset, value) {
+        this.bytes_[offset] = value;
+      }
+      writeUint8(offset, value) {
+        this.bytes_[offset] = value;
+      }
+      writeInt16(offset, value) {
+        this.bytes_[offset] = value;
+        this.bytes_[offset + 1] = value >> 8;
+      }
+      writeUint16(offset, value) {
+        this.bytes_[offset] = value;
+        this.bytes_[offset + 1] = value >> 8;
+      }
+      writeInt32(offset, value) {
+        this.bytes_[offset] = value;
+        this.bytes_[offset + 1] = value >> 8;
+        this.bytes_[offset + 2] = value >> 16;
+        this.bytes_[offset + 3] = value >> 24;
+      }
+      writeUint32(offset, value) {
+        this.bytes_[offset] = value;
+        this.bytes_[offset + 1] = value >> 8;
+        this.bytes_[offset + 2] = value >> 16;
+        this.bytes_[offset + 3] = value >> 24;
+      }
+      writeInt64(offset, value) {
+        this.writeInt32(offset, Number(BigInt.asIntN(32, value)));
+        this.writeInt32(offset + 4, Number(BigInt.asIntN(32, value >> BigInt(32))));
+      }
+      writeUint64(offset, value) {
+        this.writeUint32(offset, Number(BigInt.asUintN(32, value)));
+        this.writeUint32(offset + 4, Number(BigInt.asUintN(32, value >> BigInt(32))));
+      }
+      writeFloat32(offset, value) {
+        utils_js_1.float32[0] = value;
+        this.writeInt32(offset, utils_js_1.int32[0]);
+      }
+      writeFloat64(offset, value) {
+        utils_js_1.float64[0] = value;
+        this.writeInt32(offset, utils_js_1.int32[utils_js_1.isLittleEndian ? 0 : 1]);
+        this.writeInt32(offset + 4, utils_js_1.int32[utils_js_1.isLittleEndian ? 1 : 0]);
+      }
+      /**
+       * Return the file identifier.   Behavior is undefined for FlatBuffers whose
+       * schema does not include a file_identifier (likely points at padding or the
+       * start of a the root vtable).
+       */
+      getBufferIdentifier() {
+        if (this.bytes_.length < this.position_ + constants_js_1.SIZEOF_INT + constants_js_1.FILE_IDENTIFIER_LENGTH) {
+          throw new Error("FlatBuffers: ByteBuffer is too short to contain an identifier.");
+        }
+        let result = "";
+        for (let i = 0; i < constants_js_1.FILE_IDENTIFIER_LENGTH; i++) {
+          result += String.fromCharCode(this.readInt8(this.position_ + constants_js_1.SIZEOF_INT + i));
+        }
+        return result;
+      }
+      /**
+       * Look up a field in the vtable, return an offset into the object, or 0 if the
+       * field is not present.
+       */
+      __offset(bb_pos, vtable_offset) {
+        const vtable = bb_pos - this.readInt32(bb_pos);
+        return vtable_offset < this.readInt16(vtable) ? this.readInt16(vtable + vtable_offset) : 0;
+      }
+      /**
+       * Initialize any Table-derived type to point to the union at the given offset.
+       */
+      __union(t, offset) {
+        t.bb_pos = offset + this.readInt32(offset);
+        t.bb = this;
+        return t;
+      }
+      /**
+       * Create a JavaScript string from UTF-8 data stored inside the FlatBuffer.
+       * This allocates a new string and converts to wide chars upon each access.
+       *
+       * To avoid the conversion to string, pass Encoding.UTF8_BYTES as the
+       * "optionalEncoding" argument. This is useful for avoiding conversion when
+       * the data will just be packaged back up in another FlatBuffer later on.
+       *
+       * @param offset
+       * @param opt_encoding Defaults to UTF16_STRING
+       */
+      __string(offset, opt_encoding) {
+        offset += this.readInt32(offset);
+        const length = this.readInt32(offset);
+        offset += constants_js_1.SIZEOF_INT;
+        const utf8bytes = this.bytes_.subarray(offset, offset + length);
+        if (opt_encoding === encoding_js_1.Encoding.UTF8_BYTES)
+          return utf8bytes;
+        else
+          return this.text_decoder_.decode(utf8bytes);
+      }
+      /**
+       * Handle unions that can contain string as its member, if a Table-derived type then initialize it,
+       * if a string then return a new one
+       *
+       * WARNING: strings are immutable in JS so we can't change the string that the user gave us, this
+       * makes the behaviour of __union_with_string different compared to __union
+       */
+      __union_with_string(o, offset) {
+        if (typeof o === "string") {
+          return this.__string(offset);
+        }
+        return this.__union(o, offset);
+      }
+      /**
+       * Retrieve the relative offset stored at "offset"
+       */
+      __indirect(offset) {
+        return offset + this.readInt32(offset);
+      }
+      /**
+       * Get the start of data of a vector whose offset is stored at "offset" in this object.
+       */
+      __vector(offset) {
+        return offset + this.readInt32(offset) + constants_js_1.SIZEOF_INT;
+      }
+      /**
+       * Get the length of a vector whose offset is stored at "offset" in this object.
+       */
+      __vector_len(offset) {
+        return this.readInt32(offset + this.readInt32(offset));
+      }
+      __has_identifier(ident) {
+        if (ident.length != constants_js_1.FILE_IDENTIFIER_LENGTH) {
+          throw new Error("FlatBuffers: file identifier must be length " + constants_js_1.FILE_IDENTIFIER_LENGTH);
+        }
+        for (let i = 0; i < constants_js_1.FILE_IDENTIFIER_LENGTH; i++) {
+          if (ident.charCodeAt(i) != this.readInt8(this.position() + constants_js_1.SIZEOF_INT + i)) {
+            return false;
+          }
+        }
+        return true;
+      }
+      /**
+       * A helper function for generating list for obj api
+       */
+      createScalarList(listAccessor, listLength) {
+        const ret = [];
+        for (let i = 0; i < listLength; ++i) {
+          const val = listAccessor(i);
+          if (val !== null) {
+            ret.push(val);
+          }
+        }
+        return ret;
+      }
+      /**
+       * A helper function for generating list for obj api
+       * @param listAccessor function that accepts an index and return data at that index
+       * @param listLength listLength
+       * @param res result list
+       */
+      createObjList(listAccessor, listLength) {
+        const ret = [];
+        for (let i = 0; i < listLength; ++i) {
+          const val = listAccessor(i);
+          if (val !== null) {
+            ret.push(val.unpack());
+          }
+        }
+        return ret;
+      }
+    };
+    exports.ByteBuffer = ByteBuffer2;
+  }
+});
+
+// web/node_modules/flatbuffers/js/builder.js
+var require_builder = __commonJS({
+  "web/node_modules/flatbuffers/js/builder.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Builder = void 0;
+    var byte_buffer_js_1 = require_byte_buffer();
+    var constants_js_1 = require_constants();
+    var Builder = class _Builder {
+      /**
+       * Create a FlatBufferBuilder.
+       */
+      constructor(opt_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;
+        this.string_maps = null;
+        this.text_encoder = new TextEncoder();
+        let initial_size;
+        if (!opt_initial_size) {
+          initial_size = 1024;
+        } else {
+          initial_size = opt_initial_size;
+        }
+        this.bb = byte_buffer_js_1.ByteBuffer.allocate(initial_size);
+        this.space = initial_size;
+      }
+      clear() {
+        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;
+        this.string_maps = null;
+      }
+      /**
+       * In order to save space, fields that are set to their default value
+       * don't get serialized into the buffer. Forcing defaults provides a
+       * way to manually disable this optimization.
+       *
+       * @param forceDefaults true always serializes default values
+       */
+      forceDefaults(forceDefaults) {
+        this.force_defaults = forceDefaults;
+      }
+      /**
+       * Get the ByteBuffer representing the FlatBuffer. Only call this after you've
+       * called finish(). The actual data starts at the ByteBuffer's current position,
+       * not necessarily at 0.
+       */
+      dataBuffer() {
+        return this.bb;
+      }
+      /**
+       * Get the bytes representing the FlatBuffer. Only call this after you've
+       * called finish().
+       */
+      asUint8Array() {
+        return this.bb.bytes().subarray(this.bb.position(), this.bb.position() + this.offset());
+      }
+      /**
+       * Prepare to write an element of `size` after `additional_bytes` have been
+       * written, e.g. if you write a string, you need to align such the int length
+       * field is aligned to 4 bytes, and the string data follows it directly. If all
+       * you need to do is alignment, `additional_bytes` will be 0.
+       *
+       * @param size This is the of the new element to write
+       * @param additional_bytes The padding size
+       */
+      prep(size, additional_bytes) {
+        if (size > this.minalign) {
+          this.minalign = size;
+        }
+        const align_size = ~(this.bb.capacity() - this.space + additional_bytes) + 1 & size - 1;
+        while (this.space < align_size + size + additional_bytes) {
+          const old_buf_size = this.bb.capacity();
+          this.bb = _Builder.growByteBuffer(this.bb);
+          this.space += this.bb.capacity() - old_buf_size;
+        }
+        this.pad(align_size);
+      }
+      pad(byte_size) {
+        for (let i = 0; i < byte_size; i++) {
+          this.bb.writeInt8(--this.space, 0);
+        }
+      }
+      writeInt8(value) {
+        this.bb.writeInt8(this.space -= 1, value);
+      }
+      writeInt16(value) {
+        this.bb.writeInt16(this.space -= 2, value);
+      }
+      writeInt32(value) {
+        this.bb.writeInt32(this.space -= 4, value);
+      }
+      writeInt64(value) {
+        this.bb.writeInt64(this.space -= 8, value);
+      }
+      writeFloat32(value) {
+        this.bb.writeFloat32(this.space -= 4, value);
+      }
+      writeFloat64(value) {
+        this.bb.writeFloat64(this.space -= 8, value);
+      }
+      /**
+       * Add an `int8` to the buffer, properly aligned, and grows the buffer (if necessary).
+       * @param value The `int8` to add the buffer.
+       */
+      addInt8(value) {
+        this.prep(1, 0);
+        this.writeInt8(value);
+      }
+      /**
+       * Add an `int16` to the buffer, properly aligned, and grows the buffer (if necessary).
+       * @param value The `int16` to add the buffer.
+       */
+      addInt16(value) {
+        this.prep(2, 0);
+        this.writeInt16(value);
+      }
+      /**
+       * Add an `int32` to the buffer, properly aligned, and grows the buffer (if necessary).
+       * @param value The `int32` to add the buffer.
+       */
+      addInt32(value) {
+        this.prep(4, 0);
+        this.writeInt32(value);
+      }
+      /**
+       * Add an `int64` to the buffer, properly aligned, and grows the buffer (if necessary).
+       * @param value The `int64` to add the buffer.
+       */
+      addInt64(value) {
+        this.prep(8, 0);
+        this.writeInt64(value);
+      }
+      /**
+       * Add a `float32` to the buffer, properly aligned, and grows the buffer (if necessary).
+       * @param value The `float32` to add the buffer.
+       */
+      addFloat32(value) {
+        this.prep(4, 0);
+        this.writeFloat32(value);
+      }
+      /**
+       * Add a `float64` to the buffer, properly aligned, and grows the buffer (if necessary).
+       * @param value The `float64` to add the buffer.
+       */
+      addFloat64(value) {
+        this.prep(8, 0);
+        this.writeFloat64(value);
+      }
+      addFieldInt8(voffset, value, defaultValue) {
+        if (this.force_defaults || value != defaultValue) {
+          this.addInt8(value);
+          this.slot(voffset);
+        }
+      }
+      addFieldInt16(voffset, value, defaultValue) {
+        if (this.force_defaults || value != defaultValue) {
+          this.addInt16(value);
+          this.slot(voffset);
+        }
+      }
+      addFieldInt32(voffset, value, defaultValue) {
+        if (this.force_defaults || value != defaultValue) {
+          this.addInt32(value);
+          this.slot(voffset);
+        }
+      }
+      addFieldInt64(voffset, value, defaultValue) {
+        if (this.force_defaults || value !== defaultValue) {
+          this.addInt64(value);
+          this.slot(voffset);
+        }
+      }
+      addFieldFloat32(voffset, value, defaultValue) {
+        if (this.force_defaults || value != defaultValue) {
+          this.addFloat32(value);
+          this.slot(voffset);
+        }
+      }
+      addFieldFloat64(voffset, value, defaultValue) {
+        if (this.force_defaults || value != defaultValue) {
+          this.addFloat64(value);
+          this.slot(voffset);
+        }
+      }
+      addFieldOffset(voffset, value, defaultValue) {
+        if (this.force_defaults || value != defaultValue) {
+          this.addOffset(value);
+          this.slot(voffset);
+        }
+      }
+      /**
+       * Structs are stored inline, so nothing additional is being added. `d` is always 0.
+       */
+      addFieldStruct(voffset, value, defaultValue) {
+        if (value != defaultValue) {
+          this.nested(value);
+          this.slot(voffset);
+        }
+      }
+      /**
+       * Structures are always stored inline, they need to be created right
+       * where they're used.  You'll get this assertion failure if you
+       * created it elsewhere.
+       */
+      nested(obj) {
+        if (obj != this.offset()) {
+          throw new TypeError("FlatBuffers: struct must be serialized inline.");
+        }
+      }
+      /**
+       * Should not be creating any other object, string or vector
+       * while an object is being constructed
+       */
+      notNested() {
+        if (this.isNested) {
+          throw new TypeError("FlatBuffers: object serialization must not be nested.");
+        }
+      }
+      /**
+       * Set the current vtable at `voffset` to the current location in the buffer.
+       */
+      slot(voffset) {
+        if (this.vtable !== null)
+          this.vtable[voffset] = this.offset();
+      }
+      /**
+       * @returns Offset relative to the end of the buffer.
+       */
+      offset() {
+        return this.bb.capacity() - this.space;
+      }
+      /**
+       * Doubles the size of the backing ByteBuffer and copies the old data towards
+       * the end of the new buffer (since we build the buffer backwards).
+       *
+       * @param bb The current buffer with the existing data
+       * @returns A new byte buffer with the old data copied
+       * to it. The data is located at the end of the buffer.
+       *
+       * uint8Array.set() formally takes {Array<number>|ArrayBufferView}, so to pass
+       * it a uint8Array we need to suppress the type check:
+       * @suppress {checkTypes}
+       */
+      static growByteBuffer(bb) {
+        const old_buf_size = bb.capacity();
+        if (old_buf_size & 3221225472) {
+          throw new Error("FlatBuffers: cannot grow buffer beyond 2 gigabytes.");
+        }
+        const new_buf_size = old_buf_size << 1;
+        const nbb = byte_buffer_js_1.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;
+      }
+      /**
+       * Adds on offset, relative to where it will be written.
+       *
+       * @param offset The offset to add.
+       */
+      addOffset(offset) {
+        this.prep(constants_js_1.SIZEOF_INT, 0);
+        this.writeInt32(this.offset() - offset + constants_js_1.SIZEOF_INT);
+      }
+      /**
+       * Start encoding a new object in the buffer.  Users will not usually need to
+       * call this directly. The FlatBuffers compiler will generate helper methods
+       * that call this method internally.
+       */
+      startObject(numfields) {
+        this.notNested();
+        if (this.vtable == null) {
+          this.vtable = [];
+        }
+        this.vtable_in_use = numfields;
+        for (let i = 0; i < numfields; i++) {
+          this.vtable[i] = 0;
+        }
+        this.isNested = true;
+        this.object_start = this.offset();
+      }
+      /**
+       * Finish off writing the object that is under construction.
+       *
+       * @returns The offset to the object inside `dataBuffer`
+       */
+      endObject() {
+        if (this.vtable == null || !this.isNested) {
+          throw new Error("FlatBuffers: endObject called without startObject");
+        }
+        this.addInt32(0);
+        const vtableloc = this.offset();
+        let i = this.vtable_in_use - 1;
+        for (; i >= 0 && this.vtable[i] == 0; i--) {
+        }
+        const trimmed_size = i + 1;
+        for (; i >= 0; i--) {
+          this.addInt16(this.vtable[i] != 0 ? vtableloc - this.vtable[i] : 0);
+        }
+        const standard_fields = 2;
+        this.addInt16(vtableloc - this.object_start);
+        const len = (trimmed_size + standard_fields) * constants_js_1.SIZEOF_SHORT;
+        this.addInt16(len);
+        let existing_vtable = 0;
+        const vt1 = this.space;
+        outer_loop: for (i = 0; i < this.vtables.length; i++) {
+          const vt2 = this.bb.capacity() - this.vtables[i];
+          if (len == this.bb.readInt16(vt2)) {
+            for (let j = constants_js_1.SIZEOF_SHORT; j < len; j += constants_js_1.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;
+      }
+      /**
+       * Finalize a buffer, poiting to the given `root_table`.
+       */
+      finish(root_table, opt_file_identifier, opt_size_prefix) {
+        const size_prefix = opt_size_prefix ? constants_js_1.SIZE_PREFIX_LENGTH : 0;
+        if (opt_file_identifier) {
+          const file_identifier = opt_file_identifier;
+          this.prep(this.minalign, constants_js_1.SIZEOF_INT + constants_js_1.FILE_IDENTIFIER_LENGTH + size_prefix);
+          if (file_identifier.length != constants_js_1.FILE_IDENTIFIER_LENGTH) {
+            throw new TypeError("FlatBuffers: file identifier must be length " + constants_js_1.FILE_IDENTIFIER_LENGTH);
+          }
+          for (let i = constants_js_1.FILE_IDENTIFIER_LENGTH - 1; i >= 0; i--) {
+            this.writeInt8(file_identifier.charCodeAt(i));
+          }
+        }
+        this.prep(this.minalign, constants_js_1.SIZEOF_INT + size_prefix);
+        this.addOffset(root_table);
+        if (size_prefix) {
+          this.addInt32(this.bb.capacity() - this.space);
+        }
+        this.bb.setPosition(this.space);
+      }
+      /**
+       * Finalize a size prefixed buffer, pointing to the given `root_table`.
+       */
+      finishSizePrefixed(root_table, opt_file_identifier) {
+        this.finish(root_table, opt_file_identifier, true);
+      }
+      /**
+       * This checks a required field has been set in a given table that has
+       * just been constructed.
+       */
+      requiredField(table, field) {
+        const table_start = this.bb.capacity() - table;
+        const vtable_start = table_start - this.bb.readInt32(table_start);
+        const ok = field < this.bb.readInt16(vtable_start) && this.bb.readInt16(vtable_start + field) != 0;
+        if (!ok) {
+          throw new TypeError("FlatBuffers: field " + field + " must be set");
+        }
+      }
+      /**
+       * Start a new array/vector of objects.  Users usually will not call
+       * this directly. The FlatBuffers compiler will create a start/end
+       * method for vector types in generated code.
+       *
+       * @param elem_size The size of each element in the array
+       * @param num_elems The number of elements in the array
+       * @param alignment The alignment of the array
+       */
+      startVector(elem_size, num_elems, alignment) {
+        this.notNested();
+        this.vector_num_elems = num_elems;
+        this.prep(constants_js_1.SIZEOF_INT, elem_size * num_elems);
+        this.prep(alignment, elem_size * num_elems);
+      }
+      /**
+       * Finish off the creation of an array and all its elements. The array must be
+       * created with `startVector`.
+       *
+       * @returns The offset at which the newly created array
+       * starts.
+       */
+      endVector() {
+        this.writeInt32(this.vector_num_elems);
+        return this.offset();
+      }
+      /**
+       * Encode the string `s` in the buffer using UTF-8. If the string passed has
+       * already been seen, we return the offset of the already written string
+       *
+       * @param s The string to encode
+       * @return The offset in the buffer where the encoded string starts
+       */
+      createSharedString(s) {
+        if (!s) {
+          return 0;
+        }
+        if (!this.string_maps) {
+          this.string_maps = /* @__PURE__ */ new Map();
+        }
+        if (this.string_maps.has(s)) {
+          return this.string_maps.get(s);
+        }
+        const offset = this.createString(s);
+        this.string_maps.set(s, offset);
+        return offset;
+      }
+      /**
+       * Encode the string `s` in the buffer using UTF-8. If a Uint8Array is passed
+       * instead of a string, it is assumed to contain valid UTF-8 encoded data.
+       *
+       * @param s The string to encode
+       * @return The offset in the buffer where the encoded string starts
+       */
+      createString(s) {
+        if (s === null || s === void 0) {
+          return 0;
+        }
+        let utf8;
+        if (s instanceof Uint8Array) {
+          utf8 = s;
+        } else {
+          utf8 = this.text_encoder.encode(s);
+        }
+        this.addInt8(0);
+        this.startVector(1, utf8.length, 1);
+        this.bb.setPosition(this.space -= utf8.length);
+        this.bb.bytes().set(utf8, this.space);
+        return this.endVector();
+      }
+      /**
+       * Create a byte vector.
+       *
+       * @param v The bytes to add
+       * @returns The offset in the buffer where the byte vector starts
+       */
+      createByteVector(v) {
+        if (v === null || v === void 0) {
+          return 0;
+        }
+        this.startVector(1, v.length, 1);
+        this.bb.setPosition(this.space -= v.length);
+        this.bb.bytes().set(v, this.space);
+        return this.endVector();
+      }
+      /**
+       * A helper function to pack an object
+       *
+       * @returns offset of obj
+       */
+      createObjectOffset(obj) {
+        if (obj === null) {
+          return 0;
+        }
+        if (typeof obj === "string") {
+          return this.createString(obj);
+        } else {
+          return obj.pack(this);
+        }
+      }
+      /**
+       * A helper function to pack a list of object
+       *
+       * @returns list of offsets of each non null object
+       */
+      createObjectOffsetList(list) {
+        const ret = [];
+        for (let i = 0; i < list.length; ++i) {
+          const val = list[i];
+          if (val !== null) {
+            ret.push(this.createObjectOffset(val));
+          } else {
+            throw new TypeError("FlatBuffers: Argument for createObjectOffsetList cannot contain null.");
+          }
+        }
+        return ret;
+      }
+      createStructOffsetList(list, startFunc) {
+        startFunc(this, list.length);
+        this.createObjectOffsetList(list.slice().reverse());
+        return this.endVector();
+      }
+    };
+    exports.Builder = Builder;
+  }
+});
+
+// web/node_modules/flatbuffers/js/flatbuffers.js
+var require_flatbuffers = __commonJS({
+  "web/node_modules/flatbuffers/js/flatbuffers.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Encoding = exports.ByteBuffer = exports.Builder = exports.isLittleEndian = exports.int32 = exports.float64 = exports.float32 = exports.SIZE_PREFIX_LENGTH = exports.SIZEOF_SHORT = exports.SIZEOF_INT = exports.FILE_IDENTIFIER_LENGTH = void 0;
+    var constants_js_1 = require_constants();
+    Object.defineProperty(exports, "FILE_IDENTIFIER_LENGTH", { enumerable: true, get: function() {
+      return constants_js_1.FILE_IDENTIFIER_LENGTH;
+    } });
+    Object.defineProperty(exports, "SIZEOF_INT", { enumerable: true, get: function() {
+      return constants_js_1.SIZEOF_INT;
+    } });
+    Object.defineProperty(exports, "SIZEOF_SHORT", { enumerable: true, get: function() {
+      return constants_js_1.SIZEOF_SHORT;
+    } });
+    Object.defineProperty(exports, "SIZE_PREFIX_LENGTH", { enumerable: true, get: function() {
+      return constants_js_1.SIZE_PREFIX_LENGTH;
+    } });
+    var utils_js_1 = require_utils();
+    Object.defineProperty(exports, "float32", { enumerable: true, get: function() {
+      return utils_js_1.float32;
+    } });
+    Object.defineProperty(exports, "float64", { enumerable: true, get: function() {
+      return utils_js_1.float64;
+    } });
+    Object.defineProperty(exports, "int32", { enumerable: true, get: function() {
+      return utils_js_1.int32;
+    } });
+    Object.defineProperty(exports, "isLittleEndian", { enumerable: true, get: function() {
+      return utils_js_1.isLittleEndian;
+    } });
+    var builder_js_1 = require_builder();
+    Object.defineProperty(exports, "Builder", { enumerable: true, get: function() {
+      return builder_js_1.Builder;
+    } });
+    var byte_buffer_js_1 = require_byte_buffer();
+    Object.defineProperty(exports, "ByteBuffer", { enumerable: true, get: function() {
+      return byte_buffer_js_1.ByteBuffer;
+    } });
+    var encoding_js_1 = require_encoding();
+    Object.defineProperty(exports, "Encoding", { enumerable: true, get: function() {
+      return encoding_js_1.Encoding;
+    } });
+  }
+});
+
+// web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/arg-type-and-index.js
+var require_arg_type_and_index = __commonJS({
+  "web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/arg-type-and-index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = {
+          enumerable: true,
+          get: function() {
+            return m[k];
+          }
+        };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ArgTypeAndIndex = void 0;
+    var flatbuffers2 = __importStar(require_flatbuffers());
+    var arg_type_js_1 = require_arg_type();
+    var ArgTypeAndIndex2 = class _ArgTypeAndIndex {
+      constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+      }
+      __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+      }
+      static getRootAsArgTypeAndIndex(bb, obj) {
+        return (obj || new _ArgTypeAndIndex()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      static getSizePrefixedRootAsArgTypeAndIndex(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers2.SIZE_PREFIX_LENGTH);
+        return (obj || new _ArgTypeAndIndex()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      argType() {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.readInt8(this.bb_pos + offset) : arg_type_js_1.ArgType.INPUT;
+      }
+      index() {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
+      }
+      static startArgTypeAndIndex(builder) {
+        builder.startObject(2);
+      }
+      static addArgType(builder, argType) {
+        builder.addFieldInt8(0, argType, arg_type_js_1.ArgType.INPUT);
+      }
+      static addIndex(builder, index) {
+        builder.addFieldInt32(1, index, 0);
+      }
+      static endArgTypeAndIndex(builder) {
+        const offset = builder.endObject();
+        return offset;
+      }
+      static createArgTypeAndIndex(builder, argType, index) {
+        _ArgTypeAndIndex.startArgTypeAndIndex(builder);
+        _ArgTypeAndIndex.addArgType(builder, argType);
+        _ArgTypeAndIndex.addIndex(builder, index);
+        return _ArgTypeAndIndex.endArgTypeAndIndex(builder);
+      }
+    };
+    exports.ArgTypeAndIndex = ArgTypeAndIndex2;
+  }
+});
+
+// web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/attribute-type.js
+var require_attribute_type = __commonJS({
+  "web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/attribute-type.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.AttributeType = void 0;
+    var AttributeType2;
+    (function(AttributeType3) {
+      AttributeType3[AttributeType3["UNDEFINED"] = 0] = "UNDEFINED";
+      AttributeType3[AttributeType3["FLOAT"] = 1] = "FLOAT";
+      AttributeType3[AttributeType3["INT"] = 2] = "INT";
+      AttributeType3[AttributeType3["STRING"] = 3] = "STRING";
+      AttributeType3[AttributeType3["TENSOR"] = 4] = "TENSOR";
+      AttributeType3[AttributeType3["GRAPH"] = 5] = "GRAPH";
+      AttributeType3[AttributeType3["FLOATS"] = 6] = "FLOATS";
+      AttributeType3[AttributeType3["INTS"] = 7] = "INTS";
+      AttributeType3[AttributeType3["STRINGS"] = 8] = "STRINGS";
+      AttributeType3[AttributeType3["TENSORS"] = 9] = "TENSORS";
+      AttributeType3[AttributeType3["GRAPHS"] = 10] = "GRAPHS";
+      AttributeType3[AttributeType3["SPARSE_TENSOR"] = 11] = "SPARSE_TENSOR";
+      AttributeType3[AttributeType3["SPARSE_TENSORS"] = 12] = "SPARSE_TENSORS";
+    })(AttributeType2 || (exports.AttributeType = AttributeType2 = {}));
+  }
+});
+
+// web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/node-type.js
+var require_node_type = __commonJS({
+  "web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/node-type.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.NodeType = void 0;
+    var NodeType2;
+    (function(NodeType3) {
+      NodeType3[NodeType3["Primitive"] = 0] = "Primitive";
+      NodeType3[NodeType3["Fused"] = 1] = "Fused";
+    })(NodeType2 || (exports.NodeType = NodeType2 = {}));
+  }
+});
+
+// web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/node.js
+var require_node = __commonJS({
+  "web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/node.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = {
+          enumerable: true,
+          get: function() {
+            return m[k];
+          }
+        };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Node = void 0;
+    var flatbuffers2 = __importStar(require_flatbuffers());
+    var attribute_js_1 = require_attribute();
+    var node_type_js_1 = require_node_type();
+    var Node3 = class _Node {
+      constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+      }
+      __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+      }
+      static getRootAsNode(bb, obj) {
+        return (obj || new _Node()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      static getSizePrefixedRootAsNode(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers2.SIZE_PREFIX_LENGTH);
+        return (obj || new _Node()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      name(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+      }
+      docString(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+      }
+      domain(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+      }
+      sinceVersion() {
+        const offset = this.bb.__offset(this.bb_pos, 10);
+        return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
+      }
+      index() {
+        const offset = this.bb.__offset(this.bb_pos, 12);
+        return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
+      }
+      opType(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 14);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+      }
+      type() {
+        const offset = this.bb.__offset(this.bb_pos, 16);
+        return offset ? this.bb.readInt32(this.bb_pos + offset) : node_type_js_1.NodeType.Primitive;
+      }
+      executionProviderType(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 18);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+      }
+      inputs(index, optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 20);
+        return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;
+      }
+      inputsLength() {
+        const offset = this.bb.__offset(this.bb_pos, 20);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+      }
+      outputs(index, optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 22);
+        return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;
+      }
+      outputsLength() {
+        const offset = this.bb.__offset(this.bb_pos, 22);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+      }
+      attributes(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 24);
+        return offset ? (obj || new attribute_js_1.Attribute()).__init(
+          this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
+          this.bb
+        ) : null;
+      }
+      attributesLength() {
+        const offset = this.bb.__offset(this.bb_pos, 24);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+      }
+      inputArgCounts(index) {
+        const offset = this.bb.__offset(this.bb_pos, 26);
+        return offset ? this.bb.readInt32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
+      }
+      inputArgCountsLength() {
+        const offset = this.bb.__offset(this.bb_pos, 26);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+      }
+      inputArgCountsArray() {
+        const 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) {
+        const offset = this.bb.__offset(this.bb_pos, 28);
+        return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;
+      }
+      implicitInputsLength() {
+        const offset = this.bb.__offset(this.bb_pos, 28);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+      }
+      static startNode(builder) {
+        builder.startObject(13);
+      }
+      static addName(builder, nameOffset) {
+        builder.addFieldOffset(0, nameOffset, 0);
+      }
+      static addDocString(builder, docStringOffset) {
+        builder.addFieldOffset(1, docStringOffset, 0);
+      }
+      static addDomain(builder, domainOffset) {
+        builder.addFieldOffset(2, domainOffset, 0);
+      }
+      static addSinceVersion(builder, sinceVersion) {
+        builder.addFieldInt32(3, sinceVersion, 0);
+      }
+      static addIndex(builder, index) {
+        builder.addFieldInt32(4, index, 0);
+      }
+      static addOpType(builder, opTypeOffset) {
+        builder.addFieldOffset(5, opTypeOffset, 0);
+      }
+      static addType(builder, type) {
+        builder.addFieldInt32(6, type, node_type_js_1.NodeType.Primitive);
+      }
+      static addExecutionProviderType(builder, executionProviderTypeOffset) {
+        builder.addFieldOffset(7, executionProviderTypeOffset, 0);
+      }
+      static addInputs(builder, inputsOffset) {
+        builder.addFieldOffset(8, inputsOffset, 0);
+      }
+      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();
+      }
+      static startInputsVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+      }
+      static addOutputs(builder, outputsOffset) {
+        builder.addFieldOffset(9, outputsOffset, 0);
+      }
+      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();
+      }
+      static startOutputsVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+      }
+      static addAttributes(builder, attributesOffset) {
+        builder.addFieldOffset(10, attributesOffset, 0);
+      }
+      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();
+      }
+      static startAttributesVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+      }
+      static addInputArgCounts(builder, inputArgCountsOffset) {
+        builder.addFieldOffset(11, inputArgCountsOffset, 0);
+      }
+      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();
+      }
+      static startInputArgCountsVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+      }
+      static addImplicitInputs(builder, implicitInputsOffset) {
+        builder.addFieldOffset(12, implicitInputsOffset, 0);
+      }
+      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();
+      }
+      static startImplicitInputsVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+      }
+      static endNode(builder) {
+        const offset = builder.endObject();
+        return offset;
+      }
+      static createNode(builder, nameOffset, docStringOffset, domainOffset, sinceVersion, index, opTypeOffset, type, executionProviderTypeOffset, inputsOffset, outputsOffset, attributesOffset, inputArgCountsOffset, implicitInputsOffset) {
+        _Node.startNode(builder);
+        _Node.addName(builder, nameOffset);
+        _Node.addDocString(builder, docStringOffset);
+        _Node.addDomain(builder, domainOffset);
+        _Node.addSinceVersion(builder, sinceVersion);
+        _Node.addIndex(builder, index);
+        _Node.addOpType(builder, opTypeOffset);
+        _Node.addType(builder, type);
+        _Node.addExecutionProviderType(builder, executionProviderTypeOffset);
+        _Node.addInputs(builder, inputsOffset);
+        _Node.addOutputs(builder, outputsOffset);
+        _Node.addAttributes(builder, attributesOffset);
+        _Node.addInputArgCounts(builder, inputArgCountsOffset);
+        _Node.addImplicitInputs(builder, implicitInputsOffset);
+        return _Node.endNode(builder);
+      }
+    };
+    exports.Node = Node3;
+  }
+});
+
+// web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/edge-end.js
+var require_edge_end = __commonJS({
+  "web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/edge-end.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.EdgeEnd = void 0;
+    var EdgeEnd2 = class {
+      constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+      }
+      __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+      }
+      nodeIndex() {
+        return this.bb.readUint32(this.bb_pos);
+      }
+      srcArgIndex() {
+        return this.bb.readInt32(this.bb_pos + 4);
+      }
+      dstArgIndex() {
+        return this.bb.readInt32(this.bb_pos + 8);
+      }
+      static sizeOf() {
+        return 12;
+      }
+      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();
+      }
+    };
+    exports.EdgeEnd = EdgeEnd2;
+  }
+});
+
+// web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/node-edge.js
+var require_node_edge = __commonJS({
+  "web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/node-edge.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = {
+          enumerable: true,
+          get: function() {
+            return m[k];
+          }
+        };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.NodeEdge = void 0;
+    var flatbuffers2 = __importStar(require_flatbuffers());
+    var edge_end_js_1 = require_edge_end();
+    var NodeEdge2 = class _NodeEdge {
+      constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+      }
+      __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+      }
+      static getRootAsNodeEdge(bb, obj) {
+        return (obj || new _NodeEdge()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      static getSizePrefixedRootAsNodeEdge(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers2.SIZE_PREFIX_LENGTH);
+        return (obj || new _NodeEdge()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      nodeIndex() {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
+      }
+      inputEdges(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? (obj || new edge_end_js_1.EdgeEnd()).__init(this.bb.__vector(this.bb_pos + offset) + index * 12, this.bb) : null;
+      }
+      inputEdgesLength() {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+      }
+      outputEdges(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? (obj || new edge_end_js_1.EdgeEnd()).__init(this.bb.__vector(this.bb_pos + offset) + index * 12, this.bb) : null;
+      }
+      outputEdgesLength() {
+        const offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+      }
+      static startNodeEdge(builder) {
+        builder.startObject(3);
+      }
+      static addNodeIndex(builder, nodeIndex) {
+        builder.addFieldInt32(0, nodeIndex, 0);
+      }
+      static addInputEdges(builder, inputEdgesOffset) {
+        builder.addFieldOffset(1, inputEdgesOffset, 0);
+      }
+      static startInputEdgesVector(builder, numElems) {
+        builder.startVector(12, numElems, 4);
+      }
+      static addOutputEdges(builder, outputEdgesOffset) {
+        builder.addFieldOffset(2, outputEdgesOffset, 0);
+      }
+      static startOutputEdgesVector(builder, numElems) {
+        builder.startVector(12, numElems, 4);
+      }
+      static endNodeEdge(builder) {
+        const 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);
+      }
+    };
+    exports.NodeEdge = NodeEdge2;
+  }
+});
+
+// web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/nodes-to-optimize-indices.js
+var require_nodes_to_optimize_indices = __commonJS({
+  "web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/nodes-to-optimize-indices.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = {
+          enumerable: true,
+          get: function() {
+            return m[k];
+          }
+        };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.NodesToOptimizeIndices = void 0;
+    var flatbuffers2 = __importStar(require_flatbuffers());
+    var NodesToOptimizeIndices2 = class _NodesToOptimizeIndices {
+      constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+      }
+      __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+      }
+      static getRootAsNodesToOptimizeIndices(bb, obj) {
+        return (obj || new _NodesToOptimizeIndices()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      static getSizePrefixedRootAsNodesToOptimizeIndices(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers2.SIZE_PREFIX_LENGTH);
+        return (obj || new _NodesToOptimizeIndices()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      nodeIndices(index) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
+      }
+      nodeIndicesLength() {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+      }
+      nodeIndicesArray() {
+        const 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;
+      }
+      numInputs() {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
+      }
+      numOutputs() {
+        const offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
+      }
+      hasVariadicInput() {
+        const offset = this.bb.__offset(this.bb_pos, 10);
+        return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
+      }
+      hasVariadicOutput() {
+        const offset = this.bb.__offset(this.bb_pos, 12);
+        return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
+      }
+      numVariadicInputs() {
+        const offset = this.bb.__offset(this.bb_pos, 14);
+        return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
+      }
+      numVariadicOutputs() {
+        const offset = this.bb.__offset(this.bb_pos, 16);
+        return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
+      }
+      static startNodesToOptimizeIndices(builder) {
+        builder.startObject(7);
+      }
+      static addNodeIndices(builder, nodeIndicesOffset) {
+        builder.addFieldOffset(0, nodeIndicesOffset, 0);
+      }
+      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();
+      }
+      static startNodeIndicesVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+      }
+      static addNumInputs(builder, numInputs) {
+        builder.addFieldInt32(1, numInputs, 0);
+      }
+      static addNumOutputs(builder, numOutputs) {
+        builder.addFieldInt32(2, numOutputs, 0);
+      }
+      static addHasVariadicInput(builder, hasVariadicInput) {
+        builder.addFieldInt8(3, +hasVariadicInput, 0);
+      }
+      static addHasVariadicOutput(builder, hasVariadicOutput) {
+        builder.addFieldInt8(4, +hasVariadicOutput, 0);
+      }
+      static addNumVariadicInputs(builder, numVariadicInputs) {
+        builder.addFieldInt32(5, numVariadicInputs, 0);
+      }
+      static addNumVariadicOutputs(builder, numVariadicOutputs) {
+        builder.addFieldInt32(6, numVariadicOutputs, 0);
+      }
+      static endNodesToOptimizeIndices(builder) {
+        const offset = builder.endObject();
+        return offset;
+      }
+      static createNodesToOptimizeIndices(builder, nodeIndicesOffset, numInputs, numOutputs, hasVariadicInput, hasVariadicOutput, numVariadicInputs, numVariadicOutputs) {
+        _NodesToOptimizeIndices.startNodesToOptimizeIndices(builder);
+        _NodesToOptimizeIndices.addNodeIndices(builder, nodeIndicesOffset);
+        _NodesToOptimizeIndices.addNumInputs(builder, numInputs);
+        _NodesToOptimizeIndices.addNumOutputs(builder, numOutputs);
+        _NodesToOptimizeIndices.addHasVariadicInput(builder, hasVariadicInput);
+        _NodesToOptimizeIndices.addHasVariadicOutput(builder, hasVariadicOutput);
+        _NodesToOptimizeIndices.addNumVariadicInputs(builder, numVariadicInputs);
+        _NodesToOptimizeIndices.addNumVariadicOutputs(builder, numVariadicOutputs);
+        return _NodesToOptimizeIndices.endNodesToOptimizeIndices(builder);
+      }
+    };
+    exports.NodesToOptimizeIndices = NodesToOptimizeIndices2;
+  }
+});
+
+// web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/runtime-optimization-record.js
+var require_runtime_optimization_record = __commonJS({
+  "web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/runtime-optimization-record.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = {
+          enumerable: true,
+          get: function() {
+            return m[k];
+          }
+        };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.RuntimeOptimizationRecord = void 0;
+    var flatbuffers2 = __importStar(require_flatbuffers());
+    var nodes_to_optimize_indices_js_1 = require_nodes_to_optimize_indices();
+    var RuntimeOptimizationRecord2 = class _RuntimeOptimizationRecord {
+      constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+      }
+      __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+      }
+      static getRootAsRuntimeOptimizationRecord(bb, obj) {
+        return (obj || new _RuntimeOptimizationRecord()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      static getSizePrefixedRootAsRuntimeOptimizationRecord(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers2.SIZE_PREFIX_LENGTH);
+        return (obj || new _RuntimeOptimizationRecord()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      actionId(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+      }
+      nodesToOptimizeIndices(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? (obj || new nodes_to_optimize_indices_js_1.NodesToOptimizeIndices()).__init(
+          this.bb.__indirect(this.bb_pos + offset),
+          this.bb
+        ) : null;
+      }
+      producedOpIds(index, optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 10);
+        return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;
+      }
+      producedOpIdsLength() {
+        const offset = this.bb.__offset(this.bb_pos, 10);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+      }
+      static startRuntimeOptimizationRecord(builder) {
+        builder.startObject(4);
+      }
+      static addActionId(builder, actionIdOffset) {
+        builder.addFieldOffset(0, actionIdOffset, 0);
+      }
+      static addNodesToOptimizeIndices(builder, nodesToOptimizeIndicesOffset) {
+        builder.addFieldOffset(1, nodesToOptimizeIndicesOffset, 0);
+      }
+      static addProducedOpIds(builder, producedOpIdsOffset) {
+        builder.addFieldOffset(3, producedOpIdsOffset, 0);
+      }
+      static createProducedOpIdsVector(builder, data) {
+        builder.startVector(4, data.length, 4);
+        for (let i = data.length - 1; i >= 0; i--) {
+          builder.addOffset(data[i]);
+        }
+        return builder.endVector();
+      }
+      static startProducedOpIdsVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+      }
+      static endRuntimeOptimizationRecord(builder) {
+        const offset = builder.endObject();
+        return offset;
+      }
+    };
+    exports.RuntimeOptimizationRecord = RuntimeOptimizationRecord2;
+  }
+});
+
+// web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/runtime-optimization-record-container-entry.js
+var require_runtime_optimization_record_container_entry = __commonJS({
+  "web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/runtime-optimization-record-container-entry.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = {
+          enumerable: true,
+          get: function() {
+            return m[k];
+          }
+        };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.RuntimeOptimizationRecordContainerEntry = void 0;
+    var flatbuffers2 = __importStar(require_flatbuffers());
+    var runtime_optimization_record_js_1 = require_runtime_optimization_record();
+    var RuntimeOptimizationRecordContainerEntry2 = class _RuntimeOptimizationRecordContainerEntry {
+      constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+      }
+      __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+      }
+      static getRootAsRuntimeOptimizationRecordContainerEntry(bb, obj) {
+        return (obj || new _RuntimeOptimizationRecordContainerEntry()).__init(
+          bb.readInt32(bb.position()) + bb.position(),
+          bb
+        );
+      }
+      static getSizePrefixedRootAsRuntimeOptimizationRecordContainerEntry(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers2.SIZE_PREFIX_LENGTH);
+        return (obj || new _RuntimeOptimizationRecordContainerEntry()).__init(
+          bb.readInt32(bb.position()) + bb.position(),
+          bb
+        );
+      }
+      optimizerName(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+      }
+      runtimeOptimizationRecords(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? (obj || new runtime_optimization_record_js_1.RuntimeOptimizationRecord()).__init(
+          this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
+          this.bb
+        ) : null;
+      }
+      runtimeOptimizationRecordsLength() {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+      }
+      static startRuntimeOptimizationRecordContainerEntry(builder) {
+        builder.startObject(2);
+      }
+      static addOptimizerName(builder, optimizerNameOffset) {
+        builder.addFieldOffset(0, optimizerNameOffset, 0);
+      }
+      static addRuntimeOptimizationRecords(builder, runtimeOptimizationRecordsOffset) {
+        builder.addFieldOffset(1, runtimeOptimizationRecordsOffset, 0);
+      }
+      static createRuntimeOptimizationRecordsVector(builder, data) {
+        builder.startVector(4, data.length, 4);
+        for (let i = data.length - 1; i >= 0; i--) {
+          builder.addOffset(data[i]);
+        }
+        return builder.endVector();
+      }
+      static startRuntimeOptimizationRecordsVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+      }
+      static endRuntimeOptimizationRecordContainerEntry(builder) {
+        const offset = builder.endObject();
+        builder.requiredField(offset, 4);
+        return offset;
+      }
+      static createRuntimeOptimizationRecordContainerEntry(builder, optimizerNameOffset, runtimeOptimizationRecordsOffset) {
+        _RuntimeOptimizationRecordContainerEntry.startRuntimeOptimizationRecordContainerEntry(builder);
+        _RuntimeOptimizationRecordContainerEntry.addOptimizerName(builder, optimizerNameOffset);
+        _RuntimeOptimizationRecordContainerEntry.addRuntimeOptimizationRecords(builder, runtimeOptimizationRecordsOffset);
+        return _RuntimeOptimizationRecordContainerEntry.endRuntimeOptimizationRecordContainerEntry(builder);
+      }
+    };
+    exports.RuntimeOptimizationRecordContainerEntry = RuntimeOptimizationRecordContainerEntry2;
+  }
+});
+
+// web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/runtime-optimizations.js
+var require_runtime_optimizations = __commonJS({
+  "web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/runtime-optimizations.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = {
+          enumerable: true,
+          get: function() {
+            return m[k];
+          }
+        };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.RuntimeOptimizations = void 0;
+    var flatbuffers2 = __importStar(require_flatbuffers());
+    var runtime_optimization_record_container_entry_js_1 = require_runtime_optimization_record_container_entry();
+    var RuntimeOptimizations2 = class _RuntimeOptimizations {
+      constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+      }
+      __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+      }
+      static getRootAsRuntimeOptimizations(bb, obj) {
+        return (obj || new _RuntimeOptimizations()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      static getSizePrefixedRootAsRuntimeOptimizations(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers2.SIZE_PREFIX_LENGTH);
+        return (obj || new _RuntimeOptimizations()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      /**
+       * mapping from optimizer name to [RuntimeOptimizationRecord]
+       */
+      records(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? (obj || new runtime_optimization_record_container_entry_js_1.RuntimeOptimizationRecordContainerEntry()).__init(
+          this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
+          this.bb
+        ) : null;
+      }
+      recordsLength() {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+      }
+      static startRuntimeOptimizations(builder) {
+        builder.startObject(1);
+      }
+      static addRecords(builder, recordsOffset) {
+        builder.addFieldOffset(0, recordsOffset, 0);
+      }
+      static createRecordsVector(builder, data) {
+        builder.startVector(4, data.length, 4);
+        for (let i = data.length - 1; i >= 0; i--) {
+          builder.addOffset(data[i]);
+        }
+        return builder.endVector();
+      }
+      static startRecordsVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+      }
+      static endRuntimeOptimizations(builder) {
+        const offset = builder.endObject();
+        return offset;
+      }
+      static createRuntimeOptimizations(builder, recordsOffset) {
+        _RuntimeOptimizations.startRuntimeOptimizations(builder);
+        _RuntimeOptimizations.addRecords(builder, recordsOffset);
+        return _RuntimeOptimizations.endRuntimeOptimizations(builder);
+      }
+    };
+    exports.RuntimeOptimizations = RuntimeOptimizations2;
+  }
+});
+
+// web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/tensor-data-type.js
+var require_tensor_data_type = __commonJS({
+  "web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/tensor-data-type.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TensorDataType = void 0;
+    var TensorDataType2;
+    (function(TensorDataType3) {
+      TensorDataType3[TensorDataType3["UNDEFINED"] = 0] = "UNDEFINED";
+      TensorDataType3[TensorDataType3["FLOAT"] = 1] = "FLOAT";
+      TensorDataType3[TensorDataType3["UINT8"] = 2] = "UINT8";
+      TensorDataType3[TensorDataType3["INT8"] = 3] = "INT8";
+      TensorDataType3[TensorDataType3["UINT16"] = 4] = "UINT16";
+      TensorDataType3[TensorDataType3["INT16"] = 5] = "INT16";
+      TensorDataType3[TensorDataType3["INT32"] = 6] = "INT32";
+      TensorDataType3[TensorDataType3["INT64"] = 7] = "INT64";
+      TensorDataType3[TensorDataType3["STRING"] = 8] = "STRING";
+      TensorDataType3[TensorDataType3["BOOL"] = 9] = "BOOL";
+      TensorDataType3[TensorDataType3["FLOAT16"] = 10] = "FLOAT16";
+      TensorDataType3[TensorDataType3["DOUBLE"] = 11] = "DOUBLE";
+      TensorDataType3[TensorDataType3["UINT32"] = 12] = "UINT32";
+      TensorDataType3[TensorDataType3["UINT64"] = 13] = "UINT64";
+      TensorDataType3[TensorDataType3["COMPLEX64"] = 14] = "COMPLEX64";
+      TensorDataType3[TensorDataType3["COMPLEX128"] = 15] = "COMPLEX128";
+      TensorDataType3[TensorDataType3["BFLOAT16"] = 16] = "BFLOAT16";
+      TensorDataType3[TensorDataType3["FLOAT8E4M3FN"] = 17] = "FLOAT8E4M3FN";
+      TensorDataType3[TensorDataType3["FLOAT8E4M3FNUZ"] = 18] = "FLOAT8E4M3FNUZ";
+      TensorDataType3[TensorDataType3["FLOAT8E5M2"] = 19] = "FLOAT8E5M2";
+      TensorDataType3[TensorDataType3["FLOAT8E5M2FNUZ"] = 20] = "FLOAT8E5M2FNUZ";
+    })(TensorDataType2 || (exports.TensorDataType = TensorDataType2 = {}));
+  }
+});
+
+// web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/tensor.js
+var require_tensor = __commonJS({
+  "web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/tensor.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = {
+          enumerable: true,
+          get: function() {
+            return m[k];
+          }
+        };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Tensor = void 0;
+    var flatbuffers2 = __importStar(require_flatbuffers());
+    var tensor_data_type_js_1 = require_tensor_data_type();
+    var Tensor5 = class _Tensor {
+      constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+      }
+      __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+      }
+      static getRootAsTensor(bb, obj) {
+        return (obj || new _Tensor()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      static getSizePrefixedRootAsTensor(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers2.SIZE_PREFIX_LENGTH);
+        return (obj || new _Tensor()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      name(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+      }
+      docString(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+      }
+      dims(index) {
+        const offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? this.bb.readInt64(this.bb.__vector(this.bb_pos + offset) + index * 8) : BigInt(0);
+      }
+      dimsLength() {
+        const offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+      }
+      dataType() {
+        const offset = this.bb.__offset(this.bb_pos, 10);
+        return offset ? this.bb.readInt32(this.bb_pos + offset) : tensor_data_type_js_1.TensorDataType.UNDEFINED;
+      }
+      rawData(index) {
+        const offset = this.bb.__offset(this.bb_pos, 12);
+        return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0;
+      }
+      rawDataLength() {
+        const offset = this.bb.__offset(this.bb_pos, 12);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+      }
+      rawDataArray() {
+        const 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) {
+        const offset = this.bb.__offset(this.bb_pos, 14);
+        return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;
+      }
+      stringDataLength() {
+        const offset = this.bb.__offset(this.bb_pos, 14);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+      }
+      externalDataOffset() {
+        const offset = this.bb.__offset(this.bb_pos, 16);
+        return offset ? this.bb.readInt64(this.bb_pos + offset) : BigInt("-1");
+      }
+      static startTensor(builder) {
+        builder.startObject(7);
+      }
+      static addName(builder, nameOffset) {
+        builder.addFieldOffset(0, nameOffset, 0);
+      }
+      static addDocString(builder, docStringOffset) {
+        builder.addFieldOffset(1, docStringOffset, 0);
+      }
+      static addDims(builder, dimsOffset) {
+        builder.addFieldOffset(2, dimsOffset, 0);
+      }
+      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();
+      }
+      static startDimsVector(builder, numElems) {
+        builder.startVector(8, numElems, 8);
+      }
+      static addDataType(builder, dataType) {
+        builder.addFieldInt32(3, dataType, tensor_data_type_js_1.TensorDataType.UNDEFINED);
+      }
+      static addRawData(builder, rawDataOffset) {
+        builder.addFieldOffset(4, rawDataOffset, 0);
+      }
+      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();
+      }
+      static startRawDataVector(builder, numElems) {
+        builder.startVector(1, numElems, 1);
+      }
+      static addStringData(builder, stringDataOffset) {
+        builder.addFieldOffset(5, stringDataOffset, 0);
+      }
+      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();
+      }
+      static startStringDataVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+      }
+      static addExternalDataOffset(builder, externalDataOffset) {
+        builder.addFieldInt64(6, externalDataOffset, BigInt("-1"));
+      }
+      static endTensor(builder) {
+        const offset = builder.endObject();
+        return offset;
+      }
+      static createTensor(builder, nameOffset, docStringOffset, dimsOffset, dataType, rawDataOffset, stringDataOffset, externalDataOffset) {
+        _Tensor.startTensor(builder);
+        _Tensor.addName(builder, nameOffset);
+        _Tensor.addDocString(builder, docStringOffset);
+        _Tensor.addDims(builder, dimsOffset);
+        _Tensor.addDataType(builder, dataType);
+        _Tensor.addRawData(builder, rawDataOffset);
+        _Tensor.addStringData(builder, stringDataOffset);
+        _Tensor.addExternalDataOffset(builder, externalDataOffset);
+        return _Tensor.endTensor(builder);
+      }
+    };
+    exports.Tensor = Tensor5;
+  }
+});
+
+// web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/sparse-tensor.js
+var require_sparse_tensor = __commonJS({
+  "web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/sparse-tensor.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = {
+          enumerable: true,
+          get: function() {
+            return m[k];
+          }
+        };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.SparseTensor = void 0;
+    var flatbuffers2 = __importStar(require_flatbuffers());
+    var tensor_js_1 = require_tensor();
+    var SparseTensor2 = class _SparseTensor {
+      constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+      }
+      __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+      }
+      static getRootAsSparseTensor(bb, obj) {
+        return (obj || new _SparseTensor()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      static getSizePrefixedRootAsSparseTensor(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers2.SIZE_PREFIX_LENGTH);
+        return (obj || new _SparseTensor()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      values(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? (obj || new tensor_js_1.Tensor()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+      }
+      indices(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? (obj || new tensor_js_1.Tensor()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+      }
+      dims(index) {
+        const offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? this.bb.readInt64(this.bb.__vector(this.bb_pos + offset) + index * 8) : BigInt(0);
+      }
+      dimsLength() {
+        const offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+      }
+      static startSparseTensor(builder) {
+        builder.startObject(3);
+      }
+      static addValues(builder, valuesOffset) {
+        builder.addFieldOffset(0, valuesOffset, 0);
+      }
+      static addIndices(builder, indicesOffset) {
+        builder.addFieldOffset(1, indicesOffset, 0);
+      }
+      static addDims(builder, dimsOffset) {
+        builder.addFieldOffset(2, dimsOffset, 0);
+      }
+      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();
+      }
+      static startDimsVector(builder, numElems) {
+        builder.startVector(8, numElems, 8);
+      }
+      static endSparseTensor(builder) {
+        const offset = builder.endObject();
+        return offset;
+      }
+    };
+    exports.SparseTensor = SparseTensor2;
+  }
+});
+
+// web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/map-type.js
+var require_map_type = __commonJS({
+  "web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/map-type.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = {
+          enumerable: true,
+          get: function() {
+            return m[k];
+          }
+        };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.MapType = void 0;
+    var flatbuffers2 = __importStar(require_flatbuffers());
+    var tensor_data_type_js_1 = require_tensor_data_type();
+    var type_info_js_1 = require_type_info();
+    var MapType2 = class _MapType {
+      constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+      }
+      __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+      }
+      static getRootAsMapType(bb, obj) {
+        return (obj || new _MapType()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      static getSizePrefixedRootAsMapType(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers2.SIZE_PREFIX_LENGTH);
+        return (obj || new _MapType()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      keyType() {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.readInt32(this.bb_pos + offset) : tensor_data_type_js_1.TensorDataType.UNDEFINED;
+      }
+      valueType(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? (obj || new type_info_js_1.TypeInfo()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+      }
+      static startMapType(builder) {
+        builder.startObject(2);
+      }
+      static addKeyType(builder, keyType) {
+        builder.addFieldInt32(0, keyType, tensor_data_type_js_1.TensorDataType.UNDEFINED);
+      }
+      static addValueType(builder, valueTypeOffset) {
+        builder.addFieldOffset(1, valueTypeOffset, 0);
+      }
+      static endMapType(builder) {
+        const offset = builder.endObject();
+        return offset;
+      }
+    };
+    exports.MapType = MapType2;
+  }
+});
+
+// web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/sequence-type.js
+var require_sequence_type = __commonJS({
+  "web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/sequence-type.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = {
+          enumerable: true,
+          get: function() {
+            return m[k];
+          }
+        };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.SequenceType = void 0;
+    var flatbuffers2 = __importStar(require_flatbuffers());
+    var type_info_js_1 = require_type_info();
+    var SequenceType2 = class _SequenceType {
+      constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+      }
+      __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+      }
+      static getRootAsSequenceType(bb, obj) {
+        return (obj || new _SequenceType()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      static getSizePrefixedRootAsSequenceType(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers2.SIZE_PREFIX_LENGTH);
+        return (obj || new _SequenceType()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      elemType(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? (obj || new type_info_js_1.TypeInfo()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+      }
+      static startSequenceType(builder) {
+        builder.startObject(1);
+      }
+      static addElemType(builder, elemTypeOffset) {
+        builder.addFieldOffset(0, elemTypeOffset, 0);
+      }
+      static endSequenceType(builder) {
+        const offset = builder.endObject();
+        return offset;
+      }
+      static createSequenceType(builder, elemTypeOffset) {
+        _SequenceType.startSequenceType(builder);
+        _SequenceType.addElemType(builder, elemTypeOffset);
+        return _SequenceType.endSequenceType(builder);
+      }
+    };
+    exports.SequenceType = SequenceType2;
+  }
+});
+
+// web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/dimension-value-type.js
+var require_dimension_value_type = __commonJS({
+  "web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/dimension-value-type.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DimensionValueType = void 0;
+    var DimensionValueType2;
+    (function(DimensionValueType3) {
+      DimensionValueType3[DimensionValueType3["UNKNOWN"] = 0] = "UNKNOWN";
+      DimensionValueType3[DimensionValueType3["VALUE"] = 1] = "VALUE";
+      DimensionValueType3[DimensionValueType3["PARAM"] = 2] = "PARAM";
+    })(DimensionValueType2 || (exports.DimensionValueType = DimensionValueType2 = {}));
+  }
+});
+
+// web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/dimension-value.js
+var require_dimension_value = __commonJS({
+  "web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/dimension-value.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = {
+          enumerable: true,
+          get: function() {
+            return m[k];
+          }
+        };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DimensionValue = void 0;
+    var flatbuffers2 = __importStar(require_flatbuffers());
+    var dimension_value_type_js_1 = require_dimension_value_type();
+    var DimensionValue2 = class _DimensionValue {
+      constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+      }
+      __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+      }
+      static getRootAsDimensionValue(bb, obj) {
+        return (obj || new _DimensionValue()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      static getSizePrefixedRootAsDimensionValue(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers2.SIZE_PREFIX_LENGTH);
+        return (obj || new _DimensionValue()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      dimType() {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.readInt8(this.bb_pos + offset) : dimension_value_type_js_1.DimensionValueType.UNKNOWN;
+      }
+      dimValue() {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.readInt64(this.bb_pos + offset) : BigInt("0");
+      }
+      dimParam(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+      }
+      static startDimensionValue(builder) {
+        builder.startObject(3);
+      }
+      static addDimType(builder, dimType) {
+        builder.addFieldInt8(0, dimType, dimension_value_type_js_1.DimensionValueType.UNKNOWN);
+      }
+      static addDimValue(builder, dimValue) {
+        builder.addFieldInt64(1, dimValue, BigInt("0"));
+      }
+      static addDimParam(builder, dimParamOffset) {
+        builder.addFieldOffset(2, dimParamOffset, 0);
+      }
+      static endDimensionValue(builder) {
+        const 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);
+      }
+    };
+    exports.DimensionValue = DimensionValue2;
+  }
+});
+
+// web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/dimension.js
+var require_dimension = __commonJS({
+  "web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/dimension.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = {
+          enumerable: true,
+          get: function() {
+            return m[k];
+          }
+        };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Dimension = void 0;
+    var flatbuffers2 = __importStar(require_flatbuffers());
+    var dimension_value_js_1 = require_dimension_value();
+    var Dimension2 = class _Dimension {
+      constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+      }
+      __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+      }
+      static getRootAsDimension(bb, obj) {
+        return (obj || new _Dimension()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      static getSizePrefixedRootAsDimension(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers2.SIZE_PREFIX_LENGTH);
+        return (obj || new _Dimension()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      value(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? (obj || new dimension_value_js_1.DimensionValue()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+      }
+      denotation(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+      }
+      static startDimension(builder) {
+        builder.startObject(2);
+      }
+      static addValue(builder, valueOffset) {
+        builder.addFieldOffset(0, valueOffset, 0);
+      }
+      static addDenotation(builder, denotationOffset) {
+        builder.addFieldOffset(1, denotationOffset, 0);
+      }
+      static endDimension(builder) {
+        const 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);
+      }
+    };
+    exports.Dimension = Dimension2;
+  }
+});
+
+// web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/shape.js
+var require_shape = __commonJS({
+  "web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/shape.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = {
+          enumerable: true,
+          get: function() {
+            return m[k];
+          }
+        };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Shape = void 0;
+    var flatbuffers2 = __importStar(require_flatbuffers());
+    var dimension_js_1 = require_dimension();
+    var Shape2 = class _Shape {
+      constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+      }
+      __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+      }
+      static getRootAsShape(bb, obj) {
+        return (obj || new _Shape()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      static getSizePrefixedRootAsShape(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers2.SIZE_PREFIX_LENGTH);
+        return (obj || new _Shape()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      dim(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? (obj || new dimension_js_1.Dimension()).__init(
+          this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
+          this.bb
+        ) : null;
+      }
+      dimLength() {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+      }
+      static startShape(builder) {
+        builder.startObject(1);
+      }
+      static addDim(builder, dimOffset) {
+        builder.addFieldOffset(0, dimOffset, 0);
+      }
+      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();
+      }
+      static startDimVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+      }
+      static endShape(builder) {
+        const offset = builder.endObject();
+        return offset;
+      }
+      static createShape(builder, dimOffset) {
+        _Shape.startShape(builder);
+        _Shape.addDim(builder, dimOffset);
+        return _Shape.endShape(builder);
+      }
+    };
+    exports.Shape = Shape2;
+  }
+});
+
+// web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/tensor-type-and-shape.js
+var require_tensor_type_and_shape = __commonJS({
+  "web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/tensor-type-and-shape.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = {
+          enumerable: true,
+          get: function() {
+            return m[k];
+          }
+        };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TensorTypeAndShape = void 0;
+    var flatbuffers2 = __importStar(require_flatbuffers());
+    var shape_js_1 = require_shape();
+    var tensor_data_type_js_1 = require_tensor_data_type();
+    var TensorTypeAndShape2 = class _TensorTypeAndShape {
+      constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+      }
+      __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+      }
+      static getRootAsTensorTypeAndShape(bb, obj) {
+        return (obj || new _TensorTypeAndShape()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      static getSizePrefixedRootAsTensorTypeAndShape(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers2.SIZE_PREFIX_LENGTH);
+        return (obj || new _TensorTypeAndShape()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      elemType() {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.readInt32(this.bb_pos + offset) : tensor_data_type_js_1.TensorDataType.UNDEFINED;
+      }
+      shape(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? (obj || new shape_js_1.Shape()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+      }
+      static startTensorTypeAndShape(builder) {
+        builder.startObject(2);
+      }
+      static addElemType(builder, elemType) {
+        builder.addFieldInt32(0, elemType, tensor_data_type_js_1.TensorDataType.UNDEFINED);
+      }
+      static addShape(builder, shapeOffset) {
+        builder.addFieldOffset(1, shapeOffset, 0);
+      }
+      static endTensorTypeAndShape(builder) {
+        const offset = builder.endObject();
+        return offset;
+      }
+    };
+    exports.TensorTypeAndShape = TensorTypeAndShape2;
+  }
+});
+
+// web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/type-info-value.js
+var require_type_info_value = __commonJS({
+  "web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/type-info-value.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TypeInfoValue = void 0;
+    exports.unionToTypeInfoValue = unionToTypeInfoValue;
+    exports.unionListToTypeInfoValue = unionListToTypeInfoValue;
+    var map_type_js_1 = require_map_type();
+    var sequence_type_js_1 = require_sequence_type();
+    var tensor_type_and_shape_js_1 = require_tensor_type_and_shape();
+    var TypeInfoValue2;
+    (function(TypeInfoValue3) {
+      TypeInfoValue3[TypeInfoValue3["NONE"] = 0] = "NONE";
+      TypeInfoValue3[TypeInfoValue3["tensor_type"] = 1] = "tensor_type";
+      TypeInfoValue3[TypeInfoValue3["sequence_type"] = 2] = "sequence_type";
+      TypeInfoValue3[TypeInfoValue3["map_type"] = 3] = "map_type";
+    })(TypeInfoValue2 || (exports.TypeInfoValue = TypeInfoValue2 = {}));
+    function unionToTypeInfoValue(type, accessor) {
+      switch (TypeInfoValue2[type]) {
+        case "NONE":
+          return null;
+        case "tensor_type":
+          return accessor(new tensor_type_and_shape_js_1.TensorTypeAndShape());
+        case "sequence_type":
+          return accessor(new sequence_type_js_1.SequenceType());
+        case "map_type":
+          return accessor(new map_type_js_1.MapType());
+        default:
+          return null;
+      }
+    }
+    function unionListToTypeInfoValue(type, accessor, index) {
+      switch (TypeInfoValue2[type]) {
+        case "NONE":
+          return null;
+        case "tensor_type":
+          return accessor(index, new tensor_type_and_shape_js_1.TensorTypeAndShape());
+        case "sequence_type":
+          return accessor(index, new sequence_type_js_1.SequenceType());
+        case "map_type":
+          return accessor(index, new map_type_js_1.MapType());
+        default:
+          return null;
+      }
+    }
+  }
+});
+
+// web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/type-info.js
+var require_type_info = __commonJS({
+  "web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/type-info.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = {
+          enumerable: true,
+          get: function() {
+            return m[k];
+          }
+        };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TypeInfo = void 0;
+    var flatbuffers2 = __importStar(require_flatbuffers());
+    var type_info_value_js_1 = require_type_info_value();
+    var TypeInfo2 = class _TypeInfo {
+      constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+      }
+      __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+      }
+      static getRootAsTypeInfo(bb, obj) {
+        return (obj || new _TypeInfo()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      static getSizePrefixedRootAsTypeInfo(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers2.SIZE_PREFIX_LENGTH);
+        return (obj || new _TypeInfo()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      denotation(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+      }
+      valueType() {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.readUint8(this.bb_pos + offset) : type_info_value_js_1.TypeInfoValue.NONE;
+      }
+      value(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? this.bb.__union(obj, this.bb_pos + offset) : null;
+      }
+      static startTypeInfo(builder) {
+        builder.startObject(3);
+      }
+      static addDenotation(builder, denotationOffset) {
+        builder.addFieldOffset(0, denotationOffset, 0);
+      }
+      static addValueType(builder, valueType) {
+        builder.addFieldInt8(1, valueType, type_info_value_js_1.TypeInfoValue.NONE);
+      }
+      static addValue(builder, valueOffset) {
+        builder.addFieldOffset(2, valueOffset, 0);
+      }
+      static endTypeInfo(builder) {
+        const 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);
+      }
+    };
+    exports.TypeInfo = TypeInfo2;
+  }
+});
+
+// web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/value-info.js
+var require_value_info = __commonJS({
+  "web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/value-info.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = {
+          enumerable: true,
+          get: function() {
+            return m[k];
+          }
+        };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ValueInfo = void 0;
+    var flatbuffers2 = __importStar(require_flatbuffers());
+    var type_info_js_1 = require_type_info();
+    var ValueInfo2 = class _ValueInfo {
+      constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+      }
+      __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+      }
+      static getRootAsValueInfo(bb, obj) {
+        return (obj || new _ValueInfo()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      static getSizePrefixedRootAsValueInfo(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers2.SIZE_PREFIX_LENGTH);
+        return (obj || new _ValueInfo()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      name(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+      }
+      docString(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+      }
+      type(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? (obj || new type_info_js_1.TypeInfo()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+      }
+      static startValueInfo(builder) {
+        builder.startObject(3);
+      }
+      static addName(builder, nameOffset) {
+        builder.addFieldOffset(0, nameOffset, 0);
+      }
+      static addDocString(builder, docStringOffset) {
+        builder.addFieldOffset(1, docStringOffset, 0);
+      }
+      static addType(builder, typeOffset) {
+        builder.addFieldOffset(2, typeOffset, 0);
+      }
+      static endValueInfo(builder) {
+        const offset = builder.endObject();
+        return offset;
+      }
+    };
+    exports.ValueInfo = ValueInfo2;
+  }
+});
+
+// web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/graph.js
+var require_graph = __commonJS({
+  "web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/graph.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = {
+          enumerable: true,
+          get: function() {
+            return m[k];
+          }
+        };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Graph = void 0;
+    var flatbuffers2 = __importStar(require_flatbuffers());
+    var node_js_1 = require_node();
+    var node_edge_js_1 = require_node_edge();
+    var runtime_optimizations_js_1 = require_runtime_optimizations();
+    var sparse_tensor_js_1 = require_sparse_tensor();
+    var tensor_js_1 = require_tensor();
+    var value_info_js_1 = require_value_info();
+    var Graph3 = class _Graph {
+      constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+      }
+      __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+      }
+      static getRootAsGraph(bb, obj) {
+        return (obj || new _Graph()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      static getSizePrefixedRootAsGraph(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers2.SIZE_PREFIX_LENGTH);
+        return (obj || new _Graph()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      initializers(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? (obj || new tensor_js_1.Tensor()).__init(
+          this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
+          this.bb
+        ) : null;
+      }
+      initializersLength() {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+      }
+      nodeArgs(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? (obj || new value_info_js_1.ValueInfo()).__init(
+          this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
+          this.bb
+        ) : null;
+      }
+      nodeArgsLength() {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+      }
+      nodes(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? (obj || new node_js_1.Node()).__init(
+          this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
+          this.bb
+        ) : null;
+      }
+      nodesLength() {
+        const offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+      }
+      maxNodeIndex() {
+        const offset = this.bb.__offset(this.bb_pos, 10);
+        return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
+      }
+      nodeEdges(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 12);
+        return offset ? (obj || new node_edge_js_1.NodeEdge()).__init(
+          this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
+          this.bb
+        ) : null;
+      }
+      nodeEdgesLength() {
+        const offset = this.bb.__offset(this.bb_pos, 12);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+      }
+      inputs(index, optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 14);
+        return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;
+      }
+      inputsLength() {
+        const offset = this.bb.__offset(this.bb_pos, 14);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+      }
+      outputs(index, optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 16);
+        return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;
+      }
+      outputsLength() {
+        const offset = this.bb.__offset(this.bb_pos, 16);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+      }
+      sparseInitializers(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 18);
+        return offset ? (obj || new sparse_tensor_js_1.SparseTensor()).__init(
+          this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
+          this.bb
+        ) : null;
+      }
+      sparseInitializersLength() {
+        const offset = this.bb.__offset(this.bb_pos, 18);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+      }
+      runtimeOptimizations(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 20);
+        return offset ? (obj || new runtime_optimizations_js_1.RuntimeOptimizations()).__init(
+          this.bb.__indirect(this.bb_pos + offset),
+          this.bb
+        ) : null;
+      }
+      static startGraph(builder) {
+        builder.startObject(9);
+      }
+      static addInitializers(builder, initializersOffset) {
+        builder.addFieldOffset(0, initializersOffset, 0);
+      }
+      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();
+      }
+      static startInitializersVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+      }
+      static addNodeArgs(builder, nodeArgsOffset) {
+        builder.addFieldOffset(1, nodeArgsOffset, 0);
+      }
+      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();
+      }
+      static startNodeArgsVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+      }
+      static addNodes(builder, nodesOffset) {
+        builder.addFieldOffset(2, nodesOffset, 0);
+      }
+      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();
+      }
+      static startNodesVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+      }
+      static addMaxNodeIndex(builder, maxNodeIndex) {
+        builder.addFieldInt32(3, maxNodeIndex, 0);
+      }
+      static addNodeEdges(builder, nodeEdgesOffset) {
+        builder.addFieldOffset(4, nodeEdgesOffset, 0);
+      }
+      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();
+      }
+      static startNodeEdgesVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+      }
+      static addInputs(builder, inputsOffset) {
+        builder.addFieldOffset(5, inputsOffset, 0);
+      }
+      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();
+      }
+      static startInputsVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+      }
+      static addOutputs(builder, outputsOffset) {
+        builder.addFieldOffset(6, outputsOffset, 0);
+      }
+      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();
+      }
+      static startOutputsVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+      }
+      static addSparseInitializers(builder, sparseInitializersOffset) {
+        builder.addFieldOffset(7, sparseInitializersOffset, 0);
+      }
+      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();
+      }
+      static startSparseInitializersVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+      }
+      static addRuntimeOptimizations(builder, runtimeOptimizationsOffset) {
+        builder.addFieldOffset(8, runtimeOptimizationsOffset, 0);
+      }
+      static endGraph(builder) {
+        const offset = builder.endObject();
+        return offset;
+      }
+    };
+    exports.Graph = Graph3;
+  }
+});
+
+// web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/attribute.js
+var require_attribute = __commonJS({
+  "web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/attribute.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = {
+          enumerable: true,
+          get: function() {
+            return m[k];
+          }
+        };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Attribute = void 0;
+    var flatbuffers2 = __importStar(require_flatbuffers());
+    var attribute_type_js_1 = require_attribute_type();
+    var graph_js_1 = require_graph();
+    var tensor_js_1 = require_tensor();
+    var Attribute3 = class _Attribute {
+      constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+      }
+      __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+      }
+      static getRootAsAttribute(bb, obj) {
+        return (obj || new _Attribute()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      static getSizePrefixedRootAsAttribute(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers2.SIZE_PREFIX_LENGTH);
+        return (obj || new _Attribute()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      name(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+      }
+      docString(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+      }
+      type() {
+        const offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? this.bb.readInt32(this.bb_pos + offset) : attribute_type_js_1.AttributeType.UNDEFINED;
+      }
+      f() {
+        const offset = this.bb.__offset(this.bb_pos, 10);
+        return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0;
+      }
+      i() {
+        const offset = this.bb.__offset(this.bb_pos, 12);
+        return offset ? this.bb.readInt64(this.bb_pos + offset) : BigInt("0");
+      }
+      s(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 14);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+      }
+      t(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 16);
+        return offset ? (obj || new tensor_js_1.Tensor()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+      }
+      g(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 18);
+        return offset ? (obj || new graph_js_1.Graph()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+      }
+      floats(index) {
+        const offset = this.bb.__offset(this.bb_pos, 20);
+        return offset ? this.bb.readFloat32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
+      }
+      floatsLength() {
+        const offset = this.bb.__offset(this.bb_pos, 20);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+      }
+      floatsArray() {
+        const 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;
+      }
+      ints(index) {
+        const offset = this.bb.__offset(this.bb_pos, 22);
+        return offset ? this.bb.readInt64(this.bb.__vector(this.bb_pos + offset) + index * 8) : BigInt(0);
+      }
+      intsLength() {
+        const offset = this.bb.__offset(this.bb_pos, 22);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+      }
+      strings(index, optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 24);
+        return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;
+      }
+      stringsLength() {
+        const offset = this.bb.__offset(this.bb_pos, 24);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+      }
+      tensors(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 26);
+        return offset ? (obj || new tensor_js_1.Tensor()).__init(
+          this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
+          this.bb
+        ) : null;
+      }
+      tensorsLength() {
+        const offset = this.bb.__offset(this.bb_pos, 26);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+      }
+      graphs(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 28);
+        return offset ? (obj || new graph_js_1.Graph()).__init(
+          this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
+          this.bb
+        ) : null;
+      }
+      graphsLength() {
+        const offset = this.bb.__offset(this.bb_pos, 28);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+      }
+      static startAttribute(builder) {
+        builder.startObject(13);
+      }
+      static addName(builder, nameOffset) {
+        builder.addFieldOffset(0, nameOffset, 0);
+      }
+      static addDocString(builder, docStringOffset) {
+        builder.addFieldOffset(1, docStringOffset, 0);
+      }
+      static addType(builder, type) {
+        builder.addFieldInt32(2, type, attribute_type_js_1.AttributeType.UNDEFINED);
+      }
+      static addF(builder, f) {
+        builder.addFieldFloat32(3, f, 0);
+      }
+      static addI(builder, i) {
+        builder.addFieldInt64(4, i, BigInt("0"));
+      }
+      static addS(builder, sOffset) {
+        builder.addFieldOffset(5, sOffset, 0);
+      }
+      static addT(builder, tOffset) {
+        builder.addFieldOffset(6, tOffset, 0);
+      }
+      static addG(builder, gOffset) {
+        builder.addFieldOffset(7, gOffset, 0);
+      }
+      static addFloats(builder, floatsOffset) {
+        builder.addFieldOffset(8, floatsOffset, 0);
+      }
+      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();
+      }
+      static startFloatsVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+      }
+      static addInts(builder, intsOffset) {
+        builder.addFieldOffset(9, intsOffset, 0);
+      }
+      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();
+      }
+      static startIntsVector(builder, numElems) {
+        builder.startVector(8, numElems, 8);
+      }
+      static addStrings(builder, stringsOffset) {
+        builder.addFieldOffset(10, stringsOffset, 0);
+      }
+      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();
+      }
+      static startStringsVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+      }
+      static addTensors(builder, tensorsOffset) {
+        builder.addFieldOffset(11, tensorsOffset, 0);
+      }
+      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();
+      }
+      static startTensorsVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+      }
+      static addGraphs(builder, graphsOffset) {
+        builder.addFieldOffset(12, graphsOffset, 0);
+      }
+      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();
+      }
+      static startGraphsVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+      }
+      static endAttribute(builder) {
+        const offset = builder.endObject();
+        return offset;
+      }
+    };
+    exports.Attribute = Attribute3;
+  }
+});
+
+// web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/deprecated-kernel-create-infos.js
+var require_deprecated_kernel_create_infos = __commonJS({
+  "web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/deprecated-kernel-create-infos.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = {
+          enumerable: true,
+          get: function() {
+            return m[k];
+          }
+        };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DeprecatedKernelCreateInfos = void 0;
+    var flatbuffers2 = __importStar(require_flatbuffers());
+    var DeprecatedKernelCreateInfos2 = class _DeprecatedKernelCreateInfos {
+      constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+      }
+      __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+      }
+      static getRootAsDeprecatedKernelCreateInfos(bb, obj) {
+        return (obj || new _DeprecatedKernelCreateInfos()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      static getSizePrefixedRootAsDeprecatedKernelCreateInfos(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers2.SIZE_PREFIX_LENGTH);
+        return (obj || new _DeprecatedKernelCreateInfos()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      nodeIndices(index) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
+      }
+      nodeIndicesLength() {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+      }
+      nodeIndicesArray() {
+        const 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;
+      }
+      kernelDefHashes(index) {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.readUint64(this.bb.__vector(this.bb_pos + offset) + index * 8) : BigInt(0);
+      }
+      kernelDefHashesLength() {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+      }
+      static startDeprecatedKernelCreateInfos(builder) {
+        builder.startObject(2);
+      }
+      static addNodeIndices(builder, nodeIndicesOffset) {
+        builder.addFieldOffset(0, nodeIndicesOffset, 0);
+      }
+      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();
+      }
+      static startNodeIndicesVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+      }
+      static addKernelDefHashes(builder, kernelDefHashesOffset) {
+        builder.addFieldOffset(1, kernelDefHashesOffset, 0);
+      }
+      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();
+      }
+      static startKernelDefHashesVector(builder, numElems) {
+        builder.startVector(8, numElems, 8);
+      }
+      static endDeprecatedKernelCreateInfos(builder) {
+        const offset = builder.endObject();
+        return offset;
+      }
+      static createDeprecatedKernelCreateInfos(builder, nodeIndicesOffset, kernelDefHashesOffset) {
+        _DeprecatedKernelCreateInfos.startDeprecatedKernelCreateInfos(builder);
+        _DeprecatedKernelCreateInfos.addNodeIndices(builder, nodeIndicesOffset);
+        _DeprecatedKernelCreateInfos.addKernelDefHashes(builder, kernelDefHashesOffset);
+        return _DeprecatedKernelCreateInfos.endDeprecatedKernelCreateInfos(builder);
+      }
+    };
+    exports.DeprecatedKernelCreateInfos = DeprecatedKernelCreateInfos2;
+  }
+});
+
+// web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/deprecated-node-index-and-kernel-def-hash.js
+var require_deprecated_node_index_and_kernel_def_hash = __commonJS({
+  "web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/deprecated-node-index-and-kernel-def-hash.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = {
+          enumerable: true,
+          get: function() {
+            return m[k];
+          }
+        };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DeprecatedNodeIndexAndKernelDefHash = void 0;
+    var flatbuffers2 = __importStar(require_flatbuffers());
+    var DeprecatedNodeIndexAndKernelDefHash2 = class _DeprecatedNodeIndexAndKernelDefHash {
+      constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+      }
+      __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+      }
+      static getRootAsDeprecatedNodeIndexAndKernelDefHash(bb, obj) {
+        return (obj || new _DeprecatedNodeIndexAndKernelDefHash()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      static getSizePrefixedRootAsDeprecatedNodeIndexAndKernelDefHash(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers2.SIZE_PREFIX_LENGTH);
+        return (obj || new _DeprecatedNodeIndexAndKernelDefHash()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      nodeIndex() {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
+      }
+      kernelDefHash() {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.readUint64(this.bb_pos + offset) : BigInt("0");
+      }
+      static startDeprecatedNodeIndexAndKernelDefHash(builder) {
+        builder.startObject(2);
+      }
+      static addNodeIndex(builder, nodeIndex) {
+        builder.addFieldInt32(0, nodeIndex, 0);
+      }
+      static addKernelDefHash(builder, kernelDefHash) {
+        builder.addFieldInt64(1, kernelDefHash, BigInt("0"));
+      }
+      static endDeprecatedNodeIndexAndKernelDefHash(builder) {
+        const offset = builder.endObject();
+        return offset;
+      }
+      static createDeprecatedNodeIndexAndKernelDefHash(builder, nodeIndex, kernelDefHash) {
+        _DeprecatedNodeIndexAndKernelDefHash.startDeprecatedNodeIndexAndKernelDefHash(builder);
+        _DeprecatedNodeIndexAndKernelDefHash.addNodeIndex(builder, nodeIndex);
+        _DeprecatedNodeIndexAndKernelDefHash.addKernelDefHash(builder, kernelDefHash);
+        return _DeprecatedNodeIndexAndKernelDefHash.endDeprecatedNodeIndexAndKernelDefHash(builder);
+      }
+    };
+    exports.DeprecatedNodeIndexAndKernelDefHash = DeprecatedNodeIndexAndKernelDefHash2;
+  }
+});
+
+// web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/deprecated-sub-graph-session-state.js
+var require_deprecated_sub_graph_session_state = __commonJS({
+  "web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/deprecated-sub-graph-session-state.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = {
+          enumerable: true,
+          get: function() {
+            return m[k];
+          }
+        };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DeprecatedSubGraphSessionState = void 0;
+    var flatbuffers2 = __importStar(require_flatbuffers());
+    var deprecated_session_state_js_1 = require_deprecated_session_state();
+    var DeprecatedSubGraphSessionState2 = class _DeprecatedSubGraphSessionState {
+      constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+      }
+      __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+      }
+      static getRootAsDeprecatedSubGraphSessionState(bb, obj) {
+        return (obj || new _DeprecatedSubGraphSessionState()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      static getSizePrefixedRootAsDeprecatedSubGraphSessionState(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers2.SIZE_PREFIX_LENGTH);
+        return (obj || new _DeprecatedSubGraphSessionState()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      graphId(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+      }
+      sessionState(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? (obj || new deprecated_session_state_js_1.DeprecatedSessionState()).__init(
+          this.bb.__indirect(this.bb_pos + offset),
+          this.bb
+        ) : null;
+      }
+      static startDeprecatedSubGraphSessionState(builder) {
+        builder.startObject(2);
+      }
+      static addGraphId(builder, graphIdOffset) {
+        builder.addFieldOffset(0, graphIdOffset, 0);
+      }
+      static addSessionState(builder, sessionStateOffset) {
+        builder.addFieldOffset(1, sessionStateOffset, 0);
+      }
+      static endDeprecatedSubGraphSessionState(builder) {
+        const offset = builder.endObject();
+        builder.requiredField(offset, 4);
+        return offset;
+      }
+    };
+    exports.DeprecatedSubGraphSessionState = DeprecatedSubGraphSessionState2;
+  }
+});
+
+// web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/deprecated-session-state.js
+var require_deprecated_session_state = __commonJS({
+  "web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/deprecated-session-state.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = {
+          enumerable: true,
+          get: function() {
+            return m[k];
+          }
+        };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DeprecatedSessionState = void 0;
+    var flatbuffers2 = __importStar(require_flatbuffers());
+    var deprecated_kernel_create_infos_js_1 = require_deprecated_kernel_create_infos();
+    var deprecated_sub_graph_session_state_js_1 = require_deprecated_sub_graph_session_state();
+    var DeprecatedSessionState2 = class _DeprecatedSessionState {
+      constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+      }
+      __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+      }
+      static getRootAsDeprecatedSessionState(bb, obj) {
+        return (obj || new _DeprecatedSessionState()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      static getSizePrefixedRootAsDeprecatedSessionState(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers2.SIZE_PREFIX_LENGTH);
+        return (obj || new _DeprecatedSessionState()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      kernels(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? (obj || new deprecated_kernel_create_infos_js_1.DeprecatedKernelCreateInfos()).__init(
+          this.bb.__indirect(this.bb_pos + offset),
+          this.bb
+        ) : null;
+      }
+      subGraphSessionStates(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? (obj || new deprecated_sub_graph_session_state_js_1.DeprecatedSubGraphSessionState()).__init(
+          this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
+          this.bb
+        ) : null;
+      }
+      subGraphSessionStatesLength() {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+      }
+      static startDeprecatedSessionState(builder) {
+        builder.startObject(2);
+      }
+      static addKernels(builder, kernelsOffset) {
+        builder.addFieldOffset(0, kernelsOffset, 0);
+      }
+      static addSubGraphSessionStates(builder, subGraphSessionStatesOffset) {
+        builder.addFieldOffset(1, subGraphSessionStatesOffset, 0);
+      }
+      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();
+      }
+      static startSubGraphSessionStatesVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+      }
+      static endDeprecatedSessionState(builder) {
+        const offset = builder.endObject();
+        return offset;
+      }
+      static createDeprecatedSessionState(builder, kernelsOffset, subGraphSessionStatesOffset) {
+        _DeprecatedSessionState.startDeprecatedSessionState(builder);
+        _DeprecatedSessionState.addKernels(builder, kernelsOffset);
+        _DeprecatedSessionState.addSubGraphSessionStates(builder, subGraphSessionStatesOffset);
+        return _DeprecatedSessionState.endDeprecatedSessionState(builder);
+      }
+    };
+    exports.DeprecatedSessionState = DeprecatedSessionState2;
+  }
+});
+
+// web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/kernel-type-str-args-entry.js
+var require_kernel_type_str_args_entry = __commonJS({
+  "web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/kernel-type-str-args-entry.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = {
+          enumerable: true,
+          get: function() {
+            return m[k];
+          }
+        };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.KernelTypeStrArgsEntry = void 0;
+    var flatbuffers2 = __importStar(require_flatbuffers());
+    var arg_type_and_index_js_1 = require_arg_type_and_index();
+    var KernelTypeStrArgsEntry2 = class _KernelTypeStrArgsEntry {
+      constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+      }
+      __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+      }
+      static getRootAsKernelTypeStrArgsEntry(bb, obj) {
+        return (obj || new _KernelTypeStrArgsEntry()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      static getSizePrefixedRootAsKernelTypeStrArgsEntry(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers2.SIZE_PREFIX_LENGTH);
+        return (obj || new _KernelTypeStrArgsEntry()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      kernelTypeStr(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+      }
+      args(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? (obj || new arg_type_and_index_js_1.ArgTypeAndIndex()).__init(
+          this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
+          this.bb
+        ) : null;
+      }
+      argsLength() {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+      }
+      static startKernelTypeStrArgsEntry(builder) {
+        builder.startObject(2);
+      }
+      static addKernelTypeStr(builder, kernelTypeStrOffset) {
+        builder.addFieldOffset(0, kernelTypeStrOffset, 0);
+      }
+      static addArgs(builder, argsOffset) {
+        builder.addFieldOffset(1, argsOffset, 0);
+      }
+      static createArgsVector(builder, data) {
+        builder.startVector(4, data.length, 4);
+        for (let i = data.length - 1; i >= 0; i--) {
+          builder.addOffset(data[i]);
+        }
+        return builder.endVector();
+      }
+      static startArgsVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+      }
+      static endKernelTypeStrArgsEntry(builder) {
+        const offset = builder.endObject();
+        builder.requiredField(offset, 4);
+        return offset;
+      }
+      static createKernelTypeStrArgsEntry(builder, kernelTypeStrOffset, argsOffset) {
+        _KernelTypeStrArgsEntry.startKernelTypeStrArgsEntry(builder);
+        _KernelTypeStrArgsEntry.addKernelTypeStr(builder, kernelTypeStrOffset);
+        _KernelTypeStrArgsEntry.addArgs(builder, argsOffset);
+        return _KernelTypeStrArgsEntry.endKernelTypeStrArgsEntry(builder);
+      }
+    };
+    exports.KernelTypeStrArgsEntry = KernelTypeStrArgsEntry2;
+  }
+});
+
+// web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/op-id-kernel-type-str-args-entry.js
+var require_op_id_kernel_type_str_args_entry = __commonJS({
+  "web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/op-id-kernel-type-str-args-entry.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = {
+          enumerable: true,
+          get: function() {
+            return m[k];
+          }
+        };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.OpIdKernelTypeStrArgsEntry = void 0;
+    var flatbuffers2 = __importStar(require_flatbuffers());
+    var kernel_type_str_args_entry_js_1 = require_kernel_type_str_args_entry();
+    var OpIdKernelTypeStrArgsEntry2 = class _OpIdKernelTypeStrArgsEntry {
+      constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+      }
+      __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+      }
+      static getRootAsOpIdKernelTypeStrArgsEntry(bb, obj) {
+        return (obj || new _OpIdKernelTypeStrArgsEntry()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      static getSizePrefixedRootAsOpIdKernelTypeStrArgsEntry(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers2.SIZE_PREFIX_LENGTH);
+        return (obj || new _OpIdKernelTypeStrArgsEntry()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      opId(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+      }
+      kernelTypeStrArgs(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? (obj || new kernel_type_str_args_entry_js_1.KernelTypeStrArgsEntry()).__init(
+          this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
+          this.bb
+        ) : null;
+      }
+      kernelTypeStrArgsLength() {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+      }
+      static startOpIdKernelTypeStrArgsEntry(builder) {
+        builder.startObject(2);
+      }
+      static addOpId(builder, opIdOffset) {
+        builder.addFieldOffset(0, opIdOffset, 0);
+      }
+      static addKernelTypeStrArgs(builder, kernelTypeStrArgsOffset) {
+        builder.addFieldOffset(1, kernelTypeStrArgsOffset, 0);
+      }
+      static createKernelTypeStrArgsVector(builder, data) {
+        builder.startVector(4, data.length, 4);
+        for (let i = data.length - 1; i >= 0; i--) {
+          builder.addOffset(data[i]);
+        }
+        return builder.endVector();
+      }
+      static startKernelTypeStrArgsVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+      }
+      static endOpIdKernelTypeStrArgsEntry(builder) {
+        const offset = builder.endObject();
+        builder.requiredField(offset, 4);
+        return offset;
+      }
+      static createOpIdKernelTypeStrArgsEntry(builder, opIdOffset, kernelTypeStrArgsOffset) {
+        _OpIdKernelTypeStrArgsEntry.startOpIdKernelTypeStrArgsEntry(builder);
+        _OpIdKernelTypeStrArgsEntry.addOpId(builder, opIdOffset);
+        _OpIdKernelTypeStrArgsEntry.addKernelTypeStrArgs(builder, kernelTypeStrArgsOffset);
+        return _OpIdKernelTypeStrArgsEntry.endOpIdKernelTypeStrArgsEntry(builder);
+      }
+    };
+    exports.OpIdKernelTypeStrArgsEntry = OpIdKernelTypeStrArgsEntry2;
+  }
+});
+
+// web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/kernel-type-str-resolver.js
+var require_kernel_type_str_resolver = __commonJS({
+  "web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/kernel-type-str-resolver.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = {
+          enumerable: true,
+          get: function() {
+            return m[k];
+          }
+        };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.KernelTypeStrResolver = void 0;
+    var flatbuffers2 = __importStar(require_flatbuffers());
+    var op_id_kernel_type_str_args_entry_js_1 = require_op_id_kernel_type_str_args_entry();
+    var KernelTypeStrResolver2 = class _KernelTypeStrResolver {
+      constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+      }
+      __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+      }
+      static getRootAsKernelTypeStrResolver(bb, obj) {
+        return (obj || new _KernelTypeStrResolver()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      static getSizePrefixedRootAsKernelTypeStrResolver(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers2.SIZE_PREFIX_LENGTH);
+        return (obj || new _KernelTypeStrResolver()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      opKernelTypeStrArgs(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? (obj || new op_id_kernel_type_str_args_entry_js_1.OpIdKernelTypeStrArgsEntry()).__init(
+          this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
+          this.bb
+        ) : null;
+      }
+      opKernelTypeStrArgsLength() {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+      }
+      static startKernelTypeStrResolver(builder) {
+        builder.startObject(1);
+      }
+      static addOpKernelTypeStrArgs(builder, opKernelTypeStrArgsOffset) {
+        builder.addFieldOffset(0, opKernelTypeStrArgsOffset, 0);
+      }
+      static createOpKernelTypeStrArgsVector(builder, data) {
+        builder.startVector(4, data.length, 4);
+        for (let i = data.length - 1; i >= 0; i--) {
+          builder.addOffset(data[i]);
+        }
+        return builder.endVector();
+      }
+      static startOpKernelTypeStrArgsVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+      }
+      static endKernelTypeStrResolver(builder) {
+        const offset = builder.endObject();
+        return offset;
+      }
+      static createKernelTypeStrResolver(builder, opKernelTypeStrArgsOffset) {
+        _KernelTypeStrResolver.startKernelTypeStrResolver(builder);
+        _KernelTypeStrResolver.addOpKernelTypeStrArgs(builder, opKernelTypeStrArgsOffset);
+        return _KernelTypeStrResolver.endKernelTypeStrResolver(builder);
+      }
+    };
+    exports.KernelTypeStrResolver = KernelTypeStrResolver2;
+  }
+});
+
+// web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/operator-set-id.js
+var require_operator_set_id = __commonJS({
+  "web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/operator-set-id.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = {
+          enumerable: true,
+          get: function() {
+            return m[k];
+          }
+        };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.OperatorSetId = void 0;
+    var flatbuffers2 = __importStar(require_flatbuffers());
+    var OperatorSetId2 = class _OperatorSetId {
+      constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+      }
+      __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+      }
+      static getRootAsOperatorSetId(bb, obj) {
+        return (obj || new _OperatorSetId()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      static getSizePrefixedRootAsOperatorSetId(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers2.SIZE_PREFIX_LENGTH);
+        return (obj || new _OperatorSetId()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      domain(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+      }
+      version() {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.readInt64(this.bb_pos + offset) : BigInt("0");
+      }
+      static startOperatorSetId(builder) {
+        builder.startObject(2);
+      }
+      static addDomain(builder, domainOffset) {
+        builder.addFieldOffset(0, domainOffset, 0);
+      }
+      static addVersion(builder, version3) {
+        builder.addFieldInt64(1, version3, BigInt("0"));
+      }
+      static endOperatorSetId(builder) {
+        const 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);
+      }
+    };
+    exports.OperatorSetId = OperatorSetId2;
+  }
+});
+
+// web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/string-string-entry.js
+var require_string_string_entry = __commonJS({
+  "web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/string-string-entry.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = {
+          enumerable: true,
+          get: function() {
+            return m[k];
+          }
+        };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.StringStringEntry = void 0;
+    var flatbuffers2 = __importStar(require_flatbuffers());
+    var StringStringEntry2 = class _StringStringEntry {
+      constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+      }
+      __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+      }
+      static getRootAsStringStringEntry(bb, obj) {
+        return (obj || new _StringStringEntry()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      static getSizePrefixedRootAsStringStringEntry(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers2.SIZE_PREFIX_LENGTH);
+        return (obj || new _StringStringEntry()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      key(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+      }
+      value(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+      }
+      static startStringStringEntry(builder) {
+        builder.startObject(2);
+      }
+      static addKey(builder, keyOffset) {
+        builder.addFieldOffset(0, keyOffset, 0);
+      }
+      static addValue(builder, valueOffset) {
+        builder.addFieldOffset(1, valueOffset, 0);
+      }
+      static endStringStringEntry(builder) {
+        const offset = builder.endObject();
+        return offset;
+      }
+      static createStringStringEntry(builder, keyOffset, valueOffset) {
+        _StringStringEntry.startStringStringEntry(builder);
+        _StringStringEntry.addKey(builder, keyOffset);
+        _StringStringEntry.addValue(builder, valueOffset);
+        return _StringStringEntry.endStringStringEntry(builder);
+      }
+    };
+    exports.StringStringEntry = StringStringEntry2;
+  }
+});
+
+// web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/model.js
+var require_model = __commonJS({
+  "web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/model.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = {
+          enumerable: true,
+          get: function() {
+            return m[k];
+          }
+        };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Model = void 0;
+    var flatbuffers2 = __importStar(require_flatbuffers());
+    var graph_js_1 = require_graph();
+    var operator_set_id_js_1 = require_operator_set_id();
+    var string_string_entry_js_1 = require_string_string_entry();
+    var Model3 = class _Model {
+      constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+      }
+      __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+      }
+      static getRootAsModel(bb, obj) {
+        return (obj || new _Model()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      static getSizePrefixedRootAsModel(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers2.SIZE_PREFIX_LENGTH);
+        return (obj || new _Model()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      irVersion() {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.readInt64(this.bb_pos + offset) : BigInt("0");
+      }
+      opsetImport(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? (obj || new operator_set_id_js_1.OperatorSetId()).__init(
+          this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
+          this.bb
+        ) : null;
+      }
+      opsetImportLength() {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+      }
+      producerName(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+      }
+      producerVersion(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 10);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+      }
+      domain(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 12);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+      }
+      modelVersion() {
+        const offset = this.bb.__offset(this.bb_pos, 14);
+        return offset ? this.bb.readInt64(this.bb_pos + offset) : BigInt("0");
+      }
+      docString(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 16);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+      }
+      graph(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 18);
+        return offset ? (obj || new graph_js_1.Graph()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+      }
+      graphDocString(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 20);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+      }
+      metadataProps(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 22);
+        return offset ? (obj || new string_string_entry_js_1.StringStringEntry()).__init(
+          this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
+          this.bb
+        ) : null;
+      }
+      metadataPropsLength() {
+        const offset = this.bb.__offset(this.bb_pos, 22);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+      }
+      static startModel(builder) {
+        builder.startObject(10);
+      }
+      static addIrVersion(builder, irVersion) {
+        builder.addFieldInt64(0, irVersion, BigInt("0"));
+      }
+      static addOpsetImport(builder, opsetImportOffset) {
+        builder.addFieldOffset(1, opsetImportOffset, 0);
+      }
+      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();
+      }
+      static startOpsetImportVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+      }
+      static addProducerName(builder, producerNameOffset) {
+        builder.addFieldOffset(2, producerNameOffset, 0);
+      }
+      static addProducerVersion(builder, producerVersionOffset) {
+        builder.addFieldOffset(3, producerVersionOffset, 0);
+      }
+      static addDomain(builder, domainOffset) {
+        builder.addFieldOffset(4, domainOffset, 0);
+      }
+      static addModelVersion(builder, modelVersion) {
+        builder.addFieldInt64(5, modelVersion, BigInt("0"));
+      }
+      static addDocString(builder, docStringOffset) {
+        builder.addFieldOffset(6, docStringOffset, 0);
+      }
+      static addGraph(builder, graphOffset) {
+        builder.addFieldOffset(7, graphOffset, 0);
+      }
+      static addGraphDocString(builder, graphDocStringOffset) {
+        builder.addFieldOffset(8, graphDocStringOffset, 0);
+      }
+      static addMetadataProps(builder, metadataPropsOffset) {
+        builder.addFieldOffset(9, metadataPropsOffset, 0);
+      }
+      static createMetadataPropsVector(builder, data) {
+        builder.startVector(4, data.length, 4);
+        for (let i = data.length - 1; i >= 0; i--) {
+          builder.addOffset(data[i]);
+        }
+        return builder.endVector();
+      }
+      static startMetadataPropsVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+      }
+      static endModel(builder) {
+        const offset = builder.endObject();
+        return offset;
+      }
+    };
+    exports.Model = Model3;
+  }
+});
+
+// web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/inference-session.js
+var require_inference_session = __commonJS({
+  "web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/inference-session.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = {
+          enumerable: true,
+          get: function() {
+            return m[k];
+          }
+        };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.InferenceSession = void 0;
+    var flatbuffers2 = __importStar(require_flatbuffers());
+    var kernel_type_str_resolver_js_1 = require_kernel_type_str_resolver();
+    var model_js_1 = require_model();
+    var InferenceSession5 = class _InferenceSession {
+      constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+      }
+      __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+      }
+      static getRootAsInferenceSession(bb, obj) {
+        return (obj || new _InferenceSession()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      static getSizePrefixedRootAsInferenceSession(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers2.SIZE_PREFIX_LENGTH);
+        return (obj || new _InferenceSession()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+      }
+      static bufferHasIdentifier(bb) {
+        return bb.__has_identifier("ORTM");
+      }
+      ortVersion(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+      }
+      model(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? (obj || new model_js_1.Model()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+      }
+      kernelTypeStrResolver(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 10);
+        return offset ? (obj || new kernel_type_str_resolver_js_1.KernelTypeStrResolver()).__init(
+          this.bb.__indirect(this.bb_pos + offset),
+          this.bb
+        ) : null;
+      }
+      static startInferenceSession(builder) {
+        builder.startObject(4);
+      }
+      static addOrtVersion(builder, ortVersionOffset) {
+        builder.addFieldOffset(0, ortVersionOffset, 0);
+      }
+      static addModel(builder, modelOffset) {
+        builder.addFieldOffset(1, modelOffset, 0);
+      }
+      static addKernelTypeStrResolver(builder, kernelTypeStrResolverOffset) {
+        builder.addFieldOffset(3, kernelTypeStrResolverOffset, 0);
+      }
+      static endInferenceSession(builder) {
+        const offset = builder.endObject();
+        return offset;
+      }
+      static finishInferenceSessionBuffer(builder, offset) {
+        builder.finish(offset, "ORTM");
+      }
+      static finishSizePrefixedInferenceSessionBuffer(builder, offset) {
+        builder.finish(offset, "ORTM", true);
+      }
+    };
+    exports.InferenceSession = InferenceSession5;
+  }
+});
+
+// web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs.ts
+var import_arg_type, import_arg_type_and_index, import_attribute, import_attribute_type, import_deprecated_kernel_create_infos, import_deprecated_node_index_and_kernel_def_hash, import_deprecated_session_state, import_deprecated_sub_graph_session_state, import_dimension, import_dimension_value, import_dimension_value_type, import_edge_end, import_graph, import_inference_session, import_kernel_type_str_args_entry, import_kernel_type_str_resolver, import_map_type, import_model, import_node, import_node_edge, import_node_type, import_nodes_to_optimize_indices, import_op_id_kernel_type_str_args_entry, import_operator_set_id, import_runtime_optimization_record, import_runtime_optimization_record_container_entry, import_runtime_optimizations, import_sequence_type, import_shape, import_sparse_tensor, import_string_string_entry, import_tensor2, import_tensor_data_type, import_tensor_type_and_shape, import_type_info, import_type_info_value, import_value_info;
+var init_fbs = __esm({
+  "web/lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs.ts"() {
+    "use strict";
+    import_arg_type = __toESM(require_arg_type());
+    import_arg_type_and_index = __toESM(require_arg_type_and_index());
+    import_attribute = __toESM(require_attribute());
+    import_attribute_type = __toESM(require_attribute_type());
+    import_deprecated_kernel_create_infos = __toESM(require_deprecated_kernel_create_infos());
+    import_deprecated_node_index_and_kernel_def_hash = __toESM(require_deprecated_node_index_and_kernel_def_hash());
+    import_deprecated_session_state = __toESM(require_deprecated_session_state());
+    import_deprecated_sub_graph_session_state = __toESM(require_deprecated_sub_graph_session_state());
+    import_dimension = __toESM(require_dimension());
+    import_dimension_value = __toESM(require_dimension_value());
+    import_dimension_value_type = __toESM(require_dimension_value_type());
+    import_edge_end = __toESM(require_edge_end());
+    import_graph = __toESM(require_graph());
+    import_inference_session = __toESM(require_inference_session());
+    import_kernel_type_str_args_entry = __toESM(require_kernel_type_str_args_entry());
+    import_kernel_type_str_resolver = __toESM(require_kernel_type_str_resolver());
+    import_map_type = __toESM(require_map_type());
+    import_model = __toESM(require_model());
+    import_node = __toESM(require_node());
+    import_node_edge = __toESM(require_node_edge());
+    import_node_type = __toESM(require_node_type());
+    import_nodes_to_optimize_indices = __toESM(require_nodes_to_optimize_indices());
+    import_op_id_kernel_type_str_args_entry = __toESM(require_op_id_kernel_type_str_args_entry());
+    import_operator_set_id = __toESM(require_operator_set_id());
+    import_runtime_optimization_record = __toESM(require_runtime_optimization_record());
+    import_runtime_optimization_record_container_entry = __toESM(require_runtime_optimization_record_container_entry());
+    import_runtime_optimizations = __toESM(require_runtime_optimizations());
+    import_sequence_type = __toESM(require_sequence_type());
+    import_shape = __toESM(require_shape());
+    import_sparse_tensor = __toESM(require_sparse_tensor());
+    import_string_string_entry = __toESM(require_string_string_entry());
+    import_tensor2 = __toESM(require_tensor());
+    import_tensor_data_type = __toESM(require_tensor_data_type());
+    import_tensor_type_and_shape = __toESM(require_tensor_type_and_shape());
+    import_type_info = __toESM(require_type_info());
+    import_type_info_value = __toESM(require_type_info_value());
+    import_value_info = __toESM(require_value_info());
+  }
+});
+
+// web/lib/onnxjs/ort-schema/flatbuffers/ort-generated.ts
+var init_ort_generated = __esm({
+  "web/lib/onnxjs/ort-schema/flatbuffers/ort-generated.ts"() {
+    "use strict";
+    init_fbs();
+  }
+});
+
+// web/node_modules/@protobufjs/aspromise/index.js
+var require_aspromise = __commonJS({
+  "web/node_modules/@protobufjs/aspromise/index.js"(exports, module) {
+    "use strict";
+    module.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"(exports) {
+    "use strict";
+    var base64 = exports;
+    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"(exports, module) {
+    "use strict";
+    module.exports = EventEmitter;
+    function EventEmitter() {
+      this._listeners = /* @__PURE__ */ Object.create(null);
+    }
+    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 = /* @__PURE__ */ Object.create(null);
+      else {
+        if (fn === void 0)
+          this._listeners[evt] = [];
+        else {
+          var listeners = this._listeners[evt];
+          if (!listeners)
+            return this;
+          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"(exports, module) {
+    "use strict";
+    module.exports = factory(factory);
+    function factory(exports2) {
+      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];
+        }
+        exports2.writeFloatLE = le ? writeFloat_f32_cpy : writeFloat_f32_rev;
+        exports2.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];
+        }
+        exports2.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev;
+        exports2.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);
+          }
+        }
+        exports2.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);
+        exports2.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);
+        }
+        exports2.readFloatLE = readFloat_ieee754.bind(null, readUintLE);
+        exports2.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];
+        }
+        exports2.writeDoubleLE = le ? writeDouble_f64_cpy : writeDouble_f64_rev;
+        exports2.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];
+        }
+        exports2.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;
+        exports2.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);
+            }
+          }
+        }
+        exports2.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);
+        exports2.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);
+        }
+        exports2.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4);
+        exports2.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 4, 0);
+      })();
+      return exports2;
+    }
+    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 {
+        if (typeof __require !== "function") {
+          return null;
+        }
+        var mod = __require(moduleName);
+        if (mod && (mod.length || Object.keys(mod).length)) return mod;
+        return null;
+      } catch (err) {
+        return null;
+      }
+    }
+  }
+});
+
+// web/node_modules/@protobufjs/utf8/index.js
+var require_utf8 = __commonJS({
+  "web/node_modules/@protobufjs/utf8/index.js"(exports) {
+    "use strict";
+    var utf8 = exports;
+    var replacementChar = "\uFFFD";
+    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) {
+      if (end - start < 1) {
+        return "";
+      }
+      var str = "";
+      for (var i = start; i < end; ) {
+        var t = buffer[i++];
+        if (t <= 127) {
+          str += String.fromCharCode(t);
+        } else if (t >= 192 && t < 224) {
+          var c2 = (t & 31) << 6 | buffer[i++] & 63;
+          str += c2 >= 128 ? String.fromCharCode(c2) : replacementChar;
+        } else if (t >= 224 && t < 240) {
+          var c3 = (t & 15) << 12 | (buffer[i++] & 63) << 6 | buffer[i++] & 63;
+          str += c3 >= 2048 ? String.fromCharCode(c3) : replacementChar;
+        } else if (t >= 240) {
+          var t2 = (t & 7) << 18 | (buffer[i++] & 63) << 12 | (buffer[i++] & 63) << 6 | buffer[i++] & 63;
+          if (t2 < 65536 || t2 > 1114111)
+            str += replacementChar;
+          else {
+            t2 -= 65536;
+            str += String.fromCharCode(55296 + (t2 >> 10));
+            str += String.fromCharCode(56320 + (t2 & 1023));
+          }
+        }
+      }
+      return str;
+    };
+    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"(exports, module) {
+    "use strict";
+    module.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"(exports, module) {
+    "use strict";
+    module.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/long/umd/index.js
+var require_umd = __commonJS({
+  "web/node_modules/long/umd/index.js"(exports, module) {
+    (function(global2, factory) {
+      function preferDefault(exports2) {
+        return exports2.default || exports2;
+      }
+      if (typeof define === "function" && define.amd) {
+        define([], function() {
+          var exports2 = {};
+          factory(exports2);
+          return preferDefault(exports2);
+        });
+      } else if (typeof exports === "object") {
+        factory(exports);
+        if (typeof module === "object") module.exports = preferDefault(exports);
+      } else {
+        (function() {
+          var exports2 = {};
+          factory(exports2);
+          global2.Long = preferDefault(exports2);
+        })();
+      }
+    })(
+      typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : exports,
+      function(_exports) {
+        "use strict";
+        Object.defineProperty(_exports, "__esModule", {
+          value: true
+        });
+        _exports.default = void 0;
+        var wasm2 = null;
+        try {
+          wasm2 = new WebAssembly.Instance(
+            new WebAssembly.Module(
+              new Uint8Array([
+                // \0asm
+                0,
+                97,
+                115,
+                109,
+                // version 1
+                1,
+                0,
+                0,
+                0,
+                // section "type"
+                1,
+                13,
+                2,
+                // 0, () => i32
+                96,
+                0,
+                1,
+                127,
+                // 1, (i32, i32, i32, i32) => i32
+                96,
+                4,
+                127,
+                127,
+                127,
+                127,
+                1,
+                127,
+                // section "function"
+                3,
+                7,
+                6,
+                // 0, type 0
+                0,
+                // 1, type 1
+                1,
+                // 2, type 1
+                1,
+                // 3, type 1
+                1,
+                // 4, type 1
+                1,
+                // 5, type 1
+                1,
+                // section "global"
+                6,
+                6,
+                1,
+                // 0, "high", mutable i32
+                127,
+                1,
+                65,
+                0,
+                11,
+                // section "export"
+                7,
+                50,
+                6,
+                // 0, "mul"
+                3,
+                109,
+                117,
+                108,
+                0,
+                1,
+                // 1, "div_s"
+                5,
+                100,
+                105,
+                118,
+                95,
+                115,
+                0,
+                2,
+                // 2, "div_u"
+                5,
+                100,
+                105,
+                118,
+                95,
+                117,
+                0,
+                3,
+                // 3, "rem_s"
+                5,
+                114,
+                101,
+                109,
+                95,
+                115,
+                0,
+                4,
+                // 4, "rem_u"
+                5,
+                114,
+                101,
+                109,
+                95,
+                117,
+                0,
+                5,
+                // 5, "get_high"
+                8,
+                103,
+                101,
+                116,
+                95,
+                104,
+                105,
+                103,
+                104,
+                0,
+                0,
+                // section "code"
+                10,
+                191,
+                1,
+                6,
+                // 0, "get_high"
+                4,
+                0,
+                35,
+                0,
+                11,
+                // 1, "mul"
+                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,
+                // 2, "div_s"
+                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,
+                // 3, "div_u"
+                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,
+                // 4, "rem_s"
+                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,
+                // 5, "rem_u"
+                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 {
+        }
+        function Long2(low, high, unsigned) {
+          this.low = low | 0;
+          this.high = high | 0;
+          this.unsigned = !!unsigned;
+        }
+        Long2.prototype.__isLong__;
+        Object.defineProperty(Long2.prototype, "__isLong__", {
+          value: true
+        });
+        function isLong2(obj) {
+          return (obj && obj["__isLong__"]) === true;
+        }
+        function ctz322(value) {
+          var c = Math.clz32(value & -value);
+          return value ? 31 - c : c;
+        }
+        Long2.isLong = isLong2;
+        var INT_CACHE2 = {};
+        var UINT_CACHE2 = {};
+        function fromInt2(value, unsigned) {
+          var obj, cachedObj, cache2;
+          if (unsigned) {
+            value >>>= 0;
+            if (cache2 = 0 <= value && value < 256) {
+              cachedObj = UINT_CACHE2[value];
+              if (cachedObj) return cachedObj;
+            }
+            obj = fromBits2(value, 0, true);
+            if (cache2) UINT_CACHE2[value] = obj;
+            return obj;
+          } else {
+            value |= 0;
+            if (cache2 = -128 <= value && value < 128) {
+              cachedObj = INT_CACHE2[value];
+              if (cachedObj) return cachedObj;
+            }
+            obj = fromBits2(value, value < 0 ? -1 : 0, false);
+            if (cache2) INT_CACHE2[value] = obj;
+            return obj;
+          }
+        }
+        Long2.fromInt = fromInt2;
+        function fromNumber2(value, unsigned) {
+          if (isNaN(value)) return unsigned ? UZERO2 : ZERO2;
+          if (unsigned) {
+            if (value < 0) return UZERO2;
+            if (value >= TWO_PWR_64_DBL2) return MAX_UNSIGNED_VALUE2;
+          } else {
+            if (value <= -TWO_PWR_63_DBL2) return MIN_VALUE2;
+            if (value + 1 >= TWO_PWR_63_DBL2) return MAX_VALUE2;
+          }
+          if (value < 0) return fromNumber2(-value, unsigned).neg();
+          return fromBits2(
+            value % TWO_PWR_32_DBL2 | 0,
+            value / TWO_PWR_32_DBL2 | 0,
+            unsigned
+          );
+        }
+        Long2.fromNumber = fromNumber2;
+        function fromBits2(lowBits, highBits, unsigned) {
+          return new Long2(lowBits, highBits, unsigned);
+        }
+        Long2.fromBits = fromBits2;
+        var pow_dbl2 = Math.pow;
+        function fromString2(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 ? UZERO2 : ZERO2;
+          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 fromString2(str.substring(1), unsigned, radix).neg();
+          }
+          var radixToPower = fromNumber2(pow_dbl2(radix, 8));
+          var result = ZERO2;
+          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 = fromNumber2(pow_dbl2(radix, size));
+              result = result.mul(power).add(fromNumber2(value));
+            } else {
+              result = result.mul(radixToPower);
+              result = result.add(fromNumber2(value));
+            }
+          }
+          result.unsigned = unsigned;
+          return result;
+        }
+        Long2.fromString = fromString2;
+        function fromValue2(val, unsigned) {
+          if (typeof val === "number") return fromNumber2(val, unsigned);
+          if (typeof val === "string") return fromString2(val, unsigned);
+          return fromBits2(
+            val.low,
+            val.high,
+            typeof unsigned === "boolean" ? unsigned : val.unsigned
+          );
+        }
+        Long2.fromValue = fromValue2;
+        var TWO_PWR_16_DBL2 = 1 << 16;
+        var TWO_PWR_24_DBL2 = 1 << 24;
+        var TWO_PWR_32_DBL2 = TWO_PWR_16_DBL2 * TWO_PWR_16_DBL2;
+        var TWO_PWR_64_DBL2 = TWO_PWR_32_DBL2 * TWO_PWR_32_DBL2;
+        var TWO_PWR_63_DBL2 = TWO_PWR_64_DBL2 / 2;
+        var TWO_PWR_242 = fromInt2(TWO_PWR_24_DBL2);
+        var ZERO2 = fromInt2(0);
+        Long2.ZERO = ZERO2;
+        var UZERO2 = fromInt2(0, true);
+        Long2.UZERO = UZERO2;
+        var ONE2 = fromInt2(1);
+        Long2.ONE = ONE2;
+        var UONE2 = fromInt2(1, true);
+        Long2.UONE = UONE2;
+        var NEG_ONE2 = fromInt2(-1);
+        Long2.NEG_ONE = NEG_ONE2;
+        var MAX_VALUE2 = fromBits2(4294967295 | 0, 2147483647 | 0, false);
+        Long2.MAX_VALUE = MAX_VALUE2;
+        var MAX_UNSIGNED_VALUE2 = fromBits2(4294967295 | 0, 4294967295 | 0, true);
+        Long2.MAX_UNSIGNED_VALUE = MAX_UNSIGNED_VALUE2;
+        var MIN_VALUE2 = fromBits2(0, 2147483648 | 0, false);
+        Long2.MIN_VALUE = MIN_VALUE2;
+        var LongPrototype2 = Long2.prototype;
+        LongPrototype2.toInt = function toInt2() {
+          return this.unsigned ? this.low >>> 0 : this.low;
+        };
+        LongPrototype2.toNumber = function toNumber2() {
+          if (this.unsigned)
+            return (this.high >>> 0) * TWO_PWR_32_DBL2 + (this.low >>> 0);
+          return this.high * TWO_PWR_32_DBL2 + (this.low >>> 0);
+        };
+        LongPrototype2.toString = function toString2(radix) {
+          radix = radix || 10;
+          if (radix < 2 || 36 < radix) throw RangeError("radix");
+          if (this.isZero()) return "0";
+          if (this.isNegative()) {
+            if (this.eq(MIN_VALUE2)) {
+              var radixLong = fromNumber2(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 = fromNumber2(pow_dbl2(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;
+            }
+          }
+        };
+        LongPrototype2.getHighBits = function getHighBits2() {
+          return this.high;
+        };
+        LongPrototype2.getHighBitsUnsigned = function getHighBitsUnsigned2() {
+          return this.high >>> 0;
+        };
+        LongPrototype2.getLowBits = function getLowBits2() {
+          return this.low;
+        };
+        LongPrototype2.getLowBitsUnsigned = function getLowBitsUnsigned2() {
+          return this.low >>> 0;
+        };
+        LongPrototype2.getNumBitsAbs = function getNumBitsAbs2() {
+          if (this.isNegative())
+            return this.eq(MIN_VALUE2) ? 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;
+        };
+        LongPrototype2.isSafeInteger = function isSafeInteger2() {
+          var top11Bits = this.high >> 21;
+          if (!top11Bits) return true;
+          if (this.unsigned) return false;
+          return top11Bits === -1 && !(this.low === 0 && this.high === -2097152);
+        };
+        LongPrototype2.isZero = function isZero2() {
+          return this.high === 0 && this.low === 0;
+        };
+        LongPrototype2.eqz = LongPrototype2.isZero;
+        LongPrototype2.isNegative = function isNegative2() {
+          return !this.unsigned && this.high < 0;
+        };
+        LongPrototype2.isPositive = function isPositive2() {
+          return this.unsigned || this.high >= 0;
+        };
+        LongPrototype2.isOdd = function isOdd2() {
+          return (this.low & 1) === 1;
+        };
+        LongPrototype2.isEven = function isEven2() {
+          return (this.low & 1) === 0;
+        };
+        LongPrototype2.equals = function equals2(other) {
+          if (!isLong2(other)) other = fromValue2(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;
+        };
+        LongPrototype2.eq = LongPrototype2.equals;
+        LongPrototype2.notEquals = function notEquals2(other) {
+          return !this.eq(
+            /* validates */
+            other
+          );
+        };
+        LongPrototype2.neq = LongPrototype2.notEquals;
+        LongPrototype2.ne = LongPrototype2.notEquals;
+        LongPrototype2.lessThan = function lessThan2(other) {
+          return this.comp(
+            /* validates */
+            other
+          ) < 0;
+        };
+        LongPrototype2.lt = LongPrototype2.lessThan;
+        LongPrototype2.lessThanOrEqual = function lessThanOrEqual2(other) {
+          return this.comp(
+            /* validates */
+            other
+          ) <= 0;
+        };
+        LongPrototype2.lte = LongPrototype2.lessThanOrEqual;
+        LongPrototype2.le = LongPrototype2.lessThanOrEqual;
+        LongPrototype2.greaterThan = function greaterThan2(other) {
+          return this.comp(
+            /* validates */
+            other
+          ) > 0;
+        };
+        LongPrototype2.gt = LongPrototype2.greaterThan;
+        LongPrototype2.greaterThanOrEqual = function greaterThanOrEqual2(other) {
+          return this.comp(
+            /* validates */
+            other
+          ) >= 0;
+        };
+        LongPrototype2.gte = LongPrototype2.greaterThanOrEqual;
+        LongPrototype2.ge = LongPrototype2.greaterThanOrEqual;
+        LongPrototype2.compare = function compare2(other) {
+          if (!isLong2(other)) other = fromValue2(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;
+        };
+        LongPrototype2.comp = LongPrototype2.compare;
+        LongPrototype2.negate = function negate2() {
+          if (!this.unsigned && this.eq(MIN_VALUE2)) return MIN_VALUE2;
+          return this.not().add(ONE2);
+        };
+        LongPrototype2.neg = LongPrototype2.negate;
+        LongPrototype2.add = function add3(addend) {
+          if (!isLong2(addend)) addend = fromValue2(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 fromBits2(c16 << 16 | c00, c48 << 16 | c32, this.unsigned);
+        };
+        LongPrototype2.subtract = function subtract2(subtrahend) {
+          if (!isLong2(subtrahend)) subtrahend = fromValue2(subtrahend);
+          return this.add(subtrahend.neg());
+        };
+        LongPrototype2.sub = LongPrototype2.subtract;
+        LongPrototype2.multiply = function multiply2(multiplier) {
+          if (this.isZero()) return this;
+          if (!isLong2(multiplier)) multiplier = fromValue2(multiplier);
+          if (wasm2) {
+            var low = wasm2["mul"](
+              this.low,
+              this.high,
+              multiplier.low,
+              multiplier.high
+            );
+            return fromBits2(low, wasm2["get_high"](), this.unsigned);
+          }
+          if (multiplier.isZero()) return this.unsigned ? UZERO2 : ZERO2;
+          if (this.eq(MIN_VALUE2)) return multiplier.isOdd() ? MIN_VALUE2 : ZERO2;
+          if (multiplier.eq(MIN_VALUE2)) return this.isOdd() ? MIN_VALUE2 : ZERO2;
+          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_242) && multiplier.lt(TWO_PWR_242))
+            return fromNumber2(
+              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 fromBits2(c16 << 16 | c00, c48 << 16 | c32, this.unsigned);
+        };
+        LongPrototype2.mul = LongPrototype2.multiply;
+        LongPrototype2.divide = function divide2(divisor) {
+          if (!isLong2(divisor)) divisor = fromValue2(divisor);
+          if (divisor.isZero()) throw Error("division by zero");
+          if (wasm2) {
+            if (!this.unsigned && this.high === -2147483648 && divisor.low === -1 && divisor.high === -1) {
+              return this;
+            }
+            var low = (this.unsigned ? wasm2["div_u"] : wasm2["div_s"])(
+              this.low,
+              this.high,
+              divisor.low,
+              divisor.high
+            );
+            return fromBits2(low, wasm2["get_high"](), this.unsigned);
+          }
+          if (this.isZero()) return this.unsigned ? UZERO2 : ZERO2;
+          var approx, rem, res;
+          if (!this.unsigned) {
+            if (this.eq(MIN_VALUE2)) {
+              if (divisor.eq(ONE2) || divisor.eq(NEG_ONE2))
+                return MIN_VALUE2;
+              else if (divisor.eq(MIN_VALUE2)) return ONE2;
+              else {
+                var halfThis = this.shr(1);
+                approx = halfThis.div(divisor).shl(1);
+                if (approx.eq(ZERO2)) {
+                  return divisor.isNegative() ? ONE2 : NEG_ONE2;
+                } else {
+                  rem = this.sub(divisor.mul(approx));
+                  res = approx.add(rem.div(divisor));
+                  return res;
+                }
+              }
+            } else if (divisor.eq(MIN_VALUE2)) return this.unsigned ? UZERO2 : ZERO2;
+            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 = ZERO2;
+          } else {
+            if (!divisor.unsigned) divisor = divisor.toUnsigned();
+            if (divisor.gt(this)) return UZERO2;
+            if (divisor.gt(this.shru(1)))
+              return UONE2;
+            res = UZERO2;
+          }
+          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_dbl2(2, log22 - 48), approxRes = fromNumber2(approx), approxRem = approxRes.mul(divisor);
+            while (approxRem.isNegative() || approxRem.gt(rem)) {
+              approx -= delta;
+              approxRes = fromNumber2(approx, this.unsigned);
+              approxRem = approxRes.mul(divisor);
+            }
+            if (approxRes.isZero()) approxRes = ONE2;
+            res = res.add(approxRes);
+            rem = rem.sub(approxRem);
+          }
+          return res;
+        };
+        LongPrototype2.div = LongPrototype2.divide;
+        LongPrototype2.modulo = function modulo2(divisor) {
+          if (!isLong2(divisor)) divisor = fromValue2(divisor);
+          if (wasm2) {
+            var low = (this.unsigned ? wasm2["rem_u"] : wasm2["rem_s"])(
+              this.low,
+              this.high,
+              divisor.low,
+              divisor.high
+            );
+            return fromBits2(low, wasm2["get_high"](), this.unsigned);
+          }
+          return this.sub(this.div(divisor).mul(divisor));
+        };
+        LongPrototype2.mod = LongPrototype2.modulo;
+        LongPrototype2.rem = LongPrototype2.modulo;
+        LongPrototype2.not = function not3() {
+          return fromBits2(~this.low, ~this.high, this.unsigned);
+        };
+        LongPrototype2.countLeadingZeros = function countLeadingZeros2() {
+          return this.high ? Math.clz32(this.high) : Math.clz32(this.low) + 32;
+        };
+        LongPrototype2.clz = LongPrototype2.countLeadingZeros;
+        LongPrototype2.countTrailingZeros = function countTrailingZeros2() {
+          return this.low ? ctz322(this.low) : ctz322(this.high) + 32;
+        };
+        LongPrototype2.ctz = LongPrototype2.countTrailingZeros;
+        LongPrototype2.and = function and3(other) {
+          if (!isLong2(other)) other = fromValue2(other);
+          return fromBits2(
+            this.low & other.low,
+            this.high & other.high,
+            this.unsigned
+          );
+        };
+        LongPrototype2.or = function or3(other) {
+          if (!isLong2(other)) other = fromValue2(other);
+          return fromBits2(
+            this.low | other.low,
+            this.high | other.high,
+            this.unsigned
+          );
+        };
+        LongPrototype2.xor = function xor3(other) {
+          if (!isLong2(other)) other = fromValue2(other);
+          return fromBits2(
+            this.low ^ other.low,
+            this.high ^ other.high,
+            this.unsigned
+          );
+        };
+        LongPrototype2.shiftLeft = function shiftLeft2(numBits) {
+          if (isLong2(numBits)) numBits = numBits.toInt();
+          if ((numBits &= 63) === 0) return this;
+          else if (numBits < 32)
+            return fromBits2(
+              this.low << numBits,
+              this.high << numBits | this.low >>> 32 - numBits,
+              this.unsigned
+            );
+          else return fromBits2(0, this.low << numBits - 32, this.unsigned);
+        };
+        LongPrototype2.shl = LongPrototype2.shiftLeft;
+        LongPrototype2.shiftRight = function shiftRight2(numBits) {
+          if (isLong2(numBits)) numBits = numBits.toInt();
+          if ((numBits &= 63) === 0) return this;
+          else if (numBits < 32)
+            return fromBits2(
+              this.low >>> numBits | this.high << 32 - numBits,
+              this.high >> numBits,
+              this.unsigned
+            );
+          else
+            return fromBits2(
+              this.high >> numBits - 32,
+              this.high >= 0 ? 0 : -1,
+              this.unsigned
+            );
+        };
+        LongPrototype2.shr = LongPrototype2.shiftRight;
+        LongPrototype2.shiftRightUnsigned = function shiftRightUnsigned2(numBits) {
+          if (isLong2(numBits)) numBits = numBits.toInt();
+          if ((numBits &= 63) === 0) return this;
+          if (numBits < 32)
+            return fromBits2(
+              this.low >>> numBits | this.high << 32 - numBits,
+              this.high >>> numBits,
+              this.unsigned
+            );
+          if (numBits === 32) return fromBits2(this.high, 0, this.unsigned);
+          return fromBits2(this.high >>> numBits - 32, 0, this.unsigned);
+        };
+        LongPrototype2.shru = LongPrototype2.shiftRightUnsigned;
+        LongPrototype2.shr_u = LongPrototype2.shiftRightUnsigned;
+        LongPrototype2.rotateLeft = function rotateLeft2(numBits) {
+          var b;
+          if (isLong2(numBits)) numBits = numBits.toInt();
+          if ((numBits &= 63) === 0) return this;
+          if (numBits === 32) return fromBits2(this.high, this.low, this.unsigned);
+          if (numBits < 32) {
+            b = 32 - numBits;
+            return fromBits2(
+              this.low << numBits | this.high >>> b,
+              this.high << numBits | this.low >>> b,
+              this.unsigned
+            );
+          }
+          numBits -= 32;
+          b = 32 - numBits;
+          return fromBits2(
+            this.high << numBits | this.low >>> b,
+            this.low << numBits | this.high >>> b,
+            this.unsigned
+          );
+        };
+        LongPrototype2.rotl = LongPrototype2.rotateLeft;
+        LongPrototype2.rotateRight = function rotateRight2(numBits) {
+          var b;
+          if (isLong2(numBits)) numBits = numBits.toInt();
+          if ((numBits &= 63) === 0) return this;
+          if (numBits === 32) return fromBits2(this.high, this.low, this.unsigned);
+          if (numBits < 32) {
+            b = 32 - numBits;
+            return fromBits2(
+              this.high << b | this.low >>> numBits,
+              this.low << b | this.high >>> numBits,
+              this.unsigned
+            );
+          }
+          numBits -= 32;
+          b = 32 - numBits;
+          return fromBits2(
+            this.low << b | this.high >>> numBits,
+            this.high << b | this.low >>> numBits,
+            this.unsigned
+          );
+        };
+        LongPrototype2.rotr = LongPrototype2.rotateRight;
+        LongPrototype2.toSigned = function toSigned2() {
+          if (!this.unsigned) return this;
+          return fromBits2(this.low, this.high, false);
+        };
+        LongPrototype2.toUnsigned = function toUnsigned2() {
+          if (this.unsigned) return this;
+          return fromBits2(this.low, this.high, true);
+        };
+        LongPrototype2.toBytes = function toBytes2(le) {
+          return le ? this.toBytesLE() : this.toBytesBE();
+        };
+        LongPrototype2.toBytesLE = function toBytesLE2() {
+          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
+          ];
+        };
+        LongPrototype2.toBytesBE = function toBytesBE2() {
+          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
+          ];
+        };
+        Long2.fromBytes = function fromBytes2(bytes, unsigned, le) {
+          return le ? Long2.fromBytesLE(bytes, unsigned) : Long2.fromBytesBE(bytes, unsigned);
+        };
+        Long2.fromBytesLE = function fromBytesLE2(bytes, unsigned) {
+          return new Long2(
+            bytes[0] | bytes[1] << 8 | bytes[2] << 16 | bytes[3] << 24,
+            bytes[4] | bytes[5] << 8 | bytes[6] << 16 | bytes[7] << 24,
+            unsigned
+          );
+        };
+        Long2.fromBytesBE = function fromBytesBE2(bytes, unsigned) {
+          return new Long2(
+            bytes[4] << 24 | bytes[5] << 16 | bytes[6] << 8 | bytes[7],
+            bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3],
+            unsigned
+          );
+        };
+        if (typeof BigInt === "function") {
+          Long2.fromBigInt = function fromBigInt(value, unsigned) {
+            var lowBits = Number(BigInt.asIntN(32, value));
+            var highBits = Number(BigInt.asIntN(32, value >> BigInt(32)));
+            return fromBits2(lowBits, highBits, unsigned);
+          };
+          Long2.fromValue = function fromValueWithBigInt(value, unsigned) {
+            if (typeof value === "bigint") return Long2.fromBigInt(value, unsigned);
+            return fromValue2(value, unsigned);
+          };
+          LongPrototype2.toBigInt = function toBigInt() {
+            var lowBigInt = BigInt(this.low >>> 0);
+            var highBigInt = BigInt(this.unsigned ? this.high >>> 0 : this.high);
+            return highBigInt << BigInt(32) | lowBigInt;
+          };
+        }
+        var _default = _exports.default = Long2;
+      }
+    );
+  }
+});
+
+// web/node_modules/protobufjs/src/util/minimal.js
+var require_minimal = __commonJS({
+  "web/node_modules/protobufjs/src/util/minimal.js"(exports) {
+    "use strict";
+    var util = exports;
+    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();
+    function isUnsafeProperty(key) {
+      return key === "__proto__" || key === "prototype" || key === "constructor";
+    }
+    util.isUnsafeProperty = isUnsafeProperty;
+    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 || exports;
+    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 && Object.hasOwnProperty.call(obj, prop))
+        return typeof value !== "object" || (Array.isArray(value) ? value.length : Object.keys(value).length) > 0;
+      return false;
+    };
+    util.Buffer = (function() {
+      try {
+        var Buffer2 = util.global.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 || (function() {
+      try {
+        var Long2 = require_umd();
+        return Long2 && Long2.isLong ? Long2 : null;
+      } catch (e) {
+        return null;
+      }
+    })();
+    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) {
+      var ifNotSet = typeof arguments[arguments.length - 1] === "boolean", limit = ifNotSet ? arguments.length - 1 : arguments.length;
+      ifNotSet = ifNotSet && arguments[arguments.length - 1];
+      for (var a = 1; a < limit; ++a) {
+        var src = arguments[a];
+        if (!src)
+          continue;
+        for (var keys = Object.keys(src), i = 0; i < keys.length; ++i)
+          if (!isUnsafeProperty(keys[i]) && (dst[keys[i]] === void 0 || !ifNotSet))
+            dst[keys[i]] = src[keys[i]];
+      }
+      return dst;
+    }
+    util.merge = merge;
+    util.nestingLimit = 32;
+    util.recursionLimit = 100;
+    util.makeProp = function makeProp(obj, key) {
+      Object.defineProperty(obj, key, {
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    };
+    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"(exports, module) {
+    "use strict";
+    module.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) < 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) {
+      var lo = val.lo, hi = val.hi;
+      while (hi) {
+        buf[pos++] = lo & 127 | 128;
+        lo = (lo >>> 7 | hi << 25) >>> 0;
+        hi >>>= 7;
+      }
+      while (lo > 127) {
+        buf[pos++] = lo & 127 | 128;
+        lo = lo >>> 7;
+      }
+      buf[pos++] = 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"(exports, module) {
+    "use strict";
+    module.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"(exports, module) {
+    "use strict";
+    module.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 = /* @__PURE__ */ (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.recursionLimit = util.recursionLimit;
+    Reader.prototype.skipType = function(wireType, depth) {
+      if (depth === void 0) depth = 0;
+      if (depth > Reader.recursionLimit)
+        throw Error("maximum nesting depth exceeded");
+      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, depth + 1);
+          }
+          break;
+        case 5:
+          this.skip(4);
+          break;
+        /* istanbul ignore next */
+        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"(exports, module) {
+    "use strict";
+    module.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"(exports, module) {
+    "use strict";
+    module.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"(exports) {
+    "use strict";
+    var rpc = exports;
+    rpc.Service = require_service();
+  }
+});
+
+// web/node_modules/protobufjs/src/roots.js
+var require_roots = __commonJS({
+  "web/node_modules/protobufjs/src/roots.js"(exports, module) {
+    "use strict";
+    module.exports = /* @__PURE__ */ Object.create(null);
+  }
+});
+
+// web/node_modules/protobufjs/src/index-minimal.js
+var require_index_minimal = __commonJS({
+  "web/node_modules/protobufjs/src/index-minimal.js"(exports) {
+    "use strict";
+    var protobuf = exports;
+    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"(exports, module) {
+    "use strict";
+    module.exports = require_index_minimal();
+  }
+});
+
+// web/lib/onnxjs/ort-schema/protobuf/onnx.js
+var require_onnx = __commonJS({
+  "web/lib/onnxjs/ort-schema/protobuf/onnx.js"(exports, module) {
+    "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();
+          }
+          if (object.opsetImport) {
+            if (!Array.isArray(object.opsetImport)) throw TypeError(".onnx.ModelProto.opsetImport: array expected");
+            message.opsetImport = [];
+            for (var i = 0; i < object.opsetImport.length; ++i) {
+              if (typeof object.opsetImport[i] !== "object")
+                throw TypeError(".onnx.ModelProto.opsetImport: object expected");
+              message.opsetImport[i] = $root.onnx.OperatorSetIdProto.fromObject(object.opsetImport[i]);
+            }
+          }
+          if (object.producerName != null) message.producerName = String(object.producerName);
+          if (object.producerVersion != null) message.producerVersion = String(object.producerVersion);
+          if (object.domain != null) message.domain = String(object.domain);
+          if (object.modelVersion != null) {
+            if ($util.Long) (message.modelVersion = $util.Long.fromValue(object.modelVersion)).unsigned = false;
+            else if (typeof object.modelVersion === "string") message.modelVersion = parseInt(object.modelVersion, 10);
+            else if (typeof object.modelVersion === "number") message.modelVersion = object.modelVersion;
+            else if (typeof object.modelVersion === "object")
+              message.modelVersion = new $util.LongBits(
+                object.modelVersion.low >>> 0,
+                object.modelVersion.high >>> 0
+              ).toNumber();
+          }
+          if (object.docString != null) message.docString = String(object.docString);
+          if (object.graph != null) {
+            if (typeof object.graph !== "object") throw TypeError(".onnx.ModelProto.graph: object expected");
+            message.graph = $root.onnx.GraphProto.fromObject(object.graph);
+          }
+          if (object.metadataProps) {
+            if (!Array.isArray(object.metadataProps)) throw TypeError(".onnx.ModelProto.metadataProps: array expected");
+            message.metadataProps = [];
+            for (var i = 0; i < object.metadataProps.length; ++i) {
+              if (typeof object.metadataProps[i] !== "object")
+                throw TypeError(".onnx.ModelProto.metadataProps: object expected");
+              message.metadataProps[i] = $root.onnx.StringStringEntryProto.fromObject(object.metadataProps[i]);
+            }
+          }
+          if (object.trainingInfo) {
+            if (!Array.isArray(object.trainingInfo)) throw TypeError(".onnx.ModelProto.trainingInfo: array expected");
+            message.trainingInfo = [];
+            for (var i = 0; i < object.trainingInfo.length; ++i) {
+              if (typeof object.trainingInfo[i] !== "object")
+                throw TypeError(".onnx.ModelProto.trainingInfo: object expected");
+              message.trainingInfo[i] = $root.onnx.TrainingInfoProto.fromObject(object.trainingInfo[i]);
+            }
+          }
+          if (object.functions) {
+            if (!Array.isArray(object.functions)) throw TypeError(".onnx.ModelProto.functions: array expected");
+            message.functions = [];
+            for (var i = 0; i < object.functions.length; ++i) {
+              if (typeof object.functions[i] !== "object") throw TypeError(".onnx.ModelProto.functions: object expected");
+              message.functions[i] = $root.onnx.FunctionProto.fromObject(object.functions[i]);
+            }
+          }
+          return message;
+        };
+        ModelProto.toObject = function toObject(message, options) {
+          if (!options) options = {};
+          var object = {};
+          if (options.arrays || options.defaults) {
+            object.opsetImport = [];
+            object.metadataProps = [];
+            object.trainingInfo = [];
+            object.functions = [];
+          }
+          if (options.defaults) {
+            if ($util.Long) {
+              var long = new $util.Long(0, 0, false);
+              object.irVersion = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
+            } else object.irVersion = options.longs === String ? "0" : 0;
+            object.producerName = "";
+            object.producerVersion = "";
+            object.domain = "";
+            if ($util.Long) {
+              var long = new $util.Long(0, 0, false);
+              object.modelVersion = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
+            } else object.modelVersion = options.longs === String ? "0" : 0;
+            object.docString = "";
+            object.graph = null;
+          }
+          if (message.irVersion != null && message.hasOwnProperty("irVersion"))
+            if (typeof message.irVersion === "number")
+              object.irVersion = options.longs === String ? String(message.irVersion) : message.irVersion;
+            else
+              object.irVersion = options.longs === String ? $util.Long.prototype.toString.call(message.irVersion) : options.longs === Number ? new $util.LongBits(message.irVersion.low >>> 0, message.irVersion.high >>> 0).toNumber() : message.irVersion;
+          if (message.producerName != null && message.hasOwnProperty("producerName"))
+            object.producerName = message.producerName;
+          if (message.producerVersion != null && message.hasOwnProperty("producerVersion"))
+            object.producerVersion = message.producerVersion;
+          if (message.domain != null && message.hasOwnProperty("domain")) object.domain = message.domain;
+          if (message.modelVersion != null && message.hasOwnProperty("modelVersion"))
+            if (typeof message.modelVersion === "number")
+              object.modelVersion = options.longs === String ? String(message.modelVersion) : message.modelVersion;
+            else
+              object.modelVersion = options.longs === String ? $util.Long.prototype.toString.call(message.modelVersion) : options.longs === Number ? new $util.LongBits(message.modelVersion.low >>> 0, message.modelVersion.high >>> 0).toNumber() : message.modelVersion;
+          if (message.docString != null && message.hasOwnProperty("docString")) object.docString = message.docString;
+          if (message.graph != null && message.hasOwnProperty("graph"))
+            object.graph = $root.onnx.GraphProto.toObject(message.graph, options);
+          if (message.opsetImport && message.opsetImport.length) {
+            object.opsetImport = [];
+            for (var j = 0; j < message.opsetImport.length; ++j)
+              object.opsetImport[j] = $root.onnx.OperatorSetIdProto.toObject(message.opsetImport[j], options);
+          }
+          if (message.metadataProps && message.metadataProps.length) {
+            object.metadataProps = [];
+            for (var j = 0; j < message.metadataProps.length; ++j)
+              object.metadataProps[j] = $root.onnx.StringStringEntryProto.toObject(message.metadataProps[j], options);
+          }
+          if (message.trainingInfo && message.trainingInfo.length) {
+            object.trainingInfo = [];
+            for (var j = 0; j < message.trainingInfo.length; ++j)
+              object.trainingInfo[j] = $root.onnx.TrainingInfoProto.toObject(message.trainingInfo[j], options);
+          }
+          if (message.functions && message.functions.length) {
+            object.functions = [];
+            for (var j = 0; j < message.functions.length; ++j)
+              object.functions[j] = $root.onnx.FunctionProto.toObject(message.functions[j], options);
+          }
+          return object;
+        };
+        ModelProto.prototype.toJSON = function toJSON() {
+          return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+        };
+        ModelProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+          if (typeUrlPrefix === void 0) {
+            typeUrlPrefix = "type.googleapis.com";
+          }
+          return typeUrlPrefix + "/onnx.ModelProto";
+        };
+        return ModelProto;
+      })();
+      onnx6.StringStringEntryProto = (function() {
+        function StringStringEntryProto(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]];
+          }
+        }
+        StringStringEntryProto.prototype.key = "";
+        StringStringEntryProto.prototype.value = "";
+        StringStringEntryProto.create = function create(properties) {
+          return new StringStringEntryProto(properties);
+        };
+        StringStringEntryProto.encode = function encode(message, writer) {
+          if (!writer) writer = $Writer.create();
+          if (message.key != null && Object.hasOwnProperty.call(message, "key"))
+            writer.uint32(
+              /* id 1, wireType 2 =*/
+              10
+            ).string(message.key);
+          if (message.value != null && Object.hasOwnProperty.call(message, "value"))
+            writer.uint32(
+              /* id 2, wireType 2 =*/
+              18
+            ).string(message.value);
+          return writer;
+        };
+        StringStringEntryProto.encodeDelimited = function encodeDelimited(message, writer) {
+          return this.encode(message, writer).ldelim();
+        };
+        StringStringEntryProto.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.StringStringEntryProto();
+          while (reader.pos < end) {
+            var tag = reader.uint32();
+            switch (tag >>> 3) {
+              case 1: {
+                message.key = reader.string();
+                break;
+              }
+              case 2: {
+                message.value = reader.string();
+                break;
+              }
+              default:
+                reader.skipType(tag & 7);
+                break;
+            }
+          }
+          return message;
+        };
+        StringStringEntryProto.decodeDelimited = function decodeDelimited(reader) {
+          if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+          return this.decode(reader, reader.uint32());
+        };
+        StringStringEntryProto.verify = function verify(message) {
+          if (typeof message !== "object" || message === null) return "object expected";
+          if (message.key != null && message.hasOwnProperty("key")) {
+            if (!$util.isString(message.key)) return "key: string expected";
+          }
+          if (message.value != null && message.hasOwnProperty("value")) {
+            if (!$util.isString(message.value)) return "value: string expected";
+          }
+          return null;
+        };
+        StringStringEntryProto.fromObject = function fromObject(object) {
+          if (object instanceof $root.onnx.StringStringEntryProto) return object;
+          var message = new $root.onnx.StringStringEntryProto();
+          if (object.key != null) message.key = String(object.key);
+          if (object.value != null) message.value = String(object.value);
+          return message;
+        };
+        StringStringEntryProto.toObject = function toObject(message, options) {
+          if (!options) options = {};
+          var object = {};
+          if (options.defaults) {
+            object.key = "";
+            object.value = "";
+          }
+          if (message.key != null && message.hasOwnProperty("key")) object.key = message.key;
+          if (message.value != null && message.hasOwnProperty("value")) object.value = message.value;
+          return object;
+        };
+        StringStringEntryProto.prototype.toJSON = function toJSON() {
+          return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+        };
+        StringStringEntryProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+          if (typeUrlPrefix === void 0) {
+            typeUrlPrefix = "type.googleapis.com";
+          }
+          return typeUrlPrefix + "/onnx.StringStringEntryProto";
+        };
+        return StringStringEntryProto;
+      })();
+      onnx6.TensorAnnotation = (function() {
+        function TensorAnnotation(properties) {
+          this.quantParameterTensorNames = [];
+          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]];
+          }
+        }
+        TensorAnnotation.prototype.tensorName = "";
+        TensorAnnotation.prototype.quantParameterTensorNames = $util.emptyArray;
+        TensorAnnotation.create = function create(properties) {
+          return new TensorAnnotation(properties);
+        };
+        TensorAnnotation.encode = function encode(message, writer) {
+          if (!writer) writer = $Writer.create();
+          if (message.tensorName != null && Object.hasOwnProperty.call(message, "tensorName"))
+            writer.uint32(
+              /* id 1, wireType 2 =*/
+              10
+            ).string(message.tensorName);
+          if (message.quantParameterTensorNames != null && message.quantParameterTensorNames.length)
+            for (var i = 0; i < message.quantParameterTensorNames.length; ++i)
+              $root.onnx.StringStringEntryProto.encode(
+                message.quantParameterTensorNames[i],
+                writer.uint32(
+                  /* id 2, wireType 2 =*/
+                  18
+                ).fork()
+              ).ldelim();
+          return writer;
+        };
+        TensorAnnotation.encodeDelimited = function encodeDelimited(message, writer) {
+          return this.encode(message, writer).ldelim();
+        };
+        TensorAnnotation.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.TensorAnnotation();
+          while (reader.pos < end) {
+            var tag = reader.uint32();
+            switch (tag >>> 3) {
+              case 1: {
+                message.tensorName = reader.string();
+                break;
+              }
+              case 2: {
+                if (!(message.quantParameterTensorNames && message.quantParameterTensorNames.length))
+                  message.quantParameterTensorNames = [];
+                message.quantParameterTensorNames.push($root.onnx.StringStringEntryProto.decode(reader, reader.uint32()));
+                break;
+              }
+              default:
+                reader.skipType(tag & 7);
+                break;
+            }
+          }
+          return message;
+        };
+        TensorAnnotation.decodeDelimited = function decodeDelimited(reader) {
+          if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+          return this.decode(reader, reader.uint32());
+        };
+        TensorAnnotation.verify = function verify(message) {
+          if (typeof message !== "object" || message === null) return "object expected";
+          if (message.tensorName != null && message.hasOwnProperty("tensorName")) {
+            if (!$util.isString(message.tensorName)) return "tensorName: string expected";
+          }
+          if (message.quantParameterTensorNames != null && message.hasOwnProperty("quantParameterTensorNames")) {
+            if (!Array.isArray(message.quantParameterTensorNames)) return "quantParameterTensorNames: array expected";
+            for (var i = 0; i < message.quantParameterTensorNames.length; ++i) {
+              var error = $root.onnx.StringStringEntryProto.verify(message.quantParameterTensorNames[i]);
+              if (error) return "quantParameterTensorNames." + error;
+            }
+          }
+          return null;
+        };
+        TensorAnnotation.fromObject = function fromObject(object) {
+          if (object instanceof $root.onnx.TensorAnnotation) return object;
+          var message = new $root.onnx.TensorAnnotation();
+          if (object.tensorName != null) message.tensorName = String(object.tensorName);
+          if (object.quantParameterTensorNames) {
+            if (!Array.isArray(object.quantParameterTensorNames))
+              throw TypeError(".onnx.TensorAnnotation.quantParameterTensorNames: array expected");
+            message.quantParameterTensorNames = [];
+            for (var i = 0; i < object.quantParameterTensorNames.length; ++i) {
+              if (typeof object.quantParameterTensorNames[i] !== "object")
+                throw TypeError(".onnx.TensorAnnotation.quantParameterTensorNames: object expected");
+              message.quantParameterTensorNames[i] = $root.onnx.StringStringEntryProto.fromObject(
+                object.quantParameterTensorNames[i]
+              );
+            }
+          }
+          return message;
+        };
+        TensorAnnotation.toObject = function toObject(message, options) {
+          if (!options) options = {};
+          var object = {};
+          if (options.arrays || options.defaults) object.quantParameterTensorNames = [];
+          if (options.defaults) object.tensorName = "";
+          if (message.tensorName != null && message.hasOwnProperty("tensorName")) object.tensorName = message.tensorName;
+          if (message.quantParameterTensorNames && message.quantParameterTensorNames.length) {
+            object.quantParameterTensorNames = [];
+            for (var j = 0; j < message.quantParameterTensorNames.length; ++j)
+              object.quantParameterTensorNames[j] = $root.onnx.StringStringEntryProto.toObject(
+                message.quantParameterTensorNames[j],
+                options
+              );
+          }
+          return object;
+        };
+        TensorAnnotation.prototype.toJSON = function toJSON() {
+          return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+        };
+        TensorAnnotation.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+          if (typeUrlPrefix === void 0) {
+            typeUrlPrefix = "type.googleapis.com";
+          }
+          return typeUrlPrefix + "/onnx.TensorAnnotation";
+        };
+        return TensorAnnotation;
+      })();
+      onnx6.GraphProto = (function() {
+        function GraphProto(properties) {
+          this.node = [];
+          this.initializer = [];
+          this.sparseInitializer = [];
+          this.input = [];
+          this.output = [];
+          this.valueInfo = [];
+          this.quantizationAnnotation = [];
+          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]];
+          }
+        }
+        GraphProto.prototype.node = $util.emptyArray;
+        GraphProto.prototype.name = "";
+        GraphProto.prototype.initializer = $util.emptyArray;
+        GraphProto.prototype.sparseInitializer = $util.emptyArray;
+        GraphProto.prototype.docString = "";
+        GraphProto.prototype.input = $util.emptyArray;
+        GraphProto.prototype.output = $util.emptyArray;
+        GraphProto.prototype.valueInfo = $util.emptyArray;
+        GraphProto.prototype.quantizationAnnotation = $util.emptyArray;
+        GraphProto.create = function create(properties) {
+          return new GraphProto(properties);
+        };
+        GraphProto.encode = function encode(message, writer) {
+          if (!writer) writer = $Writer.create();
+          if (message.node != null && message.node.length)
+            for (var i = 0; i < message.node.length; ++i)
+              $root.onnx.NodeProto.encode(message.node[i], writer.uint32(
+                /* id 1, wireType 2 =*/
+                10
+              ).fork()).ldelim();
+          if (message.name != null && Object.hasOwnProperty.call(message, "name"))
+            writer.uint32(
+              /* id 2, wireType 2 =*/
+              18
+            ).string(message.name);
+          if (message.initializer != null && message.initializer.length)
+            for (var i = 0; i < message.initializer.length; ++i)
+              $root.onnx.TensorProto.encode(
+                message.initializer[i],
+                writer.uint32(
+                  /* id 5, wireType 2 =*/
+                  42
+                ).fork()
+              ).ldelim();
+          if (message.docString != null && Object.hasOwnProperty.call(message, "docString"))
+            writer.uint32(
+              /* id 10, wireType 2 =*/
+              82
+            ).string(message.docString);
+          if (message.input != null && message.input.length)
+            for (var i = 0; i < message.input.length; ++i)
+              $root.onnx.ValueInfoProto.encode(
+                message.input[i],
+                writer.uint32(
+                  /* id 11, wireType 2 =*/
+                  90
+                ).fork()
+              ).ldelim();
+          if (message.output != null && message.output.length)
+            for (var i = 0; i < message.output.length; ++i)
+              $root.onnx.ValueInfoProto.encode(
+                message.output[i],
+                writer.uint32(
+                  /* id 12, wireType 2 =*/
+                  98
+                ).fork()
+              ).ldelim();
+          if (message.valueInfo != null && message.valueInfo.length)
+            for (var i = 0; i < message.valueInfo.length; ++i)
+              $root.onnx.ValueInfoProto.encode(
+                message.valueInfo[i],
+                writer.uint32(
+                  /* id 13, wireType 2 =*/
+                  106
+                ).fork()
+              ).ldelim();
+          if (message.quantizationAnnotation != null && message.quantizationAnnotation.length)
+            for (var i = 0; i < message.quantizationAnnotation.length; ++i)
+              $root.onnx.TensorAnnotation.encode(
+                message.quantizationAnnotation[i],
+                writer.uint32(
+                  /* id 14, wireType 2 =*/
+                  114
+                ).fork()
+              ).ldelim();
+          if (message.sparseInitializer != null && message.sparseInitializer.length)
+            for (var i = 0; i < message.sparseInitializer.length; ++i)
+              $root.onnx.SparseTensorProto.encode(
+                message.sparseInitializer[i],
+                writer.uint32(
+                  /* id 15, wireType 2 =*/
+                  122
+                ).fork()
+              ).ldelim();
+          return writer;
+        };
+        GraphProto.encodeDelimited = function encodeDelimited(message, writer) {
+          return this.encode(message, writer).ldelim();
+        };
+        GraphProto.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.GraphProto();
+          while (reader.pos < end) {
+            var tag = reader.uint32();
+            switch (tag >>> 3) {
+              case 1: {
+                if (!(message.node && message.node.length)) message.node = [];
+                message.node.push($root.onnx.NodeProto.decode(reader, reader.uint32()));
+                break;
+              }
+              case 2: {
+                message.name = reader.string();
+                break;
+              }
+              case 5: {
+                if (!(message.initializer && message.initializer.length)) message.initializer = [];
+                message.initializer.push($root.onnx.TensorProto.decode(reader, reader.uint32()));
+                break;
+              }
+              case 15: {
+                if (!(message.sparseInitializer && message.sparseInitializer.length)) message.sparseInitializer = [];
+                message.sparseInitializer.push($root.onnx.SparseTensorProto.decode(reader, reader.uint32()));
+                break;
+              }
+              case 10: {
+                message.docString = reader.string();
+                break;
+              }
+              case 11: {
+                if (!(message.input && message.input.length)) message.input = [];
+                message.input.push($root.onnx.ValueInfoProto.decode(reader, reader.uint32()));
+                break;
+              }
+              case 12: {
+                if (!(message.output && message.output.length)) message.output = [];
+                message.output.push($root.onnx.ValueInfoProto.decode(reader, reader.uint32()));
+                break;
+              }
+              case 13: {
+                if (!(message.valueInfo && message.valueInfo.length)) message.valueInfo = [];
+                message.valueInfo.push($root.onnx.ValueInfoProto.decode(reader, reader.uint32()));
+                break;
+              }
+              case 14: {
+                if (!(message.quantizationAnnotation && message.quantizationAnnotation.length))
+                  message.quantizationAnnotation = [];
+                message.quantizationAnnotation.push($root.onnx.TensorAnnotation.decode(reader, reader.uint32()));
+                break;
+              }
+              default:
+                reader.skipType(tag & 7);
+                break;
+            }
+          }
+          return message;
+        };
+        GraphProto.decodeDelimited = function decodeDelimited(reader) {
+          if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+          return this.decode(reader, reader.uint32());
+        };
+        GraphProto.verify = function verify(message) {
+          if (typeof message !== "object" || message === null) return "object expected";
+          if (message.node != null && message.hasOwnProperty("node")) {
+            if (!Array.isArray(message.node)) return "node: array expected";
+            for (var i = 0; i < message.node.length; ++i) {
+              var error = $root.onnx.NodeProto.verify(message.node[i]);
+              if (error) return "node." + error;
+            }
+          }
+          if (message.name != null && message.hasOwnProperty("name")) {
+            if (!$util.isString(message.name)) return "name: string expected";
+          }
+          if (message.initializer != null && message.hasOwnProperty("initializer")) {
+            if (!Array.isArray(message.initializer)) return "initializer: array expected";
+            for (var i = 0; i < message.initializer.length; ++i) {
+              var error = $root.onnx.TensorProto.verify(message.initializer[i]);
+              if (error) return "initializer." + error;
+            }
+          }
+          if (message.sparseInitializer != null && message.hasOwnProperty("sparseInitializer")) {
+            if (!Array.isArray(message.sparseInitializer)) return "sparseInitializer: array expected";
+            for (var i = 0; i < message.sparseInitializer.length; ++i) {
+              var error = $root.onnx.SparseTensorProto.verify(message.sparseInitializer[i]);
+              if (error) return "sparseInitializer." + error;
+            }
+          }
+          if (message.docString != null && message.hasOwnProperty("docString")) {
+            if (!$util.isString(message.docString)) return "docString: string 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) {
+              var error = $root.onnx.ValueInfoProto.verify(message.input[i]);
+              if (error) return "input." + error;
+            }
+          }
+          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) {
+              var error = $root.onnx.ValueInfoProto.verify(message.output[i]);
+              if (error) return "output." + error;
+            }
+          }
+          if (message.valueInfo != null && message.hasOwnProperty("valueInfo")) {
+            if (!Array.isArray(message.valueInfo)) return "valueInfo: array expected";
+            for (var i = 0; i < message.valueInfo.length; ++i) {
+              var error = $root.onnx.ValueInfoProto.verify(message.valueInfo[i]);
+              if (error) return "valueInfo." + error;
+            }
+          }
+          if (message.quantizationAnnotation != null && message.hasOwnProperty("quantizationAnnotation")) {
+            if (!Array.isArray(message.quantizationAnnotation)) return "quantizationAnnotation: array expected";
+            for (var i = 0; i < message.quantizationAnnotation.length; ++i) {
+              var error = $root.onnx.TensorAnnotation.verify(message.quantizationAnnotation[i]);
+              if (error) return "quantizationAnnotation." + error;
+            }
+          }
+          return null;
+        };
+        GraphProto.fromObject = function fromObject(object) {
+          if (object instanceof $root.onnx.GraphProto) return object;
+          var message = new $root.onnx.GraphProto();
+          if (object.node) {
+            if (!Array.isArray(object.node)) throw TypeError(".onnx.GraphProto.node: array expected");
+            message.node = [];
+            for (var i = 0; i < object.node.length; ++i) {
+              if (typeof object.node[i] !== "object") throw TypeError(".onnx.GraphProto.node: object expected");
+              message.node[i] = $root.onnx.NodeProto.fromObject(object.node[i]);
+            }
+          }
+          if (object.name != null) message.name = String(object.name);
+          if (object.initializer) {
+            if (!Array.isArray(object.initializer)) throw TypeError(".onnx.GraphProto.initializer: array expected");
+            message.initializer = [];
+            for (var i = 0; i < object.initializer.length; ++i) {
+              if (typeof object.initializer[i] !== "object")
+                throw TypeError(".onnx.GraphProto.initializer: object expected");
+              message.initializer[i] = $root.onnx.TensorProto.fromObject(object.initializer[i]);
+            }
+          }
+          if (object.sparseInitializer) {
+            if (!Array.isArray(object.sparseInitializer))
+              throw TypeError(".onnx.GraphProto.sparseInitializer: array expected");
+            message.sparseInitializer = [];
+            for (var i = 0; i < object.sparseInitializer.length; ++i) {
+              if (typeof object.sparseInitializer[i] !== "object")
+                throw TypeError(".onnx.GraphProto.sparseInitializer: object expected");
+              message.sparseInitializer[i] = $root.onnx.SparseTensorProto.fromObject(object.sparseInitializer[i]);
+            }
+          }
+          if (object.docString != null) message.docString = String(object.docString);
+          if (object.input) {
+            if (!Array.isArray(object.input)) throw TypeError(".onnx.GraphProto.input: array expected");
+            message.input = [];
+            for (var i = 0; i < object.input.length; ++i) {
+              if (typeof object.input[i] !== "object") throw TypeError(".onnx.GraphProto.input: object expected");
+              message.input[i] = $root.onnx.ValueInfoProto.fromObject(object.input[i]);
+            }
+          }
+          if (object.output) {
+            if (!Array.isArray(object.output)) throw TypeError(".onnx.GraphProto.output: array expected");
+            message.output = [];
+            for (var i = 0; i < object.output.length; ++i) {
+              if (typeof object.output[i] !== "object") throw TypeError(".onnx.GraphProto.output: object expected");
+              message.output[i] = $root.onnx.ValueInfoProto.fromObject(object.output[i]);
+            }
+          }
+          if (object.valueInfo) {
+            if (!Array.isArray(object.valueInfo)) throw TypeError(".onnx.GraphProto.valueInfo: array expected");
+            message.valueInfo = [];
+            for (var i = 0; i < object.valueInfo.length; ++i) {
+              if (typeof object.valueInfo[i] !== "object") throw TypeError(".onnx.GraphProto.valueInfo: object expected");
+              message.valueInfo[i] = $root.onnx.ValueInfoProto.fromObject(object.valueInfo[i]);
+            }
+          }
+          if (object.quantizationAnnotation) {
+            if (!Array.isArray(object.quantizationAnnotation))
+              throw TypeError(".onnx.GraphProto.quantizationAnnotation: array expected");
+            message.quantizationAnnotation = [];
+            for (var i = 0; i < object.quantizationAnnotation.length; ++i) {
+              if (typeof object.quantizationAnnotation[i] !== "object")
+                throw TypeError(".onnx.GraphProto.quantizationAnnotation: object expected");
+              message.quantizationAnnotation[i] = $root.onnx.TensorAnnotation.fromObject(object.quantizationAnnotation[i]);
+            }
+          }
+          return message;
+        };
+        GraphProto.toObject = function toObject(message, options) {
+          if (!options) options = {};
+          var object = {};
+          if (options.arrays || options.defaults) {
+            object.node = [];
+            object.initializer = [];
+            object.input = [];
+            object.output = [];
+            object.valueInfo = [];
+            object.quantizationAnnotation = [];
+            object.sparseInitializer = [];
+          }
+          if (options.defaults) {
+            object.name = "";
+            object.docString = "";
+          }
+          if (message.node && message.node.length) {
+            object.node = [];
+            for (var j = 0; j < message.node.length; ++j)
+              object.node[j] = $root.onnx.NodeProto.toObject(message.node[j], options);
+          }
+          if (message.name != null && message.hasOwnProperty("name")) object.name = message.name;
+          if (message.initializer && message.initializer.length) {
+            object.initializer = [];
+            for (var j = 0; j < message.initializer.length; ++j)
+              object.initializer[j] = $root.onnx.TensorProto.toObject(message.initializer[j], options);
+          }
+          if (message.docString != null && message.hasOwnProperty("docString")) object.docString = message.docString;
+          if (message.input && message.input.length) {
+            object.input = [];
+            for (var j = 0; j < message.input.length; ++j)
+              object.input[j] = $root.onnx.ValueInfoProto.toObject(message.input[j], options);
+          }
+          if (message.output && message.output.length) {
+            object.output = [];
+            for (var j = 0; j < message.output.length; ++j)
+              object.output[j] = $root.onnx.ValueInfoProto.toObject(message.output[j], options);
+          }
+          if (message.valueInfo && message.valueInfo.length) {
+            object.valueInfo = [];
+            for (var j = 0; j < message.valueInfo.length; ++j)
+              object.valueInfo[j] = $root.onnx.ValueInfoProto.toObject(message.valueInfo[j], options);
+          }
+          if (message.quantizationAnnotation && message.quantizationAnnotation.length) {
+            object.quantizationAnnotation = [];
+            for (var j = 0; j < message.quantizationAnnotation.length; ++j)
+              object.quantizationAnnotation[j] = $root.onnx.TensorAnnotation.toObject(
+                message.quantizationAnnotation[j],
+                options
+              );
+          }
+          if (message.sparseInitializer && message.sparseInitializer.length) {
+            object.sparseInitializer = [];
+            for (var j = 0; j < message.sparseInitializer.length; ++j)
+              object.sparseInitializer[j] = $root.onnx.SparseTensorProto.toObject(message.sparseInitializer[j], options);
+          }
+          return object;
+        };
+        GraphProto.prototype.toJSON = function toJSON() {
+          return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+        };
+        GraphProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+          if (typeUrlPrefix === void 0) {
+            typeUrlPrefix = "type.googleapis.com";
+          }
+          return typeUrlPrefix + "/onnx.GraphProto";
+        };
+        return GraphProto;
+      })();
+      onnx6.TensorProto = (function() {
+        function TensorProto(properties) {
+          this.dims = [];
+          this.floatData = [];
+          this.int32Data = [];
+          this.stringData = [];
+          this.int64Data = [];
+          this.externalData = [];
+          this.doubleData = [];
+          this.uint64Data = [];
+          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]];
+          }
+        }
+        TensorProto.prototype.dims = $util.emptyArray;
+        TensorProto.prototype.dataType = 0;
+        TensorProto.prototype.segment = null;
+        TensorProto.prototype.floatData = $util.emptyArray;
+        TensorProto.prototype.int32Data = $util.emptyArray;
+        TensorProto.prototype.stringData = $util.emptyArray;
+        TensorProto.prototype.int64Data = $util.emptyArray;
+        TensorProto.prototype.name = "";
+        TensorProto.prototype.docString = "";
+        TensorProto.prototype.rawData = $util.newBuffer([]);
+        TensorProto.prototype.externalData = $util.emptyArray;
+        TensorProto.prototype.dataLocation = 0;
+        TensorProto.prototype.doubleData = $util.emptyArray;
+        TensorProto.prototype.uint64Data = $util.emptyArray;
+        TensorProto.create = function create(properties) {
+          return new TensorProto(properties);
+        };
+        TensorProto.encode = function encode(message, writer) {
+          if (!writer) writer = $Writer.create();
+          if (message.dims != null && message.dims.length) {
+            writer.uint32(
+              /* id 1, wireType 2 =*/
+              10
+            ).fork();
+            for (var i = 0; i < message.dims.length; ++i) writer.int64(message.dims[i]);
+            writer.ldelim();
+          }
+          if (message.dataType != null && Object.hasOwnProperty.call(message, "dataType"))
+            writer.uint32(
+              /* id 2, wireType 0 =*/
+              16
+            ).int32(message.dataType);
+          if (message.segment != null && Object.hasOwnProperty.call(message, "segment"))
+            $root.onnx.TensorProto.Segment.encode(
+              message.segment,
+              writer.uint32(
+                /* id 3, wireType 2 =*/
+                26
+              ).fork()
+            ).ldelim();
+          if (message.floatData != null && message.floatData.length) {
+            writer.uint32(
+              /* id 4, wireType 2 =*/
+              34
+            ).fork();
+            for (var i = 0; i < message.floatData.length; ++i) writer.float(message.floatData[i]);
+            writer.ldelim();
+          }
+          if (message.int32Data != null && message.int32Data.length) {
+            writer.uint32(
+              /* id 5, wireType 2 =*/
+              42
+            ).fork();
+            for (var i = 0; i < message.int32Data.length; ++i) writer.int32(message.int32Data[i]);
+            writer.ldelim();
+          }
+          if (message.stringData != null && message.stringData.length)
+            for (var i = 0; i < message.stringData.length; ++i)
+              writer.uint32(
+                /* id 6, wireType 2 =*/
+                50
+              ).bytes(message.stringData[i]);
+          if (message.int64Data != null && message.int64Data.length) {
+            writer.uint32(
+              /* id 7, wireType 2 =*/
+              58
+            ).fork();
+            for (var i = 0; i < message.int64Data.length; ++i) writer.int64(message.int64Data[i]);
+            writer.ldelim();
+          }
+          if (message.name != null && Object.hasOwnProperty.call(message, "name"))
+            writer.uint32(
+              /* id 8, wireType 2 =*/
+              66
+            ).string(message.name);
+          if (message.rawData != null && Object.hasOwnProperty.call(message, "rawData"))
+            writer.uint32(
+              /* id 9, wireType 2 =*/
+              74
+            ).bytes(message.rawData);
+          if (message.doubleData != null && message.doubleData.length) {
+            writer.uint32(
+              /* id 10, wireType 2 =*/
+              82
+            ).fork();
+            for (var i = 0; i < message.doubleData.length; ++i) writer.double(message.doubleData[i]);
+            writer.ldelim();
+          }
+          if (message.uint64Data != null && message.uint64Data.length) {
+            writer.uint32(
+              /* id 11, wireType 2 =*/
+              90
+            ).fork();
+            for (var i = 0; i < message.uint64Data.length; ++i) writer.uint64(message.uint64Data[i]);
+            writer.ldelim();
+          }
+          if (message.docString != null && Object.hasOwnProperty.call(message, "docString"))
+            writer.uint32(
+              /* id 12, wireType 2 =*/
+              98
+            ).string(message.docString);
+          if (message.externalData != null && message.externalData.length)
+            for (var i = 0; i < message.externalData.length; ++i)
+              $root.onnx.StringStringEntryProto.encode(
+                message.externalData[i],
+                writer.uint32(
+                  /* id 13, wireType 2 =*/
+                  106
+                ).fork()
+              ).ldelim();
+          if (message.dataLocation != null && Object.hasOwnProperty.call(message, "dataLocation"))
+            writer.uint32(
+              /* id 14, wireType 0 =*/
+              112
+            ).int32(message.dataLocation);
+          return writer;
+        };
+        TensorProto.encodeDelimited = function encodeDelimited(message, writer) {
+          return this.encode(message, writer).ldelim();
+        };
+        TensorProto.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.TensorProto();
+          while (reader.pos < end) {
+            var tag = reader.uint32();
+            switch (tag >>> 3) {
+              case 1: {
+                if (!(message.dims && message.dims.length)) message.dims = [];
+                if ((tag & 7) === 2) {
+                  var end2 = reader.uint32() + reader.pos;
+                  while (reader.pos < end2) message.dims.push(reader.int64());
+                } else message.dims.push(reader.int64());
+                break;
+              }
+              case 2: {
+                message.dataType = reader.int32();
+                break;
+              }
+              case 3: {
+                message.segment = $root.onnx.TensorProto.Segment.decode(reader, reader.uint32());
+                break;
+              }
+              case 4: {
+                if (!(message.floatData && message.floatData.length)) message.floatData = [];
+                if ((tag & 7) === 2) {
+                  var end2 = reader.uint32() + reader.pos;
+                  while (reader.pos < end2) message.floatData.push(reader.float());
+                } else message.floatData.push(reader.float());
+                break;
+              }
+              case 5: {
+                if (!(message.int32Data && message.int32Data.length)) message.int32Data = [];
+                if ((tag & 7) === 2) {
+                  var end2 = reader.uint32() + reader.pos;
+                  while (reader.pos < end2) message.int32Data.push(reader.int32());
+                } else message.int32Data.push(reader.int32());
+                break;
+              }
+              case 6: {
+                if (!(message.stringData && message.stringData.length)) message.stringData = [];
+                message.stringData.push(reader.bytes());
+                break;
+              }
+              case 7: {
+                if (!(message.int64Data && message.int64Data.length)) message.int64Data = [];
+                if ((tag & 7) === 2) {
+                  var end2 = reader.uint32() + reader.pos;
+                  while (reader.pos < end2) message.int64Data.push(reader.int64());
+                } else message.int64Data.push(reader.int64());
+                break;
+              }
+              case 8: {
+                message.name = reader.string();
+                break;
+              }
+              case 12: {
+                message.docString = reader.string();
+                break;
+              }
+              case 9: {
+                message.rawData = reader.bytes();
+                break;
+              }
+              case 13: {
+                if (!(message.externalData && message.externalData.length)) message.externalData = [];
+                message.externalData.push($root.onnx.StringStringEntryProto.decode(reader, reader.uint32()));
+                break;
+              }
+              case 14: {
+                message.dataLocation = reader.int32();
+                break;
+              }
+              case 10: {
+                if (!(message.doubleData && message.doubleData.length)) message.doubleData = [];
+                if ((tag & 7) === 2) {
+                  var end2 = reader.uint32() + reader.pos;
+                  while (reader.pos < end2) message.doubleData.push(reader.double());
+                } else message.doubleData.push(reader.double());
+                break;
+              }
+              case 11: {
+                if (!(message.uint64Data && message.uint64Data.length)) message.uint64Data = [];
+                if ((tag & 7) === 2) {
+                  var end2 = reader.uint32() + reader.pos;
+                  while (reader.pos < end2) message.uint64Data.push(reader.uint64());
+                } else message.uint64Data.push(reader.uint64());
+                break;
+              }
+              default:
+                reader.skipType(tag & 7);
+                break;
+            }
+          }
+          return message;
+        };
+        TensorProto.decodeDelimited = function decodeDelimited(reader) {
+          if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+          return this.decode(reader, reader.uint32());
+        };
+        TensorProto.verify = function verify(message) {
+          if (typeof message !== "object" || message === null) return "object expected";
+          if (message.dims != null && message.hasOwnProperty("dims")) {
+            if (!Array.isArray(message.dims)) return "dims: array expected";
+            for (var i = 0; i < message.dims.length; ++i)
+              if (!$util.isInteger(message.dims[i]) && !(message.dims[i] && $util.isInteger(message.dims[i].low) && $util.isInteger(message.dims[i].high)))
+                return "dims: integer|Long[] expected";
+          }
+          if (message.dataType != null && message.hasOwnProperty("dataType")) {
+            if (!$util.isInteger(message.dataType)) return "dataType: integer expected";
+          }
+          if (message.segment != null && message.hasOwnProperty("segment")) {
+            var error = $root.onnx.TensorProto.Segment.verify(message.segment);
+            if (error) return "segment." + error;
+          }
+          if (message.floatData != null && message.hasOwnProperty("floatData")) {
+            if (!Array.isArray(message.floatData)) return "floatData: array expected";
+            for (var i = 0; i < message.floatData.length; ++i)
+              if (typeof message.floatData[i] !== "number") return "floatData: number[] expected";
+          }
+          if (message.int32Data != null && message.hasOwnProperty("int32Data")) {
+            if (!Array.isArray(message.int32Data)) return "int32Data: array expected";
+            for (var i = 0; i < message.int32Data.length; ++i)
+              if (!$util.isInteger(message.int32Data[i])) return "int32Data: integer[] expected";
+          }
+          if (message.stringData != null && message.hasOwnProperty("stringData")) {
+            if (!Array.isArray(message.stringData)) return "stringData: array expected";
+            for (var i = 0; i < message.stringData.length; ++i)
+              if (!(message.stringData[i] && typeof message.stringData[i].length === "number" || $util.isString(message.stringData[i])))
+                return "stringData: buffer[] expected";
+          }
+          if (message.int64Data != null && message.hasOwnProperty("int64Data")) {
+            if (!Array.isArray(message.int64Data)) return "int64Data: array expected";
+            for (var i = 0; i < message.int64Data.length; ++i)
+              if (!$util.isInteger(message.int64Data[i]) && !(message.int64Data[i] && $util.isInteger(message.int64Data[i].low) && $util.isInteger(message.int64Data[i].high)))
+                return "int64Data: integer|Long[] expected";
+          }
+          if (message.name != null && message.hasOwnProperty("name")) {
+            if (!$util.isString(message.name)) return "name: string expected";
+          }
+          if (message.docString != null && message.hasOwnProperty("docString")) {
+            if (!$util.isString(message.docString)) return "docString: string expected";
+          }
+          if (message.rawData != null && message.hasOwnProperty("rawData")) {
+            if (!(message.rawData && typeof message.rawData.length === "number" || $util.isString(message.rawData)))
+              return "rawData: buffer expected";
+          }
+          if (message.externalData != null && message.hasOwnProperty("externalData")) {
+            if (!Array.isArray(message.externalData)) return "externalData: array expected";
+            for (var i = 0; i < message.externalData.length; ++i) {
+              var error = $root.onnx.StringStringEntryProto.verify(message.externalData[i]);
+              if (error) return "externalData." + error;
+            }
+          }
+          if (message.dataLocation != null && message.hasOwnProperty("dataLocation"))
+            switch (message.dataLocation) {
+              default:
+                return "dataLocation: enum value expected";
+              case 0:
+              case 1:
+                break;
+            }
+          if (message.doubleData != null && message.hasOwnProperty("doubleData")) {
+            if (!Array.isArray(message.doubleData)) return "doubleData: array expected";
+            for (var i = 0; i < message.doubleData.length; ++i)
+              if (typeof message.doubleData[i] !== "number") return "doubleData: number[] expected";
+          }
+          if (message.uint64Data != null && message.hasOwnProperty("uint64Data")) {
+            if (!Array.isArray(message.uint64Data)) return "uint64Data: array expected";
+            for (var i = 0; i < message.uint64Data.length; ++i)
+              if (!$util.isInteger(message.uint64Data[i]) && !(message.uint64Data[i] && $util.isInteger(message.uint64Data[i].low) && $util.isInteger(message.uint64Data[i].high)))
+                return "uint64Data: integer|Long[] expected";
+          }
+          return null;
+        };
+        TensorProto.fromObject = function fromObject(object) {
+          if (object instanceof $root.onnx.TensorProto) return object;
+          var message = new $root.onnx.TensorProto();
+          if (object.dims) {
+            if (!Array.isArray(object.dims)) throw TypeError(".onnx.TensorProto.dims: array expected");
+            message.dims = [];
+            for (var i = 0; i < object.dims.length; ++i)
+              if ($util.Long) (message.dims[i] = $util.Long.fromValue(object.dims[i])).unsigned = false;
+              else if (typeof object.dims[i] === "string") message.dims[i] = parseInt(object.dims[i], 10);
+              else if (typeof object.dims[i] === "number") message.dims[i] = object.dims[i];
+              else if (typeof object.dims[i] === "object")
+                message.dims[i] = new $util.LongBits(object.dims[i].low >>> 0, object.dims[i].high >>> 0).toNumber();
+          }
+          if (object.dataType != null) message.dataType = object.dataType | 0;
+          if (object.segment != null) {
+            if (typeof object.segment !== "object") throw TypeError(".onnx.TensorProto.segment: object expected");
+            message.segment = $root.onnx.TensorProto.Segment.fromObject(object.segment);
+          }
+          if (object.floatData) {
+            if (!Array.isArray(object.floatData)) throw TypeError(".onnx.TensorProto.floatData: array expected");
+            message.floatData = [];
+            for (var i = 0; i < object.floatData.length; ++i) message.floatData[i] = Number(object.floatData[i]);
+          }
+          if (object.int32Data) {
+            if (!Array.isArray(object.int32Data)) throw TypeError(".onnx.TensorProto.int32Data: array expected");
+            message.int32Data = [];
+            for (var i = 0; i < object.int32Data.length; ++i) message.int32Data[i] = object.int32Data[i] | 0;
+          }
+          if (object.stringData) {
+            if (!Array.isArray(object.stringData)) throw TypeError(".onnx.TensorProto.stringData: array expected");
+            message.stringData = [];
+            for (var i = 0; i < object.stringData.length; ++i)
+              if (typeof object.stringData[i] === "string")
+                $util.base64.decode(
+                  object.stringData[i],
+                  message.stringData[i] = $util.newBuffer($util.base64.length(object.stringData[i])),
+                  0
+                );
+              else if (object.stringData[i].length >= 0) message.stringData[i] = object.stringData[i];
+          }
+          if (object.int64Data) {
+            if (!Array.isArray(object.int64Data)) throw TypeError(".onnx.TensorProto.int64Data: array expected");
+            message.int64Data = [];
+            for (var i = 0; i < object.int64Data.length; ++i)
+              if ($util.Long) (message.int64Data[i] = $util.Long.fromValue(object.int64Data[i])).unsigned = false;
+              else if (typeof object.int64Data[i] === "string") message.int64Data[i] = parseInt(object.int64Data[i], 10);
+              else if (typeof object.int64Data[i] === "number") message.int64Data[i] = object.int64Data[i];
+              else if (typeof object.int64Data[i] === "object")
+                message.int64Data[i] = new $util.LongBits(
+                  object.int64Data[i].low >>> 0,
+                  object.int64Data[i].high >>> 0
+                ).toNumber();
+          }
+          if (object.name != null) message.name = String(object.name);
+          if (object.docString != null) message.docString = String(object.docString);
+          if (object.rawData != null) {
+            if (typeof object.rawData === "string")
+              $util.base64.decode(
+                object.rawData,
+                message.rawData = $util.newBuffer($util.base64.length(object.rawData)),
+                0
+              );
+            else if (object.rawData.length >= 0) message.rawData = object.rawData;
+          }
+          if (object.externalData) {
+            if (!Array.isArray(object.externalData)) throw TypeError(".onnx.TensorProto.externalData: array expected");
+            message.externalData = [];
+            for (var i = 0; i < object.externalData.length; ++i) {
+              if (typeof object.externalData[i] !== "object")
+                throw TypeError(".onnx.TensorProto.externalData: object expected");
+              message.externalData[i] = $root.onnx.StringStringEntryProto.fromObject(object.externalData[i]);
+            }
+          }
+          switch (object.dataLocation) {
+            default:
+              if (typeof object.dataLocation === "number") {
+                message.dataLocation = object.dataLocation;
+                break;
+              }
+              break;
+            case "DEFAULT":
+            case 0:
+              message.dataLocation = 0;
+              break;
+            case "EXTERNAL":
+            case 1:
+              message.dataLocation = 1;
+              break;
+          }
+          if (object.doubleData) {
+            if (!Array.isArray(object.doubleData)) throw TypeError(".onnx.TensorProto.doubleData: array expected");
+            message.doubleData = [];
+            for (var i = 0; i < object.doubleData.length; ++i) message.doubleData[i] = Number(object.doubleData[i]);
+          }
+          if (object.uint64Data) {
+            if (!Array.isArray(object.uint64Data)) throw TypeError(".onnx.TensorProto.uint64Data: array expected");
+            message.uint64Data = [];
+            for (var i = 0; i < object.uint64Data.length; ++i)
+              if ($util.Long) (message.uint64Data[i] = $util.Long.fromValue(object.uint64Data[i])).unsigned = true;
+              else if (typeof object.uint64Data[i] === "string") message.uint64Data[i] = parseInt(object.uint64Data[i], 10);
+              else if (typeof object.uint64Data[i] === "number") message.uint64Data[i] = object.uint64Data[i];
+              else if (typeof object.uint64Data[i] === "object")
+                message.uint64Data[i] = new $util.LongBits(
+                  object.uint64Data[i].low >>> 0,
+                  object.uint64Data[i].high >>> 0
+                ).toNumber(true);
+          }
+          return message;
+        };
+        TensorProto.toObject = function toObject(message, options) {
+          if (!options) options = {};
+          var object = {};
+          if (options.arrays || options.defaults) {
+            object.dims = [];
+            object.floatData = [];
+            object.int32Data = [];
+            object.stringData = [];
+            object.int64Data = [];
+            object.doubleData = [];
+            object.uint64Data = [];
+            object.externalData = [];
+          }
+          if (options.defaults) {
+            object.dataType = 0;
+            object.segment = null;
+            object.name = "";
+            if (options.bytes === String) object.rawData = "";
+            else {
+              object.rawData = [];
+              if (options.bytes !== Array) object.rawData = $util.newBuffer(object.rawData);
+            }
+            object.docString = "";
+            object.dataLocation = options.enums === String ? "DEFAULT" : 0;
+          }
+          if (message.dims && message.dims.length) {
+            object.dims = [];
+            for (var j = 0; j < message.dims.length; ++j)
+              if (typeof message.dims[j] === "number")
+                object.dims[j] = options.longs === String ? String(message.dims[j]) : message.dims[j];
+              else
+                object.dims[j] = options.longs === String ? $util.Long.prototype.toString.call(message.dims[j]) : options.longs === Number ? new $util.LongBits(message.dims[j].low >>> 0, message.dims[j].high >>> 0).toNumber() : message.dims[j];
+          }
+          if (message.dataType != null && message.hasOwnProperty("dataType")) object.dataType = message.dataType;
+          if (message.segment != null && message.hasOwnProperty("segment"))
+            object.segment = $root.onnx.TensorProto.Segment.toObject(message.segment, options);
+          if (message.floatData && message.floatData.length) {
+            object.floatData = [];
+            for (var j = 0; j < message.floatData.length; ++j)
+              object.floatData[j] = options.json && !isFinite(message.floatData[j]) ? String(message.floatData[j]) : message.floatData[j];
+          }
+          if (message.int32Data && message.int32Data.length) {
+            object.int32Data = [];
+            for (var j = 0; j < message.int32Data.length; ++j) object.int32Data[j] = message.int32Data[j];
+          }
+          if (message.stringData && message.stringData.length) {
+            object.stringData = [];
+            for (var j = 0; j < message.stringData.length; ++j)
+              object.stringData[j] = options.bytes === String ? $util.base64.encode(message.stringData[j], 0, message.stringData[j].length) : options.bytes === Array ? Array.prototype.slice.call(message.stringData[j]) : message.stringData[j];
+          }
+          if (message.int64Data && message.int64Data.length) {
+            object.int64Data = [];
+            for (var j = 0; j < message.int64Data.length; ++j)
+              if (typeof message.int64Data[j] === "number")
+                object.int64Data[j] = options.longs === String ? String(message.int64Data[j]) : message.int64Data[j];
+              else
+                object.int64Data[j] = options.longs === String ? $util.Long.prototype.toString.call(message.int64Data[j]) : options.longs === Number ? new $util.LongBits(message.int64Data[j].low >>> 0, message.int64Data[j].high >>> 0).toNumber() : message.int64Data[j];
+          }
+          if (message.name != null && message.hasOwnProperty("name")) object.name = message.name;
+          if (message.rawData != null && message.hasOwnProperty("rawData"))
+            object.rawData = options.bytes === String ? $util.base64.encode(message.rawData, 0, message.rawData.length) : options.bytes === Array ? Array.prototype.slice.call(message.rawData) : message.rawData;
+          if (message.doubleData && message.doubleData.length) {
+            object.doubleData = [];
+            for (var j = 0; j < message.doubleData.length; ++j)
+              object.doubleData[j] = options.json && !isFinite(message.doubleData[j]) ? String(message.doubleData[j]) : message.doubleData[j];
+          }
+          if (message.uint64Data && message.uint64Data.length) {
+            object.uint64Data = [];
+            for (var j = 0; j < message.uint64Data.length; ++j)
+              if (typeof message.uint64Data[j] === "number")
+                object.uint64Data[j] = options.longs === String ? String(message.uint64Data[j]) : message.uint64Data[j];
+              else
+                object.uint64Data[j] = options.longs === String ? $util.Long.prototype.toString.call(message.uint64Data[j]) : options.longs === Number ? new $util.LongBits(message.uint64Data[j].low >>> 0, message.uint64Data[j].high >>> 0).toNumber(true) : message.uint64Data[j];
+          }
+          if (message.docString != null && message.hasOwnProperty("docString")) object.docString = message.docString;
+          if (message.externalData && message.externalData.length) {
+            object.externalData = [];
+            for (var j = 0; j < message.externalData.length; ++j)
+              object.externalData[j] = $root.onnx.StringStringEntryProto.toObject(message.externalData[j], options);
+          }
+          if (message.dataLocation != null && message.hasOwnProperty("dataLocation"))
+            object.dataLocation = options.enums === String ? $root.onnx.TensorProto.DataLocation[message.dataLocation] === void 0 ? message.dataLocation : $root.onnx.TensorProto.DataLocation[message.dataLocation] : message.dataLocation;
+          return object;
+        };
+        TensorProto.prototype.toJSON = function toJSON() {
+          return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+        };
+        TensorProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+          if (typeUrlPrefix === void 0) {
+            typeUrlPrefix = "type.googleapis.com";
+          }
+          return typeUrlPrefix + "/onnx.TensorProto";
+        };
+        TensorProto.DataType = (function() {
+          var valuesById = {}, values = Object.create(valuesById);
+          values[valuesById[0] = "UNDEFINED"] = 0;
+          values[valuesById[1] = "FLOAT"] = 1;
+          values[valuesById[2] = "UINT8"] = 2;
+          values[valuesById[3] = "INT8"] = 3;
+          values[valuesById[4] = "UINT16"] = 4;
+          values[valuesById[5] = "INT16"] = 5;
+          values[valuesById[6] = "INT32"] = 6;
+          values[valuesById[7] = "INT64"] = 7;
+          values[valuesById[8] = "STRING"] = 8;
+          values[valuesById[9] = "BOOL"] = 9;
+          values[valuesById[10] = "FLOAT16"] = 10;
+          values[valuesById[11] = "DOUBLE"] = 11;
+          values[valuesById[12] = "UINT32"] = 12;
+          values[valuesById[13] = "UINT64"] = 13;
+          values[valuesById[14] = "COMPLEX64"] = 14;
+          values[valuesById[15] = "COMPLEX128"] = 15;
+          values[valuesById[16] = "BFLOAT16"] = 16;
+          values[valuesById[17] = "FLOAT8E4M3FN"] = 17;
+          values[valuesById[18] = "FLOAT8E4M3FNUZ"] = 18;
+          values[valuesById[19] = "FLOAT8E5M2"] = 19;
+          values[valuesById[20] = "FLOAT8E5M2FNUZ"] = 20;
+          return values;
+        })();
+        TensorProto.Segment = (function() {
+          function Segment(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]];
+            }
+          }
+          Segment.prototype.begin = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;
+          Segment.prototype.end = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;
+          Segment.create = function create(properties) {
+            return new Segment(properties);
+          };
+          Segment.encode = function encode(message, writer) {
+            if (!writer) writer = $Writer.create();
+            if (message.begin != null && Object.hasOwnProperty.call(message, "begin"))
+              writer.uint32(
+                /* id 1, wireType 0 =*/
+                8
+              ).int64(message.begin);
+            if (message.end != null && Object.hasOwnProperty.call(message, "end"))
+              writer.uint32(
+                /* id 2, wireType 0 =*/
+                16
+              ).int64(message.end);
+            return writer;
+          };
+          Segment.encodeDelimited = function encodeDelimited(message, writer) {
+            return this.encode(message, writer).ldelim();
+          };
+          Segment.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.TensorProto.Segment();
+            while (reader.pos < end) {
+              var tag = reader.uint32();
+              switch (tag >>> 3) {
+                case 1: {
+                  message.begin = reader.int64();
+                  break;
+                }
+                case 2: {
+                  message.end = reader.int64();
+                  break;
+                }
+                default:
+                  reader.skipType(tag & 7);
+                  break;
+              }
+            }
+            return message;
+          };
+          Segment.decodeDelimited = function decodeDelimited(reader) {
+            if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+            return this.decode(reader, reader.uint32());
+          };
+          Segment.verify = function verify(message) {
+            if (typeof message !== "object" || message === null) return "object expected";
+            if (message.begin != null && message.hasOwnProperty("begin")) {
+              if (!$util.isInteger(message.begin) && !(message.begin && $util.isInteger(message.begin.low) && $util.isInteger(message.begin.high)))
+                return "begin: integer|Long expected";
+            }
+            if (message.end != null && message.hasOwnProperty("end")) {
+              if (!$util.isInteger(message.end) && !(message.end && $util.isInteger(message.end.low) && $util.isInteger(message.end.high)))
+                return "end: integer|Long expected";
+            }
+            return null;
+          };
+          Segment.fromObject = function fromObject(object) {
+            if (object instanceof $root.onnx.TensorProto.Segment) return object;
+            var message = new $root.onnx.TensorProto.Segment();
+            if (object.begin != null) {
+              if ($util.Long) (message.begin = $util.Long.fromValue(object.begin)).unsigned = false;
+              else if (typeof object.begin === "string") message.begin = parseInt(object.begin, 10);
+              else if (typeof object.begin === "number") message.begin = object.begin;
+              else if (typeof object.begin === "object")
+                message.begin = new $util.LongBits(object.begin.low >>> 0, object.begin.high >>> 0).toNumber();
+            }
+            if (object.end != null) {
+              if ($util.Long) (message.end = $util.Long.fromValue(object.end)).unsigned = false;
+              else if (typeof object.end === "string") message.end = parseInt(object.end, 10);
+              else if (typeof object.end === "number") message.end = object.end;
+              else if (typeof object.end === "object")
+                message.end = new $util.LongBits(object.end.low >>> 0, object.end.high >>> 0).toNumber();
+            }
+            return message;
+          };
+          Segment.toObject = function toObject(message, options) {
+            if (!options) options = {};
+            var object = {};
+            if (options.defaults) {
+              if ($util.Long) {
+                var long = new $util.Long(0, 0, false);
+                object.begin = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
+              } else object.begin = options.longs === String ? "0" : 0;
+              if ($util.Long) {
+                var long = new $util.Long(0, 0, false);
+                object.end = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
+              } else object.end = options.longs === String ? "0" : 0;
+            }
+            if (message.begin != null && message.hasOwnProperty("begin"))
+              if (typeof message.begin === "number")
+                object.begin = options.longs === String ? String(message.begin) : message.begin;
+              else
+                object.begin = options.longs === String ? $util.Long.prototype.toString.call(message.begin) : options.longs === Number ? new $util.LongBits(message.begin.low >>> 0, message.begin.high >>> 0).toNumber() : message.begin;
+            if (message.end != null && message.hasOwnProperty("end"))
+              if (typeof message.end === "number")
+                object.end = options.longs === String ? String(message.end) : message.end;
+              else
+                object.end = options.longs === String ? $util.Long.prototype.toString.call(message.end) : options.longs === Number ? new $util.LongBits(message.end.low >>> 0, message.end.high >>> 0).toNumber() : message.end;
+            return object;
+          };
+          Segment.prototype.toJSON = function toJSON() {
+            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+          };
+          Segment.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+            if (typeUrlPrefix === void 0) {
+              typeUrlPrefix = "type.googleapis.com";
+            }
+            return typeUrlPrefix + "/onnx.TensorProto.Segment";
+          };
+          return Segment;
+        })();
+        TensorProto.DataLocation = (function() {
+          var valuesById = {}, values = Object.create(valuesById);
+          values[valuesById[0] = "DEFAULT"] = 0;
+          values[valuesById[1] = "EXTERNAL"] = 1;
+          return values;
+        })();
+        return TensorProto;
+      })();
+      onnx6.SparseTensorProto = (function() {
+        function SparseTensorProto(properties) {
+          this.dims = [];
+          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]];
+          }
+        }
+        SparseTensorProto.prototype.values = null;
+        SparseTensorProto.prototype.indices = null;
+        SparseTensorProto.prototype.dims = $util.emptyArray;
+        SparseTensorProto.create = function create(properties) {
+          return new SparseTensorProto(properties);
+        };
+        SparseTensorProto.encode = function encode(message, writer) {
+          if (!writer) writer = $Writer.create();
+          if (message.values != null && Object.hasOwnProperty.call(message, "values"))
+            $root.onnx.TensorProto.encode(message.values, writer.uint32(
+              /* id 1, wireType 2 =*/
+              10
+            ).fork()).ldelim();
+          if (message.indices != null && Object.hasOwnProperty.call(message, "indices"))
+            $root.onnx.TensorProto.encode(message.indices, writer.uint32(
+              /* id 2, wireType 2 =*/
+              18
+            ).fork()).ldelim();
+          if (message.dims != null && message.dims.length) {
+            writer.uint32(
+              /* id 3, wireType 2 =*/
+              26
+            ).fork();
+            for (var i = 0; i < message.dims.length; ++i) writer.int64(message.dims[i]);
+            writer.ldelim();
+          }
+          return writer;
+        };
+        SparseTensorProto.encodeDelimited = function encodeDelimited(message, writer) {
+          return this.encode(message, writer).ldelim();
+        };
+        SparseTensorProto.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.SparseTensorProto();
+          while (reader.pos < end) {
+            var tag = reader.uint32();
+            switch (tag >>> 3) {
+              case 1: {
+                message.values = $root.onnx.TensorProto.decode(reader, reader.uint32());
+                break;
+              }
+              case 2: {
+                message.indices = $root.onnx.TensorProto.decode(reader, reader.uint32());
+                break;
+              }
+              case 3: {
+                if (!(message.dims && message.dims.length)) message.dims = [];
+                if ((tag & 7) === 2) {
+                  var end2 = reader.uint32() + reader.pos;
+                  while (reader.pos < end2) message.dims.push(reader.int64());
+                } else message.dims.push(reader.int64());
+                break;
+              }
+              default:
+                reader.skipType(tag & 7);
+                break;
+            }
+          }
+          return message;
+        };
+        SparseTensorProto.decodeDelimited = function decodeDelimited(reader) {
+          if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+          return this.decode(reader, reader.uint32());
+        };
+        SparseTensorProto.verify = function verify(message) {
+          if (typeof message !== "object" || message === null) return "object expected";
+          if (message.values != null && message.hasOwnProperty("values")) {
+            var error = $root.onnx.TensorProto.verify(message.values);
+            if (error) return "values." + error;
+          }
+          if (message.indices != null && message.hasOwnProperty("indices")) {
+            var error = $root.onnx.TensorProto.verify(message.indices);
+            if (error) return "indices." + error;
+          }
+          if (message.dims != null && message.hasOwnProperty("dims")) {
+            if (!Array.isArray(message.dims)) return "dims: array expected";
+            for (var i = 0; i < message.dims.length; ++i)
+              if (!$util.isInteger(message.dims[i]) && !(message.dims[i] && $util.isInteger(message.dims[i].low) && $util.isInteger(message.dims[i].high)))
+                return "dims: integer|Long[] expected";
+          }
+          return null;
+        };
+        SparseTensorProto.fromObject = function fromObject(object) {
+          if (object instanceof $root.onnx.SparseTensorProto) return object;
+          var message = new $root.onnx.SparseTensorProto();
+          if (object.values != null) {
+            if (typeof object.values !== "object") throw TypeError(".onnx.SparseTensorProto.values: object expected");
+            message.values = $root.onnx.TensorProto.fromObject(object.values);
+          }
+          if (object.indices != null) {
+            if (typeof object.indices !== "object") throw TypeError(".onnx.SparseTensorProto.indices: object expected");
+            message.indices = $root.onnx.TensorProto.fromObject(object.indices);
+          }
+          if (object.dims) {
+            if (!Array.isArray(object.dims)) throw TypeError(".onnx.SparseTensorProto.dims: array expected");
+            message.dims = [];
+            for (var i = 0; i < object.dims.length; ++i)
+              if ($util.Long) (message.dims[i] = $util.Long.fromValue(object.dims[i])).unsigned = false;
+              else if (typeof object.dims[i] === "string") message.dims[i] = parseInt(object.dims[i], 10);
+              else if (typeof object.dims[i] === "number") message.dims[i] = object.dims[i];
+              else if (typeof object.dims[i] === "object")
+                message.dims[i] = new $util.LongBits(object.dims[i].low >>> 0, object.dims[i].high >>> 0).toNumber();
+          }
+          return message;
+        };
+        SparseTensorProto.toObject = function toObject(message, options) {
+          if (!options) options = {};
+          var object = {};
+          if (options.arrays || options.defaults) object.dims = [];
+          if (options.defaults) {
+            object.values = null;
+            object.indices = null;
+          }
+          if (message.values != null && message.hasOwnProperty("values"))
+            object.values = $root.onnx.TensorProto.toObject(message.values, options);
+          if (message.indices != null && message.hasOwnProperty("indices"))
+            object.indices = $root.onnx.TensorProto.toObject(message.indices, options);
+          if (message.dims && message.dims.length) {
+            object.dims = [];
+            for (var j = 0; j < message.dims.length; ++j)
+              if (typeof message.dims[j] === "number")
+                object.dims[j] = options.longs === String ? String(message.dims[j]) : message.dims[j];
+              else
+                object.dims[j] = options.longs === String ? $util.Long.prototype.toString.call(message.dims[j]) : options.longs === Number ? new $util.LongBits(message.dims[j].low >>> 0, message.dims[j].high >>> 0).toNumber() : message.dims[j];
+          }
+          return object;
+        };
+        SparseTensorProto.prototype.toJSON = function toJSON() {
+          return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+        };
+        SparseTensorProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+          if (typeUrlPrefix === void 0) {
+            typeUrlPrefix = "type.googleapis.com";
+          }
+          return typeUrlPrefix + "/onnx.SparseTensorProto";
+        };
+        return SparseTensorProto;
+      })();
+      onnx6.TensorShapeProto = (function() {
+        function TensorShapeProto(properties) {
+          this.dim = [];
+          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]];
+          }
+        }
+        TensorShapeProto.prototype.dim = $util.emptyArray;
+        TensorShapeProto.create = function create(properties) {
+          return new TensorShapeProto(properties);
+        };
+        TensorShapeProto.encode = function encode(message, writer) {
+          if (!writer) writer = $Writer.create();
+          if (message.dim != null && message.dim.length)
+            for (var i = 0; i < message.dim.length; ++i)
+              $root.onnx.TensorShapeProto.Dimension.encode(
+                message.dim[i],
+                writer.uint32(
+                  /* id 1, wireType 2 =*/
+                  10
+                ).fork()
+              ).ldelim();
+          return writer;
+        };
+        TensorShapeProto.encodeDelimited = function encodeDelimited(message, writer) {
+          return this.encode(message, writer).ldelim();
+        };
+        TensorShapeProto.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.TensorShapeProto();
+          while (reader.pos < end) {
+            var tag = reader.uint32();
+            switch (tag >>> 3) {
+              case 1: {
+                if (!(message.dim && message.dim.length)) message.dim = [];
+                message.dim.push($root.onnx.TensorShapeProto.Dimension.decode(reader, reader.uint32()));
+                break;
+              }
+              default:
+                reader.skipType(tag & 7);
+                break;
+            }
+          }
+          return message;
+        };
+        TensorShapeProto.decodeDelimited = function decodeDelimited(reader) {
+          if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+          return this.decode(reader, reader.uint32());
+        };
+        TensorShapeProto.verify = function verify(message) {
+          if (typeof message !== "object" || message === null) return "object expected";
+          if (message.dim != null && message.hasOwnProperty("dim")) {
+            if (!Array.isArray(message.dim)) return "dim: array expected";
+            for (var i = 0; i < message.dim.length; ++i) {
+              var error = $root.onnx.TensorShapeProto.Dimension.verify(message.dim[i]);
+              if (error) return "dim." + error;
+            }
+          }
+          return null;
+        };
+        TensorShapeProto.fromObject = function fromObject(object) {
+          if (object instanceof $root.onnx.TensorShapeProto) return object;
+          var message = new $root.onnx.TensorShapeProto();
+          if (object.dim) {
+            if (!Array.isArray(object.dim)) throw TypeError(".onnx.TensorShapeProto.dim: array expected");
+            message.dim = [];
+            for (var i = 0; i < object.dim.length; ++i) {
+              if (typeof object.dim[i] !== "object") throw TypeError(".onnx.TensorShapeProto.dim: object expected");
+              message.dim[i] = $root.onnx.TensorShapeProto.Dimension.fromObject(object.dim[i]);
+            }
+          }
+          return message;
+        };
+        TensorShapeProto.toObject = function toObject(message, options) {
+          if (!options) options = {};
+          var object = {};
+          if (options.arrays || options.defaults) object.dim = [];
+          if (message.dim && message.dim.length) {
+            object.dim = [];
+            for (var j = 0; j < message.dim.length; ++j)
+              object.dim[j] = $root.onnx.TensorShapeProto.Dimension.toObject(message.dim[j], options);
+          }
+          return object;
+        };
+        TensorShapeProto.prototype.toJSON = function toJSON() {
+          return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+        };
+        TensorShapeProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+          if (typeUrlPrefix === void 0) {
+            typeUrlPrefix = "type.googleapis.com";
+          }
+          return typeUrlPrefix + "/onnx.TensorShapeProto";
+        };
+        TensorShapeProto.Dimension = (function() {
+          function Dimension2(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]];
+            }
+          }
+          Dimension2.prototype.dimValue = null;
+          Dimension2.prototype.dimParam = null;
+          Dimension2.prototype.denotation = "";
+          var $oneOfFields;
+          Object.defineProperty(Dimension2.prototype, "value", {
+            get: $util.oneOfGetter($oneOfFields = ["dimValue", "dimParam"]),
+            set: $util.oneOfSetter($oneOfFields)
+          });
+          Dimension2.create = function create(properties) {
+            return new Dimension2(properties);
+          };
+          Dimension2.encode = function encode(message, writer) {
+            if (!writer) writer = $Writer.create();
+            if (message.dimValue != null && Object.hasOwnProperty.call(message, "dimValue"))
+              writer.uint32(
+                /* id 1, wireType 0 =*/
+                8
+              ).int64(message.dimValue);
+            if (message.dimParam != null && Object.hasOwnProperty.call(message, "dimParam"))
+              writer.uint32(
+                /* id 2, wireType 2 =*/
+                18
+              ).string(message.dimParam);
+            if (message.denotation != null && Object.hasOwnProperty.call(message, "denotation"))
+              writer.uint32(
+                /* id 3, wireType 2 =*/
+                26
+              ).string(message.denotation);
+            return writer;
+          };
+          Dimension2.encodeDelimited = function encodeDelimited(message, writer) {
+            return this.encode(message, writer).ldelim();
+          };
+          Dimension2.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.TensorShapeProto.Dimension();
+            while (reader.pos < end) {
+              var tag = reader.uint32();
+              switch (tag >>> 3) {
+                case 1: {
+                  message.dimValue = reader.int64();
+                  break;
+                }
+                case 2: {
+                  message.dimParam = reader.string();
+                  break;
+                }
+                case 3: {
+                  message.denotation = reader.string();
+                  break;
+                }
+                default:
+                  reader.skipType(tag & 7);
+                  break;
+              }
+            }
+            return message;
+          };
+          Dimension2.decodeDelimited = function decodeDelimited(reader) {
+            if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+            return this.decode(reader, reader.uint32());
+          };
+          Dimension2.verify = function verify(message) {
+            if (typeof message !== "object" || message === null) return "object expected";
+            var properties = {};
+            if (message.dimValue != null && message.hasOwnProperty("dimValue")) {
+              properties.value = 1;
+              if (!$util.isInteger(message.dimValue) && !(message.dimValue && $util.isInteger(message.dimValue.low) && $util.isInteger(message.dimValue.high)))
+                return "dimValue: integer|Long expected";
+            }
+            if (message.dimParam != null && message.hasOwnProperty("dimParam")) {
+              if (properties.value === 1) return "value: multiple values";
+              properties.value = 1;
+              if (!$util.isString(message.dimParam)) return "dimParam: string expected";
+            }
+            if (message.denotation != null && message.hasOwnProperty("denotation")) {
+              if (!$util.isString(message.denotation)) return "denotation: string expected";
+            }
+            return null;
+          };
+          Dimension2.fromObject = function fromObject(object) {
+            if (object instanceof $root.onnx.TensorShapeProto.Dimension) return object;
+            var message = new $root.onnx.TensorShapeProto.Dimension();
+            if (object.dimValue != null) {
+              if ($util.Long) (message.dimValue = $util.Long.fromValue(object.dimValue)).unsigned = false;
+              else if (typeof object.dimValue === "string") message.dimValue = parseInt(object.dimValue, 10);
+              else if (typeof object.dimValue === "number") message.dimValue = object.dimValue;
+              else if (typeof object.dimValue === "object")
+                message.dimValue = new $util.LongBits(object.dimValue.low >>> 0, object.dimValue.high >>> 0).toNumber();
+            }
+            if (object.dimParam != null) message.dimParam = String(object.dimParam);
+            if (object.denotation != null) message.denotation = String(object.denotation);
+            return message;
+          };
+          Dimension2.toObject = function toObject(message, options) {
+            if (!options) options = {};
+            var object = {};
+            if (options.defaults) object.denotation = "";
+            if (message.dimValue != null && message.hasOwnProperty("dimValue")) {
+              if (typeof message.dimValue === "number")
+                object.dimValue = options.longs === String ? String(message.dimValue) : message.dimValue;
+              else
+                object.dimValue = options.longs === String ? $util.Long.prototype.toString.call(message.dimValue) : options.longs === Number ? new $util.LongBits(message.dimValue.low >>> 0, message.dimValue.high >>> 0).toNumber() : message.dimValue;
+              if (options.oneofs) object.value = "dimValue";
+            }
+            if (message.dimParam != null && message.hasOwnProperty("dimParam")) {
+              object.dimParam = message.dimParam;
+              if (options.oneofs) object.value = "dimParam";
+            }
+            if (message.denotation != null && message.hasOwnProperty("denotation")) object.denotation = message.denotation;
+            return object;
+          };
+          Dimension2.prototype.toJSON = function toJSON() {
+            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+          };
+          Dimension2.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+            if (typeUrlPrefix === void 0) {
+              typeUrlPrefix = "type.googleapis.com";
+            }
+            return typeUrlPrefix + "/onnx.TensorShapeProto.Dimension";
+          };
+          return Dimension2;
+        })();
+        return TensorShapeProto;
+      })();
+      onnx6.TypeProto = (function() {
+        function TypeProto(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]];
+          }
+        }
+        TypeProto.prototype.tensorType = null;
+        TypeProto.prototype.sequenceType = null;
+        TypeProto.prototype.mapType = null;
+        TypeProto.prototype.optionalType = null;
+        TypeProto.prototype.sparseTensorType = null;
+        TypeProto.prototype.denotation = "";
+        var $oneOfFields;
+        Object.defineProperty(TypeProto.prototype, "value", {
+          get: $util.oneOfGetter(
+            $oneOfFields = ["tensorType", "sequenceType", "mapType", "optionalType", "sparseTensorType"]
+          ),
+          set: $util.oneOfSetter($oneOfFields)
+        });
+        TypeProto.create = function create(properties) {
+          return new TypeProto(properties);
+        };
+        TypeProto.encode = function encode(message, writer) {
+          if (!writer) writer = $Writer.create();
+          if (message.tensorType != null && Object.hasOwnProperty.call(message, "tensorType"))
+            $root.onnx.TypeProto.Tensor.encode(
+              message.tensorType,
+              writer.uint32(
+                /* id 1, wireType 2 =*/
+                10
+              ).fork()
+            ).ldelim();
+          if (message.sequenceType != null && Object.hasOwnProperty.call(message, "sequenceType"))
+            $root.onnx.TypeProto.Sequence.encode(
+              message.sequenceType,
+              writer.uint32(
+                /* id 4, wireType 2 =*/
+                34
+              ).fork()
+            ).ldelim();
+          if (message.mapType != null && Object.hasOwnProperty.call(message, "mapType"))
+            $root.onnx.TypeProto.Map.encode(message.mapType, writer.uint32(
+              /* id 5, wireType 2 =*/
+              42
+            ).fork()).ldelim();
+          if (message.denotation != null && Object.hasOwnProperty.call(message, "denotation"))
+            writer.uint32(
+              /* id 6, wireType 2 =*/
+              50
+            ).string(message.denotation);
+          if (message.sparseTensorType != null && Object.hasOwnProperty.call(message, "sparseTensorType"))
+            $root.onnx.TypeProto.SparseTensor.encode(
+              message.sparseTensorType,
+              writer.uint32(
+                /* id 8, wireType 2 =*/
+                66
+              ).fork()
+            ).ldelim();
+          if (message.optionalType != null && Object.hasOwnProperty.call(message, "optionalType"))
+            $root.onnx.TypeProto.Optional.encode(
+              message.optionalType,
+              writer.uint32(
+                /* id 9, wireType 2 =*/
+                74
+              ).fork()
+            ).ldelim();
+          return writer;
+        };
+        TypeProto.encodeDelimited = function encodeDelimited(message, writer) {
+          return this.encode(message, writer).ldelim();
+        };
+        TypeProto.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.TypeProto();
+          while (reader.pos < end) {
+            var tag = reader.uint32();
+            switch (tag >>> 3) {
+              case 1: {
+                message.tensorType = $root.onnx.TypeProto.Tensor.decode(reader, reader.uint32());
+                break;
+              }
+              case 4: {
+                message.sequenceType = $root.onnx.TypeProto.Sequence.decode(reader, reader.uint32());
+                break;
+              }
+              case 5: {
+                message.mapType = $root.onnx.TypeProto.Map.decode(reader, reader.uint32());
+                break;
+              }
+              case 9: {
+                message.optionalType = $root.onnx.TypeProto.Optional.decode(reader, reader.uint32());
+                break;
+              }
+              case 8: {
+                message.sparseTensorType = $root.onnx.TypeProto.SparseTensor.decode(reader, reader.uint32());
+                break;
+              }
+              case 6: {
+                message.denotation = reader.string();
+                break;
+              }
+              default:
+                reader.skipType(tag & 7);
+                break;
+            }
+          }
+          return message;
+        };
+        TypeProto.decodeDelimited = function decodeDelimited(reader) {
+          if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+          return this.decode(reader, reader.uint32());
+        };
+        TypeProto.verify = function verify(message) {
+          if (typeof message !== "object" || message === null) return "object expected";
+          var properties = {};
+          if (message.tensorType != null && message.hasOwnProperty("tensorType")) {
+            properties.value = 1;
+            {
+              var error = $root.onnx.TypeProto.Tensor.verify(message.tensorType);
+              if (error) return "tensorType." + error;
+            }
+          }
+          if (message.sequenceType != null && message.hasOwnProperty("sequenceType")) {
+            if (properties.value === 1) return "value: multiple values";
+            properties.value = 1;
+            {
+              var error = $root.onnx.TypeProto.Sequence.verify(message.sequenceType);
+              if (error) return "sequenceType." + error;
+            }
+          }
+          if (message.mapType != null && message.hasOwnProperty("mapType")) {
+            if (properties.value === 1) return "value: multiple values";
+            properties.value = 1;
+            {
+              var error = $root.onnx.TypeProto.Map.verify(message.mapType);
+              if (error) return "mapType." + error;
+            }
+          }
+          if (message.optionalType != null && message.hasOwnProperty("optionalType")) {
+            if (properties.value === 1) return "value: multiple values";
+            properties.value = 1;
+            {
+              var error = $root.onnx.TypeProto.Optional.verify(message.optionalType);
+              if (error) return "optionalType." + error;
+            }
+          }
+          if (message.sparseTensorType != null && message.hasOwnProperty("sparseTensorType")) {
+            if (properties.value === 1) return "value: multiple values";
+            properties.value = 1;
+            {
+              var error = $root.onnx.TypeProto.SparseTensor.verify(message.sparseTensorType);
+              if (error) return "sparseTensorType." + error;
+            }
+          }
+          if (message.denotation != null && message.hasOwnProperty("denotation")) {
+            if (!$util.isString(message.denotation)) return "denotation: string expected";
+          }
+          return null;
+        };
+        TypeProto.fromObject = function fromObject(object) {
+          if (object instanceof $root.onnx.TypeProto) return object;
+          var message = new $root.onnx.TypeProto();
+          if (object.tensorType != null) {
+            if (typeof object.tensorType !== "object") throw TypeError(".onnx.TypeProto.tensorType: object expected");
+            message.tensorType = $root.onnx.TypeProto.Tensor.fromObject(object.tensorType);
+          }
+          if (object.sequenceType != null) {
+            if (typeof object.sequenceType !== "object") throw TypeError(".onnx.TypeProto.sequenceType: object expected");
+            message.sequenceType = $root.onnx.TypeProto.Sequence.fromObject(object.sequenceType);
+          }
+          if (object.mapType != null) {
+            if (typeof object.mapType !== "object") throw TypeError(".onnx.TypeProto.mapType: object expected");
+            message.mapType = $root.onnx.TypeProto.Map.fromObject(object.mapType);
+          }
+          if (object.optionalType != null) {
+            if (typeof object.optionalType !== "object") throw TypeError(".onnx.TypeProto.optionalType: object expected");
+            message.optionalType = $root.onnx.TypeProto.Optional.fromObject(object.optionalType);
+          }
+          if (object.sparseTensorType != null) {
+            if (typeof object.sparseTensorType !== "object")
+              throw TypeError(".onnx.TypeProto.sparseTensorType: object expected");
+            message.sparseTensorType = $root.onnx.TypeProto.SparseTensor.fromObject(object.sparseTensorType);
+          }
+          if (object.denotation != null) message.denotation = String(object.denotation);
+          return message;
+        };
+        TypeProto.toObject = function toObject(message, options) {
+          if (!options) options = {};
+          var object = {};
+          if (options.defaults) object.denotation = "";
+          if (message.tensorType != null && message.hasOwnProperty("tensorType")) {
+            object.tensorType = $root.onnx.TypeProto.Tensor.toObject(message.tensorType, options);
+            if (options.oneofs) object.value = "tensorType";
+          }
+          if (message.sequenceType != null && message.hasOwnProperty("sequenceType")) {
+            object.sequenceType = $root.onnx.TypeProto.Sequence.toObject(message.sequenceType, options);
+            if (options.oneofs) object.value = "sequenceType";
+          }
+          if (message.mapType != null && message.hasOwnProperty("mapType")) {
+            object.mapType = $root.onnx.TypeProto.Map.toObject(message.mapType, options);
+            if (options.oneofs) object.value = "mapType";
+          }
+          if (message.denotation != null && message.hasOwnProperty("denotation")) object.denotation = message.denotation;
+          if (message.sparseTensorType != null && message.hasOwnProperty("sparseTensorType")) {
+            object.sparseTensorType = $root.onnx.TypeProto.SparseTensor.toObject(message.sparseTensorType, options);
+            if (options.oneofs) object.value = "sparseTensorType";
+          }
+          if (message.optionalType != null && message.hasOwnProperty("optionalType")) {
+            object.optionalType = $root.onnx.TypeProto.Optional.toObject(message.optionalType, options);
+            if (options.oneofs) object.value = "optionalType";
+          }
+          return object;
+        };
+        TypeProto.prototype.toJSON = function toJSON() {
+          return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+        };
+        TypeProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+          if (typeUrlPrefix === void 0) {
+            typeUrlPrefix = "type.googleapis.com";
+          }
+          return typeUrlPrefix + "/onnx.TypeProto";
+        };
+        TypeProto.Tensor = (function() {
+          function Tensor5(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]];
+            }
+          }
+          Tensor5.prototype.elemType = 0;
+          Tensor5.prototype.shape = null;
+          Tensor5.create = function create(properties) {
+            return new Tensor5(properties);
+          };
+          Tensor5.encode = function encode(message, writer) {
+            if (!writer) writer = $Writer.create();
+            if (message.elemType != null && Object.hasOwnProperty.call(message, "elemType"))
+              writer.uint32(
+                /* id 1, wireType 0 =*/
+                8
+              ).int32(message.elemType);
+            if (message.shape != null && Object.hasOwnProperty.call(message, "shape"))
+              $root.onnx.TensorShapeProto.encode(message.shape, writer.uint32(
+                /* id 2, wireType 2 =*/
+                18
+              ).fork()).ldelim();
+            return writer;
+          };
+          Tensor5.encodeDelimited = function encodeDelimited(message, writer) {
+            return this.encode(message, writer).ldelim();
+          };
+          Tensor5.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.TypeProto.Tensor();
+            while (reader.pos < end) {
+              var tag = reader.uint32();
+              switch (tag >>> 3) {
+                case 1: {
+                  message.elemType = reader.int32();
+                  break;
+                }
+                case 2: {
+                  message.shape = $root.onnx.TensorShapeProto.decode(reader, reader.uint32());
+                  break;
+                }
+                default:
+                  reader.skipType(tag & 7);
+                  break;
+              }
+            }
+            return message;
+          };
+          Tensor5.decodeDelimited = function decodeDelimited(reader) {
+            if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+            return this.decode(reader, reader.uint32());
+          };
+          Tensor5.verify = function verify(message) {
+            if (typeof message !== "object" || message === null) return "object expected";
+            if (message.elemType != null && message.hasOwnProperty("elemType")) {
+              if (!$util.isInteger(message.elemType)) return "elemType: integer expected";
+            }
+            if (message.shape != null && message.hasOwnProperty("shape")) {
+              var error = $root.onnx.TensorShapeProto.verify(message.shape);
+              if (error) return "shape." + error;
+            }
+            return null;
+          };
+          Tensor5.fromObject = function fromObject(object) {
+            if (object instanceof $root.onnx.TypeProto.Tensor) return object;
+            var message = new $root.onnx.TypeProto.Tensor();
+            if (object.elemType != null) message.elemType = object.elemType | 0;
+            if (object.shape != null) {
+              if (typeof object.shape !== "object") throw TypeError(".onnx.TypeProto.Tensor.shape: object expected");
+              message.shape = $root.onnx.TensorShapeProto.fromObject(object.shape);
+            }
+            return message;
+          };
+          Tensor5.toObject = function toObject(message, options) {
+            if (!options) options = {};
+            var object = {};
+            if (options.defaults) {
+              object.elemType = 0;
+              object.shape = null;
+            }
+            if (message.elemType != null && message.hasOwnProperty("elemType")) object.elemType = message.elemType;
+            if (message.shape != null && message.hasOwnProperty("shape"))
+              object.shape = $root.onnx.TensorShapeProto.toObject(message.shape, options);
+            return object;
+          };
+          Tensor5.prototype.toJSON = function toJSON() {
+            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+          };
+          Tensor5.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+            if (typeUrlPrefix === void 0) {
+              typeUrlPrefix = "type.googleapis.com";
+            }
+            return typeUrlPrefix + "/onnx.TypeProto.Tensor";
+          };
+          return Tensor5;
+        })();
+        TypeProto.Sequence = (function() {
+          function Sequence(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]];
+            }
+          }
+          Sequence.prototype.elemType = null;
+          Sequence.create = function create(properties) {
+            return new Sequence(properties);
+          };
+          Sequence.encode = function encode(message, writer) {
+            if (!writer) writer = $Writer.create();
+            if (message.elemType != null && Object.hasOwnProperty.call(message, "elemType"))
+              $root.onnx.TypeProto.encode(message.elemType, writer.uint32(
+                /* id 1, wireType 2 =*/
+                10
+              ).fork()).ldelim();
+            return writer;
+          };
+          Sequence.encodeDelimited = function encodeDelimited(message, writer) {
+            return this.encode(message, writer).ldelim();
+          };
+          Sequence.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.TypeProto.Sequence();
+            while (reader.pos < end) {
+              var tag = reader.uint32();
+              switch (tag >>> 3) {
+                case 1: {
+                  message.elemType = $root.onnx.TypeProto.decode(reader, reader.uint32());
+                  break;
+                }
+                default:
+                  reader.skipType(tag & 7);
+                  break;
+              }
+            }
+            return message;
+          };
+          Sequence.decodeDelimited = function decodeDelimited(reader) {
+            if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+            return this.decode(reader, reader.uint32());
+          };
+          Sequence.verify = function verify(message) {
+            if (typeof message !== "object" || message === null) return "object expected";
+            if (message.elemType != null && message.hasOwnProperty("elemType")) {
+              var error = $root.onnx.TypeProto.verify(message.elemType);
+              if (error) return "elemType." + error;
+            }
+            return null;
+          };
+          Sequence.fromObject = function fromObject(object) {
+            if (object instanceof $root.onnx.TypeProto.Sequence) return object;
+            var message = new $root.onnx.TypeProto.Sequence();
+            if (object.elemType != null) {
+              if (typeof object.elemType !== "object")
+                throw TypeError(".onnx.TypeProto.Sequence.elemType: object expected");
+              message.elemType = $root.onnx.TypeProto.fromObject(object.elemType);
+            }
+            return message;
+          };
+          Sequence.toObject = function toObject(message, options) {
+            if (!options) options = {};
+            var object = {};
+            if (options.defaults) object.elemType = null;
+            if (message.elemType != null && message.hasOwnProperty("elemType"))
+              object.elemType = $root.onnx.TypeProto.toObject(message.elemType, options);
+            return object;
+          };
+          Sequence.prototype.toJSON = function toJSON() {
+            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+          };
+          Sequence.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+            if (typeUrlPrefix === void 0) {
+              typeUrlPrefix = "type.googleapis.com";
+            }
+            return typeUrlPrefix + "/onnx.TypeProto.Sequence";
+          };
+          return Sequence;
+        })();
+        TypeProto.Map = (function() {
+          function Map2(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]];
+            }
+          }
+          Map2.prototype.keyType = 0;
+          Map2.prototype.valueType = null;
+          Map2.create = function create(properties) {
+            return new Map2(properties);
+          };
+          Map2.encode = function encode(message, writer) {
+            if (!writer) writer = $Writer.create();
+            if (message.keyType != null && Object.hasOwnProperty.call(message, "keyType"))
+              writer.uint32(
+                /* id 1, wireType 0 =*/
+                8
+              ).int32(message.keyType);
+            if (message.valueType != null && Object.hasOwnProperty.call(message, "valueType"))
+              $root.onnx.TypeProto.encode(message.valueType, writer.uint32(
+                /* id 2, wireType 2 =*/
+                18
+              ).fork()).ldelim();
+            return writer;
+          };
+          Map2.encodeDelimited = function encodeDelimited(message, writer) {
+            return this.encode(message, writer).ldelim();
+          };
+          Map2.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.TypeProto.Map();
+            while (reader.pos < end) {
+              var tag = reader.uint32();
+              switch (tag >>> 3) {
+                case 1: {
+                  message.keyType = reader.int32();
+                  break;
+                }
+                case 2: {
+                  message.valueType = $root.onnx.TypeProto.decode(reader, reader.uint32());
+                  break;
+                }
+                default:
+                  reader.skipType(tag & 7);
+                  break;
+              }
+            }
+            return message;
+          };
+          Map2.decodeDelimited = function decodeDelimited(reader) {
+            if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+            return this.decode(reader, reader.uint32());
+          };
+          Map2.verify = function verify(message) {
+            if (typeof message !== "object" || message === null) return "object expected";
+            if (message.keyType != null && message.hasOwnProperty("keyType")) {
+              if (!$util.isInteger(message.keyType)) return "keyType: integer expected";
+            }
+            if (message.valueType != null && message.hasOwnProperty("valueType")) {
+              var error = $root.onnx.TypeProto.verify(message.valueType);
+              if (error) return "valueType." + error;
+            }
+            return null;
+          };
+          Map2.fromObject = function fromObject(object) {
+            if (object instanceof $root.onnx.TypeProto.Map) return object;
+            var message = new $root.onnx.TypeProto.Map();
+            if (object.keyType != null) message.keyType = object.keyType | 0;
+            if (object.valueType != null) {
+              if (typeof object.valueType !== "object") throw TypeError(".onnx.TypeProto.Map.valueType: object expected");
+              message.valueType = $root.onnx.TypeProto.fromObject(object.valueType);
+            }
+            return message;
+          };
+          Map2.toObject = function toObject(message, options) {
+            if (!options) options = {};
+            var object = {};
+            if (options.defaults) {
+              object.keyType = 0;
+              object.valueType = null;
+            }
+            if (message.keyType != null && message.hasOwnProperty("keyType")) object.keyType = message.keyType;
+            if (message.valueType != null && message.hasOwnProperty("valueType"))
+              object.valueType = $root.onnx.TypeProto.toObject(message.valueType, options);
+            return object;
+          };
+          Map2.prototype.toJSON = function toJSON() {
+            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+          };
+          Map2.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+            if (typeUrlPrefix === void 0) {
+              typeUrlPrefix = "type.googleapis.com";
+            }
+            return typeUrlPrefix + "/onnx.TypeProto.Map";
+          };
+          return Map2;
+        })();
+        TypeProto.Optional = (function() {
+          function Optional(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]];
+            }
+          }
+          Optional.prototype.elemType = null;
+          Optional.create = function create(properties) {
+            return new Optional(properties);
+          };
+          Optional.encode = function encode(message, writer) {
+            if (!writer) writer = $Writer.create();
+            if (message.elemType != null && Object.hasOwnProperty.call(message, "elemType"))
+              $root.onnx.TypeProto.encode(message.elemType, writer.uint32(
+                /* id 1, wireType 2 =*/
+                10
+              ).fork()).ldelim();
+            return writer;
+          };
+          Optional.encodeDelimited = function encodeDelimited(message, writer) {
+            return this.encode(message, writer).ldelim();
+          };
+          Optional.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.TypeProto.Optional();
+            while (reader.pos < end) {
+              var tag = reader.uint32();
+              switch (tag >>> 3) {
+                case 1: {
+                  message.elemType = $root.onnx.TypeProto.decode(reader, reader.uint32());
+                  break;
+                }
+                default:
+                  reader.skipType(tag & 7);
+                  break;
+              }
+            }
+            return message;
+          };
+          Optional.decodeDelimited = function decodeDelimited(reader) {
+            if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+            return this.decode(reader, reader.uint32());
+          };
+          Optional.verify = function verify(message) {
+            if (typeof message !== "object" || message === null) return "object expected";
+            if (message.elemType != null && message.hasOwnProperty("elemType")) {
+              var error = $root.onnx.TypeProto.verify(message.elemType);
+              if (error) return "elemType." + error;
+            }
+            return null;
+          };
+          Optional.fromObject = function fromObject(object) {
+            if (object instanceof $root.onnx.TypeProto.Optional) return object;
+            var message = new $root.onnx.TypeProto.Optional();
+            if (object.elemType != null) {
+              if (typeof object.elemType !== "object")
+                throw TypeError(".onnx.TypeProto.Optional.elemType: object expected");
+              message.elemType = $root.onnx.TypeProto.fromObject(object.elemType);
+            }
+            return message;
+          };
+          Optional.toObject = function toObject(message, options) {
+            if (!options) options = {};
+            var object = {};
+            if (options.defaults) object.elemType = null;
+            if (message.elemType != null && message.hasOwnProperty("elemType"))
+              object.elemType = $root.onnx.TypeProto.toObject(message.elemType, options);
+            return object;
+          };
+          Optional.prototype.toJSON = function toJSON() {
+            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+          };
+          Optional.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+            if (typeUrlPrefix === void 0) {
+              typeUrlPrefix = "type.googleapis.com";
+            }
+            return typeUrlPrefix + "/onnx.TypeProto.Optional";
+          };
+          return Optional;
+        })();
+        TypeProto.SparseTensor = (function() {
+          function SparseTensor2(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]];
+            }
+          }
+          SparseTensor2.prototype.elemType = 0;
+          SparseTensor2.prototype.shape = null;
+          SparseTensor2.create = function create(properties) {
+            return new SparseTensor2(properties);
+          };
+          SparseTensor2.encode = function encode(message, writer) {
+            if (!writer) writer = $Writer.create();
+            if (message.elemType != null && Object.hasOwnProperty.call(message, "elemType"))
+              writer.uint32(
+                /* id 1, wireType 0 =*/
+                8
+              ).int32(message.elemType);
+            if (message.shape != null && Object.hasOwnProperty.call(message, "shape"))
+              $root.onnx.TensorShapeProto.encode(message.shape, writer.uint32(
+                /* id 2, wireType 2 =*/
+                18
+              ).fork()).ldelim();
+            return writer;
+          };
+          SparseTensor2.encodeDelimited = function encodeDelimited(message, writer) {
+            return this.encode(message, writer).ldelim();
+          };
+          SparseTensor2.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.TypeProto.SparseTensor();
+            while (reader.pos < end) {
+              var tag = reader.uint32();
+              switch (tag >>> 3) {
+                case 1: {
+                  message.elemType = reader.int32();
+                  break;
+                }
+                case 2: {
+                  message.shape = $root.onnx.TensorShapeProto.decode(reader, reader.uint32());
+                  break;
+                }
+                default:
+                  reader.skipType(tag & 7);
+                  break;
+              }
+            }
+            return message;
+          };
+          SparseTensor2.decodeDelimited = function decodeDelimited(reader) {
+            if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+            return this.decode(reader, reader.uint32());
+          };
+          SparseTensor2.verify = function verify(message) {
+            if (typeof message !== "object" || message === null) return "object expected";
+            if (message.elemType != null && message.hasOwnProperty("elemType")) {
+              if (!$util.isInteger(message.elemType)) return "elemType: integer expected";
+            }
+            if (message.shape != null && message.hasOwnProperty("shape")) {
+              var error = $root.onnx.TensorShapeProto.verify(message.shape);
+              if (error) return "shape." + error;
+            }
+            return null;
+          };
+          SparseTensor2.fromObject = function fromObject(object) {
+            if (object instanceof $root.onnx.TypeProto.SparseTensor) return object;
+            var message = new $root.onnx.TypeProto.SparseTensor();
+            if (object.elemType != null) message.elemType = object.elemType | 0;
+            if (object.shape != null) {
+              if (typeof object.shape !== "object") throw TypeError(".onnx.TypeProto.SparseTensor.shape: object expected");
+              message.shape = $root.onnx.TensorShapeProto.fromObject(object.shape);
+            }
+            return message;
+          };
+          SparseTensor2.toObject = function toObject(message, options) {
+            if (!options) options = {};
+            var object = {};
+            if (options.defaults) {
+              object.elemType = 0;
+              object.shape = null;
+            }
+            if (message.elemType != null && message.hasOwnProperty("elemType")) object.elemType = message.elemType;
+            if (message.shape != null && message.hasOwnProperty("shape"))
+              object.shape = $root.onnx.TensorShapeProto.toObject(message.shape, options);
+            return object;
+          };
+          SparseTensor2.prototype.toJSON = function toJSON() {
+            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+          };
+          SparseTensor2.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+            if (typeUrlPrefix === void 0) {
+              typeUrlPrefix = "type.googleapis.com";
+            }
+            return typeUrlPrefix + "/onnx.TypeProto.SparseTensor";
+          };
+          return SparseTensor2;
+        })();
+        return TypeProto;
+      })();
+      onnx6.OperatorSetIdProto = (function() {
+        function OperatorSetIdProto(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]];
+          }
+        }
+        OperatorSetIdProto.prototype.domain = "";
+        OperatorSetIdProto.prototype.version = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;
+        OperatorSetIdProto.create = function create(properties) {
+          return new OperatorSetIdProto(properties);
+        };
+        OperatorSetIdProto.encode = function encode(message, writer) {
+          if (!writer) writer = $Writer.create();
+          if (message.domain != null && Object.hasOwnProperty.call(message, "domain"))
+            writer.uint32(
+              /* id 1, wireType 2 =*/
+              10
+            ).string(message.domain);
+          if (message.version != null && Object.hasOwnProperty.call(message, "version"))
+            writer.uint32(
+              /* id 2, wireType 0 =*/
+              16
+            ).int64(message.version);
+          return writer;
+        };
+        OperatorSetIdProto.encodeDelimited = function encodeDelimited(message, writer) {
+          return this.encode(message, writer).ldelim();
+        };
+        OperatorSetIdProto.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.OperatorSetIdProto();
+          while (reader.pos < end) {
+            var tag = reader.uint32();
+            switch (tag >>> 3) {
+              case 1: {
+                message.domain = reader.string();
+                break;
+              }
+              case 2: {
+                message.version = reader.int64();
+                break;
+              }
+              default:
+                reader.skipType(tag & 7);
+                break;
+            }
+          }
+          return message;
+        };
+        OperatorSetIdProto.decodeDelimited = function decodeDelimited(reader) {
+          if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+          return this.decode(reader, reader.uint32());
+        };
+        OperatorSetIdProto.verify = function verify(message) {
+          if (typeof message !== "object" || message === null) return "object expected";
+          if (message.domain != null && message.hasOwnProperty("domain")) {
+            if (!$util.isString(message.domain)) return "domain: string expected";
+          }
+          if (message.version != null && message.hasOwnProperty("version")) {
+            if (!$util.isInteger(message.version) && !(message.version && $util.isInteger(message.version.low) && $util.isInteger(message.version.high)))
+              return "version: integer|Long expected";
+          }
+          return null;
+        };
+        OperatorSetIdProto.fromObject = function fromObject(object) {
+          if (object instanceof $root.onnx.OperatorSetIdProto) return object;
+          var message = new $root.onnx.OperatorSetIdProto();
+          if (object.domain != null) message.domain = String(object.domain);
+          if (object.version != null) {
+            if ($util.Long) (message.version = $util.Long.fromValue(object.version)).unsigned = false;
+            else if (typeof object.version === "string") message.version = parseInt(object.version, 10);
+            else if (typeof object.version === "number") message.version = object.version;
+            else if (typeof object.version === "object")
+              message.version = new $util.LongBits(object.version.low >>> 0, object.version.high >>> 0).toNumber();
+          }
+          return message;
+        };
+        OperatorSetIdProto.toObject = function toObject(message, options) {
+          if (!options) options = {};
+          var object = {};
+          if (options.defaults) {
+            object.domain = "";
+            if ($util.Long) {
+              var long = new $util.Long(0, 0, false);
+              object.version = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
+            } else object.version = options.longs === String ? "0" : 0;
+          }
+          if (message.domain != null && message.hasOwnProperty("domain")) object.domain = message.domain;
+          if (message.version != null && message.hasOwnProperty("version"))
+            if (typeof message.version === "number")
+              object.version = options.longs === String ? String(message.version) : message.version;
+            else
+              object.version = options.longs === String ? $util.Long.prototype.toString.call(message.version) : options.longs === Number ? new $util.LongBits(message.version.low >>> 0, message.version.high >>> 0).toNumber() : message.version;
+          return object;
+        };
+        OperatorSetIdProto.prototype.toJSON = function toJSON() {
+          return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+        };
+        OperatorSetIdProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+          if (typeUrlPrefix === void 0) {
+            typeUrlPrefix = "type.googleapis.com";
+          }
+          return typeUrlPrefix + "/onnx.OperatorSetIdProto";
+        };
+        return OperatorSetIdProto;
+      })();
+      onnx6.OperatorStatus = (function() {
+        var valuesById = {}, values = Object.create(valuesById);
+        values[valuesById[0] = "EXPERIMENTAL"] = 0;
+        values[valuesById[1] = "STABLE"] = 1;
+        return values;
+      })();
+      onnx6.FunctionProto = (function() {
+        function FunctionProto(properties) {
+          this.input = [];
+          this.output = [];
+          this.attribute = [];
+          this.attributeProto = [];
+          this.node = [];
+          this.opsetImport = [];
+          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]];
+          }
+        }
+        FunctionProto.prototype.name = "";
+        FunctionProto.prototype.input = $util.emptyArray;
+        FunctionProto.prototype.output = $util.emptyArray;
+        FunctionProto.prototype.attribute = $util.emptyArray;
+        FunctionProto.prototype.attributeProto = $util.emptyArray;
+        FunctionProto.prototype.node = $util.emptyArray;
+        FunctionProto.prototype.docString = "";
+        FunctionProto.prototype.opsetImport = $util.emptyArray;
+        FunctionProto.prototype.domain = "";
+        FunctionProto.create = function create(properties) {
+          return new FunctionProto(properties);
+        };
+        FunctionProto.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.input != null && message.input.length)
+            for (var i = 0; i < message.input.length; ++i)
+              writer.uint32(
+                /* id 4, wireType 2 =*/
+                34
+              ).string(message.input[i]);
+          if (message.output != null && message.output.length)
+            for (var i = 0; i < message.output.length; ++i)
+              writer.uint32(
+                /* id 5, wireType 2 =*/
+                42
+              ).string(message.output[i]);
+          if (message.attribute != null && message.attribute.length)
+            for (var i = 0; i < message.attribute.length; ++i)
+              writer.uint32(
+                /* id 6, wireType 2 =*/
+                50
+              ).string(message.attribute[i]);
+          if (message.node != null && message.node.length)
+            for (var i = 0; i < message.node.length; ++i)
+              $root.onnx.NodeProto.encode(message.node[i], writer.uint32(
+                /* id 7, wireType 2 =*/
+                58
+              ).fork()).ldelim();
+          if (message.docString != null && Object.hasOwnProperty.call(message, "docString"))
+            writer.uint32(
+              /* id 8, wireType 2 =*/
+              66
+            ).string(message.docString);
+          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 9, wireType 2 =*/
+                  74
+                ).fork()
+              ).ldelim();
+          if (message.domain != null && Object.hasOwnProperty.call(message, "domain"))
+            writer.uint32(
+              /* id 10, wireType 2 =*/
+              82
+            ).string(message.domain);
+          if (message.attributeProto != null && message.attributeProto.length)
+            for (var i = 0; i < message.attributeProto.length; ++i)
+              $root.onnx.AttributeProto.encode(
+                message.attributeProto[i],
+                writer.uint32(
+                  /* id 11, wireType 2 =*/
+                  90
+                ).fork()
+              ).ldelim();
+          return writer;
+        };
+        FunctionProto.encodeDelimited = function encodeDelimited(message, writer) {
+          return this.encode(message, writer).ldelim();
+        };
+        FunctionProto.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.FunctionProto();
+          while (reader.pos < end) {
+            var tag = reader.uint32();
+            switch (tag >>> 3) {
+              case 1: {
+                message.name = reader.string();
+                break;
+              }
+              case 4: {
+                if (!(message.input && message.input.length)) message.input = [];
+                message.input.push(reader.string());
+                break;
+              }
+              case 5: {
+                if (!(message.output && message.output.length)) message.output = [];
+                message.output.push(reader.string());
+                break;
+              }
+              case 6: {
+                if (!(message.attribute && message.attribute.length)) message.attribute = [];
+                message.attribute.push(reader.string());
+                break;
+              }
+              case 11: {
+                if (!(message.attributeProto && message.attributeProto.length)) message.attributeProto = [];
+                message.attributeProto.push($root.onnx.AttributeProto.decode(reader, reader.uint32()));
+                break;
+              }
+              case 7: {
+                if (!(message.node && message.node.length)) message.node = [];
+                message.node.push($root.onnx.NodeProto.decode(reader, reader.uint32()));
+                break;
+              }
+              case 8: {
+                message.docString = reader.string();
+                break;
+              }
+              case 9: {
+                if (!(message.opsetImport && message.opsetImport.length)) message.opsetImport = [];
+                message.opsetImport.push($root.onnx.OperatorSetIdProto.decode(reader, reader.uint32()));
+                break;
+              }
+              case 10: {
+                message.domain = reader.string();
+                break;
+              }
+              default:
+                reader.skipType(tag & 7);
+                break;
+            }
+          }
+          return message;
+        };
+        FunctionProto.decodeDelimited = function decodeDelimited(reader) {
+          if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+          return this.decode(reader, reader.uint32());
+        };
+        FunctionProto.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.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.attribute != null && message.hasOwnProperty("attribute")) {
+            if (!Array.isArray(message.attribute)) return "attribute: array expected";
+            for (var i = 0; i < message.attribute.length; ++i)
+              if (!$util.isString(message.attribute[i])) return "attribute: string[] expected";
+          }
+          if (message.attributeProto != null && message.hasOwnProperty("attributeProto")) {
+            if (!Array.isArray(message.attributeProto)) return "attributeProto: array expected";
+            for (var i = 0; i < message.attributeProto.length; ++i) {
+              var error = $root.onnx.AttributeProto.verify(message.attributeProto[i]);
+              if (error) return "attributeProto." + error;
+            }
+          }
+          if (message.node != null && message.hasOwnProperty("node")) {
+            if (!Array.isArray(message.node)) return "node: array expected";
+            for (var i = 0; i < message.node.length; ++i) {
+              var error = $root.onnx.NodeProto.verify(message.node[i]);
+              if (error) return "node." + error;
+            }
+          }
+          if (message.docString != null && message.hasOwnProperty("docString")) {
+            if (!$util.isString(message.docString)) return "docString: string 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.domain != null && message.hasOwnProperty("domain")) {
+            if (!$util.isString(message.domain)) return "domain: string expected";
+          }
+          return null;
+        };
+        FunctionProto.fromObject = function fromObject(object) {
+          if (object instanceof $root.onnx.FunctionProto) return object;
+          var message = new $root.onnx.FunctionProto();
+          if (object.name != null) message.name = String(object.name);
+          if (object.input) {
+            if (!Array.isArray(object.input)) throw TypeError(".onnx.FunctionProto.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.FunctionProto.output: array expected");
+            message.output = [];
+            for (var i = 0; i < object.output.length; ++i) message.output[i] = String(object.output[i]);
+          }
+          if (object.attribute) {
+            if (!Array.isArray(object.attribute)) throw TypeError(".onnx.FunctionProto.attribute: array expected");
+            message.attribute = [];
+            for (var i = 0; i < object.attribute.length; ++i) message.attribute[i] = String(object.attribute[i]);
+          }
+          if (object.attributeProto) {
+            if (!Array.isArray(object.attributeProto))
+              throw TypeError(".onnx.FunctionProto.attributeProto: array expected");
+            message.attributeProto = [];
+            for (var i = 0; i < object.attributeProto.length; ++i) {
+              if (typeof object.attributeProto[i] !== "object")
+                throw TypeError(".onnx.FunctionProto.attributeProto: object expected");
+              message.attributeProto[i] = $root.onnx.AttributeProto.fromObject(object.attributeProto[i]);
+            }
+          }
+          if (object.node) {
+            if (!Array.isArray(object.node)) throw TypeError(".onnx.FunctionProto.node: array expected");
+            message.node = [];
+            for (var i = 0; i < object.node.length; ++i) {
+              if (typeof object.node[i] !== "object") throw TypeError(".onnx.FunctionProto.node: object expected");
+              message.node[i] = $root.onnx.NodeProto.fromObject(object.node[i]);
+            }
+          }
+          if (object.docString != null) message.docString = String(object.docString);
+          if (object.opsetImport) {
+            if (!Array.isArray(object.opsetImport)) throw TypeError(".onnx.FunctionProto.opsetImport: array expected");
+            message.opsetImport = [];
+            for (var i = 0; i < object.opsetImport.length; ++i) {
+              if (typeof object.opsetImport[i] !== "object")
+                throw TypeError(".onnx.FunctionProto.opsetImport: object expected");
+              message.opsetImport[i] = $root.onnx.OperatorSetIdProto.fromObject(object.opsetImport[i]);
+            }
+          }
+          if (object.domain != null) message.domain = String(object.domain);
+          return message;
+        };
+        FunctionProto.toObject = function toObject(message, options) {
+          if (!options) options = {};
+          var object = {};
+          if (options.arrays || options.defaults) {
+            object.input = [];
+            object.output = [];
+            object.attribute = [];
+            object.node = [];
+            object.opsetImport = [];
+            object.attributeProto = [];
+          }
+          if (options.defaults) {
+            object.name = "";
+            object.docString = "";
+            object.domain = "";
+          }
+          if (message.name != null && message.hasOwnProperty("name")) object.name = message.name;
+          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.attribute && message.attribute.length) {
+            object.attribute = [];
+            for (var j = 0; j < message.attribute.length; ++j) object.attribute[j] = message.attribute[j];
+          }
+          if (message.node && message.node.length) {
+            object.node = [];
+            for (var j = 0; j < message.node.length; ++j)
+              object.node[j] = $root.onnx.NodeProto.toObject(message.node[j], options);
+          }
+          if (message.docString != null && message.hasOwnProperty("docString")) object.docString = message.docString;
+          if (message.opsetImport && message.opsetImport.length) {
+            object.opsetImport = [];
+            for (var j = 0; j < message.opsetImport.length; ++j)
+              object.opsetImport[j] = $root.onnx.OperatorSetIdProto.toObject(message.opsetImport[j], options);
+          }
+          if (message.domain != null && message.hasOwnProperty("domain")) object.domain = message.domain;
+          if (message.attributeProto && message.attributeProto.length) {
+            object.attributeProto = [];
+            for (var j = 0; j < message.attributeProto.length; ++j)
+              object.attributeProto[j] = $root.onnx.AttributeProto.toObject(message.attributeProto[j], options);
+          }
+          return object;
+        };
+        FunctionProto.prototype.toJSON = function toJSON() {
+          return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+        };
+        FunctionProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+          if (typeUrlPrefix === void 0) {
+            typeUrlPrefix = "type.googleapis.com";
+          }
+          return typeUrlPrefix + "/onnx.FunctionProto";
+        };
+        return FunctionProto;
+      })();
+      return onnx6;
+    })();
+    module.exports = $root;
+  }
+});
+
+// web/lib/onnxjs/util.ts
+function assert(expr, msg) {
+  if (!expr) {
+    throw new Error(typeof msg === "string" ? msg : msg());
+  }
+}
+function decodeUtf8String(buffer) {
+  return new TextDecoder().decode(buffer);
+}
+var import_onnx, ArrayUtil, MatMulUtil, BroadcastUtil, GemmUtil, ProtoUtil, LongUtil, ShapeUtil, SplitUtil, PoolConvUtil, MIN_CLIP, MAX_CLIP;
+var init_util = __esm({
+  "web/lib/onnxjs/util.ts"() {
+    "use strict";
+    init_long();
+    import_onnx = __toESM(require_onnx());
+    init_tensor2();
+    ArrayUtil = class {
+      /**
+       * Verifies if 2 input arrays contain the same elements.
+       * @param n1 Array 1
+       * @param n2 Array 2
+       * @returns Whether these 2 are equal
+       */
+      static arraysEqual(n1, n2) {
+        if (n1.length !== n2.length) {
+          return false;
+        }
+        for (let i = 0; i < n1.length; i++) {
+          if (n1[i] !== n2[i]) {
+            return false;
+          }
+        }
+        return true;
+      }
+    };
+    MatMulUtil = class {
+      /**
+       * Fix the input shapes for MatMul operation if they need fixing
+       * @param dimsA The shape of tensor A. Should be an array of positive integers
+       * @param dimsB The shape of tensor B. Should be an array of positive integers
+       * @returns A tuple containing the preprocessed input shapes as required by ONNX specifications
+       */
+      static preprocessInputShapes(dimsA, dimsB) {
+        const a = dimsA.length === 1 ? [1, dimsA[0]] : dimsA;
+        const b = dimsB.length === 1 ? [dimsB[0], 1] : dimsB;
+        return [a, b];
+      }
+      /**
+       * Fix the output shape computed for MatMul operation if it needs fixing
+       * @param outputShape The computed outputShape. Should be an array (at least of length 2) of positive integers.
+       * This will be mutated.
+       * @param aRank The rank of tensor A.
+       * @param bRank The rank of tensor B.
+       */
+      static postprocessOutputShape(outputShape, aRank, bRank) {
+        if (aRank === 1) {
+          outputShape.splice(outputShape.length - 2, 1);
+        }
+        if (bRank === 1) {
+          outputShape.pop();
+        }
+      }
+      /**
+       * Calculate the expected shape when matrix multiplication
+       * @param a The shape of tensor A. Should be a tuple of 2 positive integers
+       * @param b The shape of tensor B. Should be a tuple of 2 positive integers
+       * @returns The expected shape of the result, or undefined if N/A
+       */
+      static calcMatMulShape(a, b) {
+        return a[1] !== b[0] ? void 0 : [a[0], b[1]];
+      }
+    };
+    BroadcastUtil = class _BroadcastUtil {
+      /**
+       * Calculate the expected shape when broadcasting 2 tensors
+       * @param a The shape of tensor A. Should be an array of positive integers
+       * @param b The shape of tensor B. Should be an array of positive integers
+       * @param isMatMul Whether the operation is MatMul
+       * @returns The expected shape of the result, or undefined if N/A
+       */
+      static calcShape(adims, bdims, isMatMul = false) {
+        const arank = adims.length;
+        const brank = bdims.length;
+        if (arank === 0) {
+          return bdims;
+        }
+        if (brank === 0) {
+          return adims;
+        }
+        const crank = Math.max(adims.length, bdims.length);
+        const cdims = new Array(crank);
+        if (isMatMul) {
+          if (arank < 2 || brank < 2) {
+            return void 0;
+          }
+          const cShapeMatMul = MatMulUtil.calcMatMulShape(
+            [adims[arank - 2], adims[arank - 1]],
+            [bdims[brank - 2], bdims[brank - 1]]
+          );
+          if (cShapeMatMul === void 0) {
+            return void 0;
+          }
+          [cdims[crank - 2], cdims[crank - 1]] = cShapeMatMul;
+        }
+        for (let i = isMatMul ? 3 : 1; i <= crank; i++) {
+          const aLen = arank - i < 0 ? 1 : adims[arank - i];
+          const bLen = brank - i < 0 ? 1 : bdims[brank - i];
+          if (aLen !== bLen && aLen > 1 && bLen > 1) {
+            return void 0;
+          }
+          cdims[crank - i] = Math.max(aLen, bLen);
+        }
+        return cdims;
+      }
+      /**
+       * Given the indices of a broadcasted tensor, calculate the original indices
+       * @param broadcastedIndices The given indices of the broadcasted tensor.
+       * @param originalShape The original shape of the tensor before broadcast
+       * @returns The calculated indices that maps to the original tensor.
+       */
+      static index(broadcastedIndices, originalShape) {
+        const originalIndices = new Array(originalShape.length);
+        _BroadcastUtil.fillIndex(broadcastedIndices, originalShape, originalIndices);
+        return originalIndices;
+      }
+      /**
+       * Given the indices of a broadcasted tensor, calculate the original indices
+       * @param broadcastedIndices The given indices of the broadcasted tensor.
+       * @param originalShape The original shape of the tensor before broadcast
+       * @param originalIndices The mapping of broadcastedIndices to the originalIndices (output parameter - will be
+       *     mutated).
+       */
+      static fillIndex(broadcastedIndices, originalShape, originalIndices) {
+        const dimOffset = broadcastedIndices.length - originalShape.length;
+        for (let i = 0; i < originalShape.length; i++) {
+          originalIndices[i] = broadcastedIndices[dimOffset + i] % originalShape[i];
+        }
+      }
+      /**
+       * Perform the broadcasting operation on the specific operator
+       * @param a The input tensor A
+       * @param b The input tensor B
+       * @param op The operator lambda function
+       * @param inplace Whether to write the result back to A.
+       * @returns The result tensor, or undefined if input not broadcastable.
+       */
+      static calc(a, b, op, inplace, resultType) {
+        const outputShape = _BroadcastUtil.calcShape(a.dims, b.dims);
+        if (outputShape) {
+          if (inplace && !ShapeUtil.areEqual(outputShape, a.dims)) {
+            return void 0;
+          }
+          const size = ShapeUtil.size(outputShape);
+          const c = inplace ? a : new Tensor4(outputShape, resultType || a.type);
+          if (outputShape.length === 0) {
+            c.set([], op(a.get([]), b.get([])));
+          } else {
+            const outputIndices = new Array(outputShape.length);
+            const originalIndicesA = new Array(a.dims.length);
+            const originalIndicesB = new Array(b.dims.length);
+            let valA = 0;
+            let valB = 0;
+            let isAScalar = false;
+            let isBScalar = false;
+            if (a.dims.length === 0) {
+              valA = a.get([]);
+              isAScalar = true;
+            }
+            if (b.dims.length === 0) {
+              valB = b.get([]);
+              isBScalar = true;
+            }
+            let rest;
+            for (let i = 0; i < size; i++) {
+              rest = i;
+              for (let j = outputShape.length - 1; j >= 0; j--) {
+                outputIndices[j] = rest % outputShape[j];
+                rest = Math.floor(rest / outputShape[j]);
+              }
+              if (!isAScalar) {
+                _BroadcastUtil.fillIndex(outputIndices, a.dims, originalIndicesA);
+                valA = a.get(originalIndicesA);
+              }
+              if (!isBScalar) {
+                _BroadcastUtil.fillIndex(outputIndices, b.dims, originalIndicesB);
+                valB = b.get(originalIndicesB);
+              }
+              c.set(outputIndices, op(valA, valB));
+            }
+          }
+          return c;
+        }
+        return void 0;
+      }
+      /**
+       * Determine if a shape is unidirectional broadcastable to another shape
+       * @param shape The input shape
+       * @param finalShape The desired shape after broadcasting
+       */
+      static isValidBroadcast(shape2, finalShape) {
+        const inputRank = shape2.length;
+        const finalRank = finalShape.length;
+        if (inputRank > finalRank) {
+          return false;
+        }
+        for (let i = 1; i <= inputRank; i++) {
+          if (shape2[inputRank - i] !== 1 && shape2[inputRank - i] !== finalShape[finalRank - i]) {
+            return false;
+          }
+        }
+        return true;
+      }
+      /**
+       * Determine the broadcasted dims in input shape based on the given output shape.
+       * Note that this function only returns the broadcasted dims.
+       * @param inputShape The input shape
+       * @param outputShape The output shape
+       * @returns The broadcasted dims in input shape.
+       */
+      static getBroadcastDims(inputShape, outputShape) {
+        const inRank = inputShape.length;
+        const dims = [];
+        for (let i = 0; i < inRank; i++) {
+          const dim = inRank - 1 - i;
+          const a = inputShape[dim] || 1;
+          const b = outputShape[outputShape.length - 1 - i] || 1;
+          if (b > 1 && a === 1) {
+            dims.unshift(dim);
+          }
+        }
+        return dims;
+      }
+    };
+    GemmUtil = class {
+      // will make sure input shapes are compatible for this op
+      // and return back the shape of the output in the form of a tuple
+      // will throw exception if the input shapes are not compatible
+      static getShapeOfGemmResult(leftShape, transLeft, rightShape, transRight, biasShape) {
+        if (leftShape.length !== 2 || rightShape.length !== 2) {
+          throw new Error("shape need to be of size 2");
+        }
+        let M;
+        let K;
+        let N;
+        if (transLeft) {
+          M = leftShape[1];
+          K = leftShape[0];
+        } else {
+          M = leftShape[0];
+          K = leftShape[1];
+        }
+        let kDim = -1;
+        if (transRight) {
+          N = rightShape[0];
+          kDim = 1;
+        } else {
+          N = rightShape[1];
+          kDim = 0;
+        }
+        if (rightShape[kDim] !== K) {
+          throw new Error("dimension mismatch");
+        }
+        if (M <= 0 || N <= 0 || K <= 0) {
+          throw new Error("invalid shape specified");
+        }
+        if (biasShape && !BroadcastUtil.isValidBroadcast(biasShape, [M, N])) {
+          throw new Error("gemm: invalid bias shape for broadcast");
+        }
+        return [M, N, K];
+      }
+    };
+    ProtoUtil = class _ProtoUtil {
+      static tensorDataTypeFromProto(typeProto) {
+        switch (typeProto) {
+          case import_onnx.onnx.TensorProto.DataType.INT8:
+            return "int8";
+          case import_onnx.onnx.TensorProto.DataType.UINT8:
+            return "uint8";
+          case import_onnx.onnx.TensorProto.DataType.BOOL:
+            return "bool";
+          case import_onnx.onnx.TensorProto.DataType.INT16:
+            return "int16";
+          case import_onnx.onnx.TensorProto.DataType.UINT16:
+            return "uint16";
+          case import_onnx.onnx.TensorProto.DataType.INT32:
+            return "int32";
+          case import_onnx.onnx.TensorProto.DataType.UINT32:
+            return "uint32";
+          case import_onnx.onnx.TensorProto.DataType.FLOAT:
+            return "float32";
+          case import_onnx.onnx.TensorProto.DataType.DOUBLE:
+            return "float64";
+          case import_onnx.onnx.TensorProto.DataType.STRING:
+            return "string";
+          // For INT64/UINT64, reduce their value to 32-bits.
+          // Should throw exception when overflow
+          case import_onnx.onnx.TensorProto.DataType.INT64:
+            return "int32";
+          case import_onnx.onnx.TensorProto.DataType.UINT64:
+            return "uint32";
+          default:
+            throw new Error(`unsupported data type: ${import_onnx.onnx.TensorProto.DataType[typeProto]}`);
+        }
+      }
+      static tensorDataTypeStringToEnum(type) {
+        switch (type) {
+          case "int8":
+            return import_onnx.onnx.TensorProto.DataType.INT8;
+          case "uint8":
+            return import_onnx.onnx.TensorProto.DataType.UINT8;
+          case "bool":
+            return import_onnx.onnx.TensorProto.DataType.BOOL;
+          case "int16":
+            return import_onnx.onnx.TensorProto.DataType.INT16;
+          case "uint16":
+            return import_onnx.onnx.TensorProto.DataType.UINT16;
+          case "int32":
+            return import_onnx.onnx.TensorProto.DataType.INT32;
+          case "uint32":
+            return import_onnx.onnx.TensorProto.DataType.UINT32;
+          case "float32":
+            return import_onnx.onnx.TensorProto.DataType.FLOAT;
+          case "float64":
+            return import_onnx.onnx.TensorProto.DataType.DOUBLE;
+          case "string":
+            return import_onnx.onnx.TensorProto.DataType.STRING;
+          case "int64":
+            return import_onnx.onnx.TensorProto.DataType.INT64;
+          case "uint64":
+            return import_onnx.onnx.TensorProto.DataType.UINT64;
+          default:
+            throw new Error(`unsupported data type: ${type}`);
+        }
+      }
+      static tensorDimsFromProto(dims) {
+        return dims.map((d) => long_default.isLong(d) ? d.toNumber() : d);
+      }
+      static tensorValueTypeFromProto(valueType) {
+        return {
+          tensorType: _ProtoUtil.tensorDataTypeFromProto(valueType.elemType),
+          shape: { dims: _ProtoUtil.tensorDimsFromProto(valueType.shape.dim.map((d) => d.dimValue)) }
+        };
+      }
+      static tensorDimsFromORTFormat(tensor) {
+        const dims = [];
+        for (let i = 0; i < tensor.dimsLength(); i++) {
+          dims.push(LongUtil.longToNumber(tensor.dims(i)));
+        }
+        return dims;
+      }
+      static tensorAttributesFromORTFormat(node) {
+        const attributes = [];
+        for (let i = 0; i < node.attributesLength(); i++) {
+          attributes.push(node.attributes(i));
+        }
+        return attributes;
+      }
+    };
+    LongUtil = class {
+      // This function is called to get a number from long type of data for attribute, dim, and ir version,
+      // which values are signed integers.
+      // To make it more generic, add an optional parameter to convert to a unsigned number.
+      static longToNumber(n) {
+        if (long_default.isLong(n)) {
+          return n.toNumber();
+        } else if (typeof n === "bigint") {
+          return Number(n);
+        }
+        return n;
+      }
+      static isLong(n) {
+        return long_default.isLong(n) || typeof n === "bigint";
+      }
+    };
+    ShapeUtil = class _ShapeUtil {
+      static size(dims) {
+        return _ShapeUtil.getSizeFromDimensionRange(dims, 0, dims.length);
+      }
+      // `axis` inclusive
+      static sizeFromDimension(dims, axis) {
+        if (axis < 0 || axis > dims.length) {
+          throw new Error(`invalid dimension of ${axis} for sizeFromDimension as Tensor has ${dims.length} dimensions.`);
+        }
+        return _ShapeUtil.getSizeFromDimensionRange(dims, axis, dims.length);
+      }
+      // `axis` exclusive
+      static sizeToDimension(dims, axis) {
+        if (axis < 0 || axis > dims.length) {
+          throw new Error(`invalid dimension of ${axis} for sizeToDimension as Tensor has ${dims.length} dimensions.`);
+        }
+        return _ShapeUtil.getSizeFromDimensionRange(dims, 0, axis);
+      }
+      static getSizeFromDimensionRange(dims, start, end) {
+        let size = 1;
+        for (let i = start; i < end; i++) {
+          if (dims[i] <= 0) {
+            throw new Error(
+              "cannot get valid size from specified dimension range. Most likely the range contains 0 or negative values in them."
+            );
+          }
+          size *= dims[i];
+        }
+        return size;
+      }
+      static computeStrides(dims) {
+        const rank = dims.length;
+        if (rank === 0) {
+          return [];
+        } else if (rank === 1) {
+          return [1];
+        }
+        const strides = new Array(rank);
+        strides[rank - 1] = 1;
+        strides[rank - 2] = dims[rank - 1];
+        for (let i = rank - 3; i >= 0; --i) {
+          strides[i] = strides[i + 1] * dims[i + 1];
+        }
+        return strides;
+      }
+      static transpose(dims) {
+        const copy = dims.slice();
+        return copy.reverse();
+      }
+      static indicesToOffset(indices, strides, axis) {
+        if (axis === void 0) {
+          axis = indices.length;
+        }
+        let offset = 0;
+        for (let i = 0; i < axis; ++i) {
+          offset += strides[i] * indices[i];
+        }
+        return offset;
+      }
+      static offsetToIndices(offset, strides) {
+        const rank = strides.length;
+        if (rank === 0) {
+          return [];
+        } else if (rank === 1) {
+          return [offset * strides[0]];
+        }
+        const indices = new Array(strides.length);
+        for (let i = 0; i < indices.length - 1; ++i) {
+          indices[i] = Math.floor(offset / strides[i]);
+          offset -= indices[i] * strides[i];
+        }
+        indices[indices.length - 1] = offset;
+        return indices;
+      }
+      /**
+       * normalize axis of range [-r, r) into [0, r).
+       */
+      static normalizeAxis(axis, tensorRank) {
+        if (axis < -tensorRank && axis >= tensorRank) {
+          throw new Error("unsupported axis for this operation.");
+        }
+        return axis < 0 ? axis + tensorRank : axis;
+      }
+      static normalizeAxes(axes, tensorRank) {
+        return axes.map((x) => this.normalizeAxis(x, tensorRank));
+      }
+      // Increment an index into a tensor (in lexicographic
+      // ordering), wrapping around the specified upper_bound.
+      /**
+       * Increment an index into a tensor (in lexicographic ordering), wrapping around the specified upper_bound.
+       * @param index Given index to increment (Will be mutated)
+       * @param dims The dimensions of the tensor for which the given index corresponds to
+       * @param axisToIncrementOn The 1-indexed axis to increment on. If undefined, axisToIncrementOn == rank
+       */
+      static incrementIndex(index, dims, axisToIncrementOn) {
+        if (dims.length === 0 || index.length === 0) {
+          throw new Error("Index incrementing unsupported for scalar Tensor");
+        }
+        if (axisToIncrementOn === void 0) {
+          axisToIncrementOn = dims.length;
+        } else {
+          if (axisToIncrementOn <= 0 || axisToIncrementOn > dims.length) {
+            throw new Error("Incorrect axis to increment on");
+          }
+        }
+        for (let k = axisToIncrementOn - 1; k >= 0; --k) {
+          index[k]++;
+          if (index[k] < dims[k]) {
+            break;
+          }
+          index[k] = 0;
+        }
+      }
+      /**
+       * Produces a new dimensions array based on the values in the 'originalDimensions' and 'shape' array
+       * Used in Reshape
+       * @param originalDims Original Shape array
+       * @param shapeHints array containing values to compute the new dimensions
+       * For example:
+       * originalDims = [2,2] and shapeHints = [0,-1] will return [2,2]
+       * originalDims = [2,2] and shapeHints = [4] will return [4]
+       * originalDims = [2,2] and shapeHints = [5] will throw an exception
+       * https://github.com/onnx/onnx/blob/main/docs/Operators.md#Reshape
+       */
+      static calculateReshapedDims(originalDims, shapeHints) {
+        if (shapeHints.length === 0) {
+          if (originalDims.length === 0 || _ShapeUtil.size(originalDims) === 1) {
+            return [];
+          } else {
+            throw new Error("cannot reshape to a scalar Tensor");
+          }
+        }
+        const nDims = shapeHints.length;
+        const reshapedDims = new Array(nDims);
+        let unknownDimension = -1;
+        let newTensorSize = 1;
+        for (let i = 0; i < nDims; i++) {
+          if (shapeHints[i] < -1) {
+            throw new Error("a dimension in shape hints cannot be less than -1");
+          }
+          if (shapeHints[i] === -1) {
+            if (unknownDimension !== -1) {
+              throw new Error("at most one dimension in shape hints can be -1");
+            }
+            unknownDimension = i;
+          } else {
+            if (shapeHints[i] === 0) {
+              if (i >= originalDims.length) {
+                throw new Error("the dimension with value zero exceeds the dimension size of the input tensor");
+              }
+              reshapedDims[i] = originalDims[i];
+            } else {
+              reshapedDims[i] = shapeHints[i];
+            }
+            newTensorSize *= reshapedDims[i];
+          }
+        }
+        const oldTensorSize = _ShapeUtil.size(originalDims);
+        if (unknownDimension !== -1) {
+          if (oldTensorSize % newTensorSize !== 0) {
+            throw new Error(
+              `the input tensor cannot be reshaped to the requested shape. Input shape: [${originalDims}] Output shape: [${shapeHints}]`
+            );
+          }
+          reshapedDims[unknownDimension] = oldTensorSize / newTensorSize;
+        } else {
+          if (newTensorSize !== oldTensorSize) {
+            throw new Error("reshapedDims and originalDims don't have matching sizes");
+          }
+        }
+        return reshapedDims;
+      }
+      /**
+       * Sorts a given array based on the indices in the Perm array
+       * Used in Transpose
+       * @param a Array to be sorted such as dims or strides
+       * @param perm Perm given; if null a will be reversed
+       */
+      static sortBasedOnPerm(a, perm) {
+        if (perm) {
+          return perm.map((v) => a[v]);
+        } else {
+          return a.slice().reverse();
+        }
+      }
+      /**
+       * Pads a given shape according to the padding values
+       * @param dims shape of the Tensor to be padded
+       * @param pad pad values
+       */
+      static padShape(dims, pad) {
+        const rank = dims.length;
+        return dims.map((v, i) => v + pad[i] + pad[i + rank]);
+      }
+      /**
+       * Determines if the two shapes are identical
+       * @param shape1
+       * @param shape2
+       */
+      static areEqual(shape1, shape2) {
+        if (shape1.length !== shape2.length) {
+          return false;
+        }
+        return shape1.every((v, i) => v === shape2[i]);
+      }
+      /**
+       * Validates if the given `dims` or `shape` is valid in ONNX.js context and returns data size
+       * @param dims - input `dims` that needs to be checked
+       */
+      static validateDimsAndCalcSize(dims) {
+        if (dims.length > 6) {
+          throw new TypeError("Only rank 0 to 6 is supported for tensor shape.");
+        }
+        let size = 1;
+        for (const n of dims) {
+          if (!Number.isInteger(n)) {
+            throw new TypeError(`Invalid shape: ${n} is not an integer`);
+          }
+          if (n < 0 || n > 2147483647) {
+            throw new TypeError(`Invalid shape: length ${n} is not allowed`);
+          }
+          size *= n;
+        }
+        return size;
+      }
+      /**
+       * Determines the shape of output tensor y = flatten(x, axis)
+       * @param dims - shape of input tensor
+       * @param axis - flatten axis, in the range [-r, r]
+       */
+      static flattenShape(dims, axis) {
+        if (axis < 0) {
+          axis += dims.length;
+        }
+        const total = dims.reduce((x, y) => x * y, 1);
+        const right = dims.slice(axis).reduce((x, y) => x * y, 1);
+        const outputDims = [total / right, right];
+        return outputDims;
+      }
+      /**
+       * Determines the shape of output tensor y = squeeze(x, axes)
+       * @param dims - shape of input tensor
+       * @param axes - squeeze axes
+       */
+      static squeezeShape(dims, axes) {
+        const outputDims = new Array();
+        axes = _ShapeUtil.normalizeAxes(axes, dims.length);
+        for (let i = 0; i < dims.length; i++) {
+          const inSqueezeList = axes.indexOf(i) >= 0;
+          if (inSqueezeList && dims[i] !== 1) {
+            throw new Error("squeeze an axis of size different than 1");
+          }
+          if (axes.length === 0 && dims[i] > 1 || axes.length > 0 && !inSqueezeList) {
+            outputDims.push(dims[i]);
+          }
+        }
+        return outputDims;
+      }
+      /**
+       * Determines the shape of output tensor y = unsqueeze(x, axes)
+       * @param dims - shape of input tensor
+       * @param axes - unsqueeze axes
+       */
+      static unsqueezeShape(dims, axes) {
+        const outputDims = new Array(dims.length + axes.length);
+        outputDims.fill(0);
+        for (let i = 0; i < axes.length; i++) {
+          const axis = _ShapeUtil.normalizeAxis(axes[i], outputDims.length);
+          if (axis >= outputDims.length) {
+            throw new Error("'axes' has an out of range axis");
+          }
+          if (outputDims[axis] !== 0) {
+            throw new Error("'axes' has a duplicate axis");
+          }
+          outputDims[axis] = 1;
+        }
+        let inputDimsIterator = 0;
+        for (let i = 0; i < outputDims.length; i++) {
+          if (outputDims[i] === 0) {
+            outputDims[i] = dims[inputDimsIterator++];
+          }
+        }
+        if (inputDimsIterator !== dims.length) {
+          throw new Error("the unsqueezed dimension could not be established");
+        }
+        return outputDims;
+      }
+    };
+    SplitUtil = class _SplitUtil {
+      /**
+       * Calculates new Shapes from existing one and the splits given along the axis provides
+       * @param dims Shape of the Tensor to be splitted into two or more Shapes
+       * @param axis The dimension along which the Tensor will be split
+       * @param splits Offsets for the start of each split
+       */
+      static splitShape(dims, axis, split2, numOutputs) {
+        if (split2.length === 0) {
+          if (!numOutputs) {
+            throw new Error("need to know number of outputs when the 'split' attribute is not specified");
+          }
+          _SplitUtil.determineSplit(dims[axis], numOutputs, split2);
+        }
+        const shapes = [];
+        const offsets = [0];
+        for (let i = 0; i < split2.length; ++i) {
+          if (i !== 0) {
+            offsets.push(offsets[i - 1] + split2[i - 1]);
+          }
+          const shape2 = dims.slice();
+          shape2[axis] = split2[i];
+          shapes.push(shape2);
+        }
+        return [shapes, offsets];
+      }
+      static determineSplit(numElementsAlongAxis, numOutputs, split2) {
+        if (numElementsAlongAxis % numOutputs !== 0) {
+          throw new Error("cannot split tensor to equal sized parts");
+        }
+        for (let i = 0; i < numOutputs; ++i) {
+          split2.push(numElementsAlongAxis / numOutputs);
+        }
+      }
+    };
+    PoolConvUtil = class _PoolConvUtil {
+      /**
+       * Adjust the kernel, strides, pads to correct rank. Set to default value if not present
+       * @param isGlobalOperator If true, perform global pooling.
+       * @param inputDims The input tensor dimension.
+       * @param kernelShape The size of the kernel along each axis.
+       * @param strides Stride along each axis.
+       * @param dilations Dilation along each axis.
+       * @param pads Padding for the beginning and ending along each axis.
+       */
+      static adjustPoolAttributes(isGlobalOperator, inputDims, kernelShape, strides, dilations, pads) {
+        if (!isGlobalOperator && kernelShape.length !== inputDims.length - 2) {
+          throw new Error("length of specified kernel shapes should be 2 less than length of input dimensions");
+        }
+        if (isGlobalOperator) {
+          for (let dim = 0; dim < inputDims.length - 2; dim++) {
+            if (dim >= kernelShape.length) {
+              kernelShape.push(inputDims[dim + 2]);
+            } else {
+              kernelShape[dim] = inputDims[dim + 2];
+            }
+          }
+        }
+        for (let dim = 0; dim < kernelShape.length; dim++) {
+          if (dim < strides.length) {
+            if (strides[dim] < 0) {
+              throw new Error("strides should be greater than or equal to 1");
+            }
+          } else {
+            strides.push(1);
+          }
+        }
+        for (let dim = 0; dim < kernelShape.length; dim++) {
+          if (dim < dilations.length) {
+            if (dilations[dim] < 0) {
+              throw new Error("dilations should be greater than or equal to 1");
+            }
+          } else {
+            dilations.push(1);
+          }
+        }
+        for (let dim = 0; dim < kernelShape.length * 2; dim++) {
+          if (dim < pads.length) {
+            if (pads[dim] < 0) {
+              throw new Error("pad should be greater than or equal to 1");
+            }
+          } else {
+            pads.push(0);
+          }
+        }
+        for (let dim = 0; dim < kernelShape.length; dim++) {
+          if (kernelShape[dim] <= 0) {
+            throw new Error("kernel shapes need to be greater than 0");
+          }
+          if (pads[dim] >= kernelShape[dim] || pads[dim + kernelShape.length] >= kernelShape[dim]) {
+            throw new Error("pads should be smaller than kernel");
+          }
+        }
+      }
+      // adjust pad values based on 'autoPad' attribute
+      static adjustPadsBasedOnAutoPad(inputDims, strides, dilations, kernelShape, pads, autoPad) {
+        if (!autoPad) {
+          return;
+        }
+        if (pads.length !== 2 * (inputDims.length - 2)) {
+          throw new Error("length of pads should be twice the length of data dimensions");
+        }
+        if (strides.length !== inputDims.length - 2) {
+          throw new Error("length of strides should be the length of data dimensions");
+        }
+        if (kernelShape.length !== inputDims.length - 2) {
+          throw new Error("length of kernel shapes should be the length of data dimensions");
+        }
+        for (let dim = 0; dim < inputDims.length - 2; dim++) {
+          _PoolConvUtil.adjustPadAndReturnShape(
+            inputDims[dim + 2],
+            strides[dim],
+            dilations[dim],
+            kernelShape[dim],
+            pads,
+            dim,
+            dim + inputDims.length - 2,
+            autoPad
+          );
+        }
+      }
+      /**
+       * Calculate the output shape for Pool ops based on input attributes. (Should be used only for Pool ops)
+       * @param isGlobalOperator If true, perform global pooling.
+       * @param inputDims The input tensor dimension. (inputs[0].dims)
+       * @param strides Stride along each axis.
+       * @param dilations Dilation along each axis.
+       * @param kernelShape The size of the kernel along each axis.
+       * @param pads Padding for the beginning and ending along each axis.
+       * @param autoPad DEPRECATED attribute supported for legacy models. Specifies how to implicitly calculate pads in each
+       *     dimension. Can take values NOTSET, SAME_UPPER, SAME_LOWER, or VALID.
+       * @param ceilMode When set to 1, use ceil() instead of floor() to compute the output spatial size (and apply the
+       *     "shrink the last window if it starts entirely in padding" rule). Defaults to 0 (floor).
+       */
+      static computePoolOutputShape(isGlobalOperator, inputDims, strides, dilations, kernelShape, pads, autoPad, ceilMode = 0) {
+        if (inputDims.length <= 0) {
+          throw new Error("input shape must be of size greater than 0");
+        }
+        const outputDims = [inputDims[0], inputDims[1]];
+        _PoolConvUtil.computeShapeHelper(
+          isGlobalOperator,
+          inputDims,
+          outputDims,
+          strides,
+          dilations,
+          kernelShape,
+          pads,
+          autoPad,
+          ceilMode
+        );
+        return outputDims;
+      }
+      /**
+       * Calculate the output shape for Conv op based on input attributes. (Should be used only for Conv op)
+       * @param inputDims The input tensor dimension. (inputs[0].dims)
+       * @param filterDims The filter tensor dimension. (inputs[1].dims)
+       * @param strides Stride along each axis.
+       * @param kernelShape The size of the kernel along each axis.
+       * @param pads Padding for the beginning and ending along each axis.
+       * @param autoPad DEPRECATED attribute supported for legacy models. Specifies how to implicitly calculate pads in each
+       *     dimension. Can take values NOTSET, SAME_UPPER, SAME_LOWER, or VALID.
+       */
+      static computeConvOutputShape(inputDims, filterDims, strides, dilations, kernelShape, pads, autoPad) {
+        if (inputDims.length <= 0 || filterDims.length <= 0) {
+          throw new Error("invalid input tensor dims or invalid filter tensor dims");
+        }
+        const outputDims = [inputDims[0], filterDims[0]];
+        _PoolConvUtil.computeShapeHelper(false, inputDims, outputDims, strides, dilations, kernelShape, pads, autoPad);
+        return outputDims;
+      }
+      // will compute output shapes for data dimensions ONLY (i.e.) no batch size and channels
+      // called by computePoolOutputShape() and computeConvOutputShape()
+      // adjust pads based on 'autoPad' attribute prior to shape computation
+      static computeShapeHelper(isGlobalOperator, inputDims, outputDims, strides, dilations, kernelShape, pads, autoPad, ceilMode = 0) {
+        if (isGlobalOperator) {
+          for (let dim = 0; dim < inputDims.length - 2; dim++) {
+            outputDims.push(1);
+          }
+        } else {
+          for (let dim = 0; dim < inputDims.length - 2; dim++) {
+            outputDims.push(
+              _PoolConvUtil.adjustPadAndReturnShape(
+                inputDims[dim + 2],
+                strides[dim],
+                dilations[dim],
+                kernelShape[dim],
+                pads,
+                dim,
+                dim + inputDims.length - 2,
+                autoPad,
+                ceilMode
+              )
+            );
+          }
+        }
+      }
+      // Computes the output spatial size for a single dimension.
+      // Produces results identical to the C++ PoolAttributes::ComputeOutputSize
+      // (onnxruntime/core/providers/cpu/nn/pool_attributes.h), including the ceil_mode
+      // "shrink the last window if it starts entirely in the trailing padding" rule. The JS
+      // signature takes a pre-computed `numerator` (equal to `inSize + padHead + padTail - dkernel`,
+      // matching the C++ `in_size + pad_head + pad_tail - dilation * (kernel - 1) - 1`) instead of
+      // the raw pooling attributes, but the computed output size is the same.
+      // Keep in sync with the onnxjs/jsep copy.
+      // NOTE: In this onnxjs copy the ceilMode path exists for shape-test parity with the jsep copy;
+      // the onnxjs WebGL pooling caller (backends/webgl/ops/pool.ts) intentionally does NOT pass
+      // ceilMode (legacy path still throws on ceil_mode != 0), so it always uses the floor default.
+      static computeOutputSize(numerator, stride, inSize, padHead, ceilMode) {
+        let outSize = Math.floor(numerator / stride) + 1;
+        if (ceilMode === 1) {
+          outSize = Math.ceil(numerator / stride) + 1;
+          if ((outSize - 1) * stride >= inSize + padHead) {
+            outSize -= 1;
+          }
+        }
+        return outSize;
+      }
+      // helper for computeShapeHelper() and adjustPadsBasedOnAutoPad()
+      // adjusts pad value for given 'autoPad' string and computes output shape along a particular dimension
+      static adjustPadAndReturnShape(inSize, stride, dilation, kernel, pads, padHeadIndex, padTailIndex, autoPad, ceilMode = 0) {
+        const dkernel = dilation * (kernel - 1) + 1;
+        if (autoPad && autoPad !== "NOTSET") {
+          switch (autoPad) {
+            case "VALID":
+              pads[padHeadIndex] = 0;
+              pads[padTailIndex] = 0;
+              return _PoolConvUtil.computeOutputSize(inSize - dkernel, stride, inSize, 0, ceilMode);
+            case "SAME_LOWER":
+            case "SAME_UPPER":
+              if (dilation !== 1) {
+                throw new Error("Dilation not supported for SAME_UPPER or SAME_LOWER");
+              } else {
+                const legacyTargetSize = Math.floor((inSize + stride - 1) / stride);
+                const padNeeded = (legacyTargetSize - 1) * stride + kernel - inSize;
+                pads[padHeadIndex] = autoPad === "SAME_LOWER" ? Math.floor((padNeeded + 1) / 2) : Math.floor(padNeeded / 2);
+                pads[padTailIndex] = padNeeded - pads[padHeadIndex];
+                return _PoolConvUtil.computeOutputSize(
+                  inSize + pads[padHeadIndex] + pads[padTailIndex] - dkernel,
+                  stride,
+                  inSize,
+                  pads[padHeadIndex],
+                  ceilMode
+                );
+              }
+            default:
+              throw new Error("Unsupported AutoPad type");
+          }
+        } else {
+          return _PoolConvUtil.computeOutputSize(
+            inSize + pads[padHeadIndex] + pads[padTailIndex] - dkernel,
+            stride,
+            inSize,
+            pads[padHeadIndex],
+            ceilMode
+          );
+        }
+      }
+    };
+    MIN_CLIP = -34028234663852886e22;
+    MAX_CLIP = 34028234663852886e22;
+  }
+});
+
+// web/lib/onnxjs/tensor.ts
+function sizeof(type) {
+  switch (type) {
+    case "bool":
+    case "int8":
+    case "uint8":
+      return 1;
+    case "int16":
+    case "uint16":
+      return 2;
+    case "int32":
+    case "uint32":
+    case "float32":
+      return 4;
+    case "float64":
+      return 8;
+    default:
+      throw new Error(`cannot calculate sizeof() on type ${type}`);
+  }
+}
+function sizeofProto(type) {
+  switch (type) {
+    case import_onnx2.onnx.TensorProto.DataType.UINT8:
+    case import_onnx2.onnx.TensorProto.DataType.INT8:
+    case import_onnx2.onnx.TensorProto.DataType.BOOL:
+      return 1;
+    case import_onnx2.onnx.TensorProto.DataType.UINT16:
+    case import_onnx2.onnx.TensorProto.DataType.INT16:
+      return 2;
+    case import_onnx2.onnx.TensorProto.DataType.FLOAT:
+    case import_onnx2.onnx.TensorProto.DataType.INT32:
+    case import_onnx2.onnx.TensorProto.DataType.UINT32:
+      return 4;
+    case import_onnx2.onnx.TensorProto.DataType.INT64:
+    case import_onnx2.onnx.TensorProto.DataType.DOUBLE:
+    case import_onnx2.onnx.TensorProto.DataType.UINT64:
+      return 8;
+    default:
+      throw new Error(`cannot calculate sizeof() on type ${import_onnx2.onnx.TensorProto.DataType[type]}`);
+  }
+}
+function createView(dataBuffer, type) {
+  return new (dataviewConstructor(type))(dataBuffer);
+}
+function dataviewConstructor(type) {
+  switch (type) {
+    case "bool":
+    case "uint8":
+      return Uint8Array;
+    case "int8":
+      return Int8Array;
+    case "int16":
+      return Int16Array;
+    case "uint16":
+      return Uint16Array;
+    case "int32":
+      return Int32Array;
+    case "uint32":
+      return Uint32Array;
+    case "int64":
+      return BigInt64Array;
+    case "float32":
+      return Float32Array;
+    case "float64":
+      return Float64Array;
+    default:
+      throw new Error("unspecified error");
+  }
+}
+function longToNumber(i, type) {
+  if (type === import_onnx2.onnx.TensorProto.DataType.INT64 || type === import_tensor_data_type.TensorDataType.INT64) {
+    if (i.greaterThanOrEqual(2147483648) || i.lessThan(-2147483648)) {
+      throw new TypeError("int64 is not supported");
+    }
+  } else if (type === import_onnx2.onnx.TensorProto.DataType.UINT32 || type === import_tensor_data_type.TensorDataType.UINT32 || type === import_onnx2.onnx.TensorProto.DataType.UINT64 || type === import_tensor_data_type.TensorDataType.UINT64) {
+    if (i.greaterThanOrEqual(4294967296) || i.lessThan(0)) {
+      throw new TypeError("uint64 is not supported");
+    }
+  } else {
+    throw new TypeError(`not a LONG type: ${import_onnx2.onnx.TensorProto.DataType[type]}`);
+  }
+  return i.toNumber();
+}
+function readProto(view, type, byteOffset) {
+  switch (type) {
+    case import_onnx2.onnx.TensorProto.DataType.BOOL:
+    case import_onnx2.onnx.TensorProto.DataType.UINT8:
+      return view.getUint8(byteOffset);
+    case import_onnx2.onnx.TensorProto.DataType.INT8:
+      return view.getInt8(byteOffset);
+    case import_onnx2.onnx.TensorProto.DataType.UINT16:
+      return view.getUint16(byteOffset, true);
+    case import_onnx2.onnx.TensorProto.DataType.INT16:
+      return view.getInt16(byteOffset, true);
+    case import_onnx2.onnx.TensorProto.DataType.FLOAT:
+      return view.getFloat32(byteOffset, true);
+    case import_onnx2.onnx.TensorProto.DataType.INT32:
+      return view.getInt32(byteOffset, true);
+    case import_onnx2.onnx.TensorProto.DataType.UINT32:
+      return view.getUint32(byteOffset, true);
+    case import_onnx2.onnx.TensorProto.DataType.INT64:
+      return longToNumber(
+        long_default.fromBits(view.getUint32(byteOffset, true), view.getUint32(byteOffset + 4, true), false),
+        type
+      );
+    case import_onnx2.onnx.TensorProto.DataType.DOUBLE:
+      return view.getFloat64(byteOffset, true);
+    case import_onnx2.onnx.TensorProto.DataType.UINT64:
+      return longToNumber(
+        long_default.fromBits(view.getUint32(byteOffset, true), view.getUint32(byteOffset + 4, true), true),
+        type
+      );
+    default:
+      throw new Error(`cannot read from DataView for type ${import_onnx2.onnx.TensorProto.DataType[type]}`);
+  }
+}
+var import_guid_typescript, import_onnx2, Tensor4;
+var init_tensor2 = __esm({
+  "web/lib/onnxjs/tensor.ts"() {
+    "use strict";
+    import_guid_typescript = __toESM(require_guid());
+    init_long();
+    init_ort_generated();
+    import_onnx2 = __toESM(require_onnx());
+    init_util();
+    Tensor4 = class _Tensor {
+      constructor(dims, type, dataProvider, asyncDataProvider, cache2, dataId = import_guid_typescript.Guid.create()) {
+        this.dims = dims;
+        this.type = type;
+        this.dataProvider = dataProvider;
+        this.asyncDataProvider = asyncDataProvider;
+        this.cache = cache2;
+        this.dataId = dataId;
+        this.size = ShapeUtil.validateDimsAndCalcSize(dims);
+        const size = this.size;
+        const empty = dataProvider === void 0 && asyncDataProvider === void 0 && cache2 === void 0;
+        if (cache2 !== void 0) {
+          if (cache2.length !== size) {
+            throw new RangeError("Input dims doesn't match data length.");
+          }
+        }
+        if (type === "string") {
+          if (cache2 !== void 0 && (!Array.isArray(cache2) || !cache2.every((i) => typeof i === "string"))) {
+            throw new TypeError("cache should be a string array");
+          }
+          if (empty) {
+            this.cache = new Array(size);
+          }
+        } else {
+          if (cache2 !== void 0) {
+            const constructor = dataviewConstructor(type);
+            if (!(cache2 instanceof constructor)) {
+              throw new TypeError(`cache should be type ${constructor.name}`);
+            }
+          }
+          if (empty) {
+            const buf = new ArrayBuffer(size * sizeof(type));
+            this.cache = createView(buf, type);
+          }
+        }
+      }
+      /**
+       * get the underlying tensor data
+       */
+      get data() {
+        if (this.cache === void 0) {
+          const data = this.dataProvider(this.dataId);
+          if (data.length !== this.size) {
+            throw new Error("Length of data provided by the Data Provider is inconsistent with the dims of this Tensor.");
+          }
+          this.cache = data;
+        }
+        return this.cache;
+      }
+      /**
+       * get the underlying string tensor data. Should only use when type is STRING
+       */
+      get stringData() {
+        if (this.type !== "string") {
+          throw new TypeError("data type is not string");
+        }
+        return this.data;
+      }
+      /**
+       * get the underlying integer tensor data. Should only use when type is one of the following: (UINT8, INT8, UINT16,
+       * INT16, INT32, UINT32, BOOL)
+       */
+      get integerData() {
+        switch (this.type) {
+          case "uint8":
+          case "int8":
+          case "uint16":
+          case "int16":
+          case "int32":
+          case "uint32":
+          case "bool":
+            return this.data;
+          default:
+            throw new TypeError("data type is not integer (uint8, int8, uint16, int16, int32, uint32, bool)");
+        }
+      }
+      /**
+       * get the underlying float tensor data. Should only use when type is one of the following: (FLOAT, DOUBLE)
+       */
+      get floatData() {
+        switch (this.type) {
+          case "float32":
+          case "float64":
+            return this.data;
+          default:
+            throw new TypeError("data type is not float (float32, float64)");
+        }
+      }
+      /**
+       * get the underlying number tensor data. Should only use when type is one of the following: (UINT8, INT8, UINT16,
+       * INT16, INT32, UINT32, BOOL, FLOAT, DOUBLE)
+       */
+      get numberData() {
+        if (this.type !== "string") {
+          return this.data;
+        }
+        throw new TypeError("type cannot be non-number (string)");
+      }
+      /**
+       * get value of an element at the given indices
+       */
+      get(indices) {
+        return this.data[ShapeUtil.indicesToOffset(indices, this.strides)];
+      }
+      /**
+       * set value of an element at the given indices
+       */
+      set(indices, value) {
+        this.data[ShapeUtil.indicesToOffset(indices, this.strides)] = value;
+      }
+      /**
+       * get the underlying tensor data asynchronously
+       */
+      async getData() {
+        if (this.cache === void 0) {
+          this.cache = await this.asyncDataProvider(this.dataId);
+        }
+        return this.cache;
+      }
+      /**
+       * get the strides for each dimension
+       */
+      get strides() {
+        if (!this._strides) {
+          this._strides = ShapeUtil.computeStrides(this.dims);
+        }
+        return this._strides;
+      }
+      /**
+       * Construct new Tensor from a ONNX Tensor object
+       * @param tensorProto the ONNX Tensor
+       */
+      static fromProto(tensorProto) {
+        if (!tensorProto) {
+          throw new Error("cannot construct Value from an empty tensor");
+        }
+        const type = ProtoUtil.tensorDataTypeFromProto(tensorProto.dataType);
+        const dims = ProtoUtil.tensorDimsFromProto(tensorProto.dims);
+        const value = new _Tensor(dims, type);
+        if (type === "string") {
+          tensorProto.stringData.forEach((str, i) => {
+            value.data[i] = decodeUtf8String(str);
+          });
+        } else if (tensorProto.rawData && typeof tensorProto.rawData.byteLength === "number" && tensorProto.rawData.byteLength > 0) {
+          const dataDest = value.data;
+          const dataSource = new DataView(
+            tensorProto.rawData.buffer,
+            tensorProto.rawData.byteOffset,
+            tensorProto.rawData.byteLength
+          );
+          const elementSize = sizeofProto(tensorProto.dataType);
+          const length = tensorProto.rawData.byteLength / elementSize;
+          if (tensorProto.rawData.byteLength % elementSize !== 0) {
+            throw new Error("invalid buffer length");
+          }
+          if (dataDest.length !== length) {
+            throw new Error("buffer length mismatch");
+          }
+          for (let i = 0; i < length; i++) {
+            const n = readProto(dataSource, tensorProto.dataType, i * elementSize);
+            dataDest[i] = n;
+          }
+        } else {
+          let array;
+          switch (tensorProto.dataType) {
+            case import_onnx2.onnx.TensorProto.DataType.FLOAT:
+              array = tensorProto.floatData;
+              break;
+            case import_onnx2.onnx.TensorProto.DataType.INT32:
+            case import_onnx2.onnx.TensorProto.DataType.INT16:
+            case import_onnx2.onnx.TensorProto.DataType.UINT16:
+            case import_onnx2.onnx.TensorProto.DataType.INT8:
+            case import_onnx2.onnx.TensorProto.DataType.UINT8:
+            case import_onnx2.onnx.TensorProto.DataType.BOOL:
+              array = tensorProto.int32Data;
+              break;
+            case import_onnx2.onnx.TensorProto.DataType.INT64:
+              array = tensorProto.int64Data;
+              break;
+            case import_onnx2.onnx.TensorProto.DataType.DOUBLE:
+              array = tensorProto.doubleData;
+              break;
+            case import_onnx2.onnx.TensorProto.DataType.UINT32:
+            case import_onnx2.onnx.TensorProto.DataType.UINT64:
+              array = tensorProto.uint64Data;
+              break;
+            default:
+              throw new Error("unspecific error");
+          }
+          if (array === null || array === void 0) {
+            throw new Error("failed to populate data from a tensorproto value");
+          }
+          const data = value.data;
+          if (data.length !== array.length) {
+            throw new Error("array length mismatch");
+          }
+          for (let i = 0; i < array.length; i++) {
+            const element = array[i];
+            if (long_default.isLong(element)) {
+              data[i] = longToNumber(element, tensorProto.dataType);
+            } else {
+              data[i] = element;
+            }
+          }
+        }
+        return value;
+      }
+      /**
+       * Construct new Tensor from raw data
+       * @param data the raw data object. Should be a string array for 'string' tensor, and the corresponding typed array
+       * for other types of tensor.
+       * @param dims the dimensions of the tensor
+       * @param type the type of the tensor
+       */
+      static fromData(data, dims, type) {
+        return new _Tensor(dims, type, void 0, void 0, data);
+      }
+      static fromOrtTensor(ortTensor) {
+        if (!ortTensor) {
+          throw new Error("cannot construct Value from an empty tensor");
+        }
+        const dims = ProtoUtil.tensorDimsFromORTFormat(ortTensor);
+        const type = ProtoUtil.tensorDataTypeFromProto(ortTensor.dataType());
+        const value = new _Tensor(dims, type);
+        if (type === "string") {
+          for (let i = 0; i < ortTensor.stringDataLength(); i++) {
+            value.data[i] = ortTensor.stringData(i);
+          }
+        } else if (ortTensor.rawDataArray() && typeof ortTensor.rawDataLength() === "number" && ortTensor.rawDataLength() > 0) {
+          const dataDest = value.data;
+          const dataSource = new DataView(
+            ortTensor.rawDataArray().buffer,
+            ortTensor.rawDataArray().byteOffset,
+            ortTensor.rawDataLength()
+          );
+          const elementSize = sizeofProto(ortTensor.dataType());
+          const length = ortTensor.rawDataLength() / elementSize;
+          if (ortTensor.rawDataLength() % elementSize !== 0) {
+            throw new Error("invalid buffer length");
+          }
+          if (dataDest.length !== length) {
+            throw new Error("buffer length mismatch");
+          }
+          for (let i = 0; i < length; i++) {
+            const n = readProto(dataSource, ortTensor.dataType(), i * elementSize);
+            dataDest[i] = n;
+          }
+        }
+        return value;
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/glsl-source.ts
+function getGlsl(version3) {
+  return version3 === 1 ? GLSL_ES_2_0 : GLSL_ES_3_0;
+}
+function getVertexShaderSource(version3) {
+  const glsl = getGlsl(version3);
+  return `${glsl.version}
+      precision highp float;
+      ${glsl.attribute} vec3 position;
+      ${glsl.attribute} vec2 textureCoord;
+
+      ${glsl.varyingVertex} vec2 TexCoords;
+
+      void main()
+      {
+          gl_Position = vec4(position, 1.0);
+          TexCoords = textureCoord;
+      }`;
+}
+function getFragShaderPreamble(version3) {
+  const glsl = getGlsl(version3);
+  return `${glsl.version}
+    precision highp float;
+    precision highp int;
+    precision highp sampler2D;
+    ${glsl.varyingFrag} vec2 TexCoords;
+    ${glsl.outputDeclaration}
+    const vec2 halfCR = vec2(0.5, 0.5);
+
+    // Custom vector types to handle higher dimenalities.
+    struct ivec5
+    {
+      int x;
+      int y;
+      int z;
+      int w;
+      int u;
+    };
+
+    struct ivec6
+    {
+      int x;
+      int y;
+      int z;
+      int w;
+      int u;
+      int v;
+    };
+
+    int imod(int x, int y) {
+      return x - y * (x / y);
+    }
+
+    `;
+}
+function getDefaultFragShaderMain(version3, outputShapeLength) {
+  const glsl = getGlsl(version3);
+  return `
+  void main() {
+    int indices[${outputShapeLength}];
+    toVec(TexCoords, indices);
+    vec4 result = vec4(process(indices));
+    ${glsl.output} = result;
+  }
+  `;
+}
+var GLSL_ES_2_0, GLSL_ES_3_0;
+var init_glsl_source = __esm({
+  "web/lib/onnxjs/backends/webgl/glsl-source.ts"() {
+    "use strict";
+    GLSL_ES_2_0 = {
+      version: "",
+      attribute: "attribute",
+      varyingVertex: "varying",
+      varyingFrag: "varying",
+      texture2D: "texture2D",
+      output: "gl_FragColor",
+      outputDeclaration: ""
+    };
+    GLSL_ES_3_0 = {
+      version: "#version 300 es",
+      attribute: "in",
+      varyingVertex: "out",
+      varyingFrag: "in",
+      texture2D: "texture",
+      output: "outputColor",
+      outputDeclaration: "out vec4 outputColor;"
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/types.ts
+var init_types = __esm({
+  "web/lib/onnxjs/backends/webgl/types.ts"() {
+    "use strict";
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/utils.ts
+async function repeatedTry(checkFn, delayFn = (_counter) => 0, maxCounter) {
+  return new Promise((resolve, reject) => {
+    let tryCount = 0;
+    const tryFn = () => {
+      if (checkFn()) {
+        resolve();
+        return;
+      }
+      tryCount++;
+      const nextBackoff = delayFn(tryCount);
+      if (maxCounter != null && tryCount >= maxCounter) {
+        reject();
+        return;
+      }
+      setTimeout(tryFn, nextBackoff);
+    };
+    tryFn();
+  });
+}
+function generateShaderFuncNameFromInputSamplerName(samplerName) {
+  assert(typeof samplerName !== "undefined" && samplerName.length !== 0, () => "empty string found for sampler name");
+  return "get" + samplerName.charAt(0).toUpperCase() + samplerName.slice(1);
+}
+function generateShaderFuncNameFromInputSamplerNameAtOutCoords(samplerName) {
+  assert(typeof samplerName !== "undefined" && samplerName.length !== 0, () => "empty string found for sampler name");
+  return "get" + samplerName.charAt(0).toUpperCase() + samplerName.slice(1) + "AtOutCoords";
+}
+function squeezeInputShape(inputShape, squeezedShape) {
+  let newInputShape = JSON.parse(JSON.stringify(inputShape));
+  newInputShape = squeezedShape;
+  return newInputShape;
+}
+function getSqueezedParams(params, keptDims) {
+  return keptDims.map((d) => params[d]).join(", ");
+}
+function getCoordsDataType(rank) {
+  if (rank <= 1) {
+    return "int";
+  } else if (rank === 2) {
+    return "ivec2";
+  } else if (rank === 3) {
+    return "ivec3";
+  } else if (rank === 4) {
+    return "ivec4";
+  } else if (rank === 5) {
+    return "ivec5";
+  } else if (rank === 6) {
+    return "ivec6";
+  } else {
+    throw Error(`GPU for rank ${rank} is not yet supported`);
+  }
+}
+function getGlChannels(rank = 6) {
+  return ["x", "y", "z", "w", "u", "v"].slice(0, rank);
+}
+var init_utils = __esm({
+  "web/lib/onnxjs/backends/webgl/utils.ts"() {
+    "use strict";
+    init_util();
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/packing-utils.ts
+function getVecChannels(name2, rank) {
+  return getGlChannels(rank).map((d) => `${name2}.${d}`);
+}
+function getChannels(name2, rank) {
+  if (rank === 1) {
+    return [name2];
+  }
+  return getVecChannels(name2, rank);
+}
+function unpackFromChannel() {
+  return `
+    float getChannel(vec4 frag, int dim) {
+      int modCoord = imod(dim, 2);
+      return modCoord == 0 ? frag.r : frag.g;
+    }
+
+    float getChannel(vec4 frag, vec2 innerDims) {
+      vec2 modCoord = mod(innerDims, 2.);
+      return modCoord.x == 0. ?
+        (modCoord.y == 0. ? frag.r : frag.g) :
+        (modCoord.y == 0. ? frag.b : frag.a);
+    }
+  `;
+}
+var init_packing_utils = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/packing-utils.ts"() {
+    "use strict";
+    init_utils();
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/pack.ts
+function getOutOfBoundsCondition(rank, shape2, dims) {
+  if (rank === 0) {
+    return "false";
+  }
+  if (rank === 1) {
+    return `rc > ${shape2[0]}`;
+  }
+  let cond = "";
+  for (let i = rank - 2; i < rank; i++) {
+    cond += `${dims[i]} >= ${shape2[i - rank + 2]}`;
+    if (i < rank - 1) {
+      cond += "||";
+    }
+  }
+  return cond;
+}
+function getOutput(shape2, dims) {
+  const rank = shape2.length;
+  if (rank === 0) {
+    return "getA(), 0, 0, 0";
+  }
+  if (rank === 1) {
+    return `getA(rc),
+            rc + 1 >= ${shape2[0]} ? 0. : getA(rc + 1),
+            0, 0`;
+  }
+  const coord00 = "r, c";
+  const coord01 = "r, cp1";
+  const coord10 = "rp1, c";
+  const coord11 = "rp1, cp1";
+  let D = "";
+  if (rank > 2) {
+    for (let i = 0; i < rank - 2; ++i) {
+      D = D + `${dims[i]},`;
+    }
+  }
+  return `getA(${D}${coord00}),
+          rEdge ? 0. : getA(${D}${coord10}),
+          cEdge ? 0. : getA(${D}${coord01}),
+          rEdge || cEdge ? 0. : getA(${D}${coord11})`;
+}
+function getSetup(rank, dims, rows, cols) {
+  if (rank === 0 || rank === 1) {
+    return "";
+  } else {
+    const setup = `
+    int r = ${dims[rank - 2]};
+    int c = ${dims[rank - 1]};
+    int rp1 = ${dims[rank - 2]} + 1;
+    int cp1 = ${dims[rank - 1]} + 1;
+    bool rEdge = rp1 >= ${cols};
+    bool cEdge = cp1 >= ${rows};
+    `;
+    return setup;
+  }
+}
+var packProgramMetadata, createPackProgramInfo, createPackProgramInfoLoader;
+var init_pack = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/pack.ts"() {
+    "use strict";
+    init_glsl_source();
+    init_types();
+    init_utils();
+    init_packing_utils();
+    packProgramMetadata = {
+      name: "pack",
+      inputNames: ["A"],
+      inputTypes: [1 /* unpackedReversed */]
+    };
+    createPackProgramInfo = (handler, input) => {
+      const glsl = getGlsl(handler.session.backend.glContext.version);
+      const inputShape = input.dims;
+      const inputRank = inputShape.length;
+      const outputRank = input.dims.length;
+      const coordsDataType = getCoordsDataType(outputRank);
+      const channels = getChannels("rc", outputRank);
+      const setup = getSetup(outputRank, channels, inputShape[inputShape.length - 2], inputShape[inputShape.length - 1]);
+      let reversedInputWH;
+      if (inputRank === 0) {
+        reversedInputWH = [1, 1];
+      } else if (inputRank === 1) {
+        reversedInputWH = [inputShape[0], 1];
+      } else {
+        reversedInputWH = [inputShape[outputRank - 1], inputShape[outputRank - 2]];
+      }
+      const outOfBoundsCondition = getOutOfBoundsCondition(outputRank, reversedInputWH, channels);
+      const output = getOutput(inputShape, channels);
+      const shaderSource = `
+        void main() {
+          ${coordsDataType} rc = getOutputCoords();
+
+          if(${outOfBoundsCondition}) {
+            ${glsl.output} = vec4(0);
+          } else {
+            ${setup}
+
+            ${glsl.output} = vec4(${output});
+          }
+        }
+      `;
+      return {
+        ...packProgramMetadata,
+        hasMain: true,
+        output: { dims: input.dims, type: input.type, textureType: 2 /* packed */ },
+        shaderSource
+      };
+    };
+    createPackProgramInfoLoader = (handler, input) => ({
+      ...packProgramMetadata,
+      get: () => createPackProgramInfo(handler, input)
+    });
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/reshape-packed.ts
+function processDims3D(shape2) {
+  if (shape2.length === 0) {
+    return [1, 1, 1];
+  }
+  let batch = 1;
+  for (let i = 0; i < shape2.length - 2; ++i) {
+    batch *= shape2[i];
+  }
+  return [batch, shape2.length > 1 ? shape2[shape2.length - 2] : 1, shape2[shape2.length - 1]];
+}
+function isReshapeCheap(dims, reshapedDims) {
+  let isCheapReshape = false;
+  if (dims.length === 0 || reshapedDims.length === 0) {
+    isCheapReshape = true;
+  } else if (dims.length < 2 || reshapedDims.length < 2) {
+    isCheapReshape = dims[dims.length - 1] === reshapedDims[reshapedDims.length - 1];
+  } else {
+    isCheapReshape = dims[dims.length - 1] === reshapedDims[reshapedDims.length - 1] && dims[dims.length - 2] === reshapedDims[reshapedDims.length - 2];
+  }
+  return isCheapReshape;
+}
+function getReshapedInputCoords(shape2) {
+  const strides = ShapeUtil.computeStrides(shape2);
+  const coords = ["b", "r", "c"];
+  const index = "index";
+  const coordsFromIndexSnippet = strides.map((stride, i) => {
+    const line1 = `int ${coords[i]} = ${index} / ${stride}`;
+    const line2 = i === strides.length - 1 ? `int ${coords[i + 1]} = ${index} - ${coords[i]} * ${stride}` : `index -= ${coords[i]} * ${stride}`;
+    return `${line1}; ${line2};`;
+  }).join("");
+  return `
+    ivec3 inputCoordsFromReshapedOutCoords(int index) {
+      ${coordsFromIndexSnippet}
+      return ivec3(b, r, c);
+    }
+  `;
+}
+function getFlattenedIndexFrom3D(shape2) {
+  const strides = ShapeUtil.computeStrides(shape2);
+  return `
+  int getFlattenedIndex(ivec3 coords) {
+    // reverse y, z order
+    return coords.x * ${strides[0]} + coords.z * ${strides[1]} + coords.y;
+  }
+`;
+}
+var createPackedReshape3DProgramMetadata, createPackedReshape3DProgramInfo, createPackedReshape3DProgramInfoLoader;
+var init_reshape_packed = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/reshape-packed.ts"() {
+    "use strict";
+    init_util();
+    init_glsl_source();
+    init_types();
+    init_packing_utils();
+    createPackedReshape3DProgramMetadata = (outputShape3D) => ({
+      name: "Reshape (packed)",
+      inputTypes: [2 /* packed */],
+      inputNames: ["A"],
+      cacheHint: `${outputShape3D}`
+    });
+    createPackedReshape3DProgramInfo = (handler, input3D, metadata, outputShape3D) => {
+      const inputShape3D = input3D.dims;
+      const squeezedOutputShape = outputShape3D;
+      let mainLoop = "";
+      for (let i = 0; i < 4; i++) {
+        let outputCoords = "";
+        switch (i) {
+          case 0:
+            outputCoords = "outputCoords = rc;";
+            break;
+          case 1:
+            outputCoords = "outputCoords = ivec3(rc.x, rc.y+1, rc.z);";
+            break;
+          case 2:
+            outputCoords = "outputCoords = ivec3(rc.x, rc.y, rc.z+1);";
+            break;
+          case 3:
+            outputCoords = "outputCoords = ivec3(rc.x, rc.y+1, rc.z+1);";
+            break;
+          default:
+            throw new Error();
+        }
+        mainLoop += `
+        ${outputCoords}
+        ${i > 0 ? "if(outputCoords.y < rows && outputCoords.z < cols){" : ""}
+          int flattenedIndex = getFlattenedIndex(outputCoords);
+
+          ivec3 inputRC = inputCoordsFromReshapedOutCoords(flattenedIndex);
+          vec2 innerDims = vec2(float(inputRC.y),float(inputRC.z));
+
+          result[${i}] = getChannel(getA(inputRC.x, inputRC.y, inputRC.z), innerDims);
+
+        ${i > 0 ? "}" : ""}
+      `;
+      }
+      const glsl = getGlsl(handler.session.backend.glContext.version);
+      const shaderSource = `
+      ${getReshapedInputCoords(inputShape3D)}
+      ${getFlattenedIndexFrom3D(squeezedOutputShape)}
+      ${unpackFromChannel()}
+
+      void main() {
+        ivec3 rc = getOutputCoords();
+
+        vec4 result = vec4(0.0);
+
+        ivec3 outputCoords;
+        int rows = ${squeezedOutputShape[2]};
+        int cols = ${squeezedOutputShape[1]};
+
+        ${mainLoop}
+        ${glsl.output} = result;
+      }
+    `;
+      return {
+        ...metadata,
+        output: { dims: squeezedOutputShape, type: input3D.type, textureType: 2 /* packed */ },
+        shaderSource,
+        hasMain: true
+      };
+    };
+    createPackedReshape3DProgramInfoLoader = (handler, input3D, outputShape3D) => {
+      const metadata = createPackedReshape3DProgramMetadata(outputShape3D);
+      return { ...metadata, get: () => createPackedReshape3DProgramInfo(handler, input3D, metadata, outputShape3D) };
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/uint8-encode.ts
+var encodeAsUint8;
+var init_uint8_encode = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/uint8-encode.ts"() {
+    "use strict";
+    init_glsl_source();
+    init_types();
+    encodeAsUint8 = (inferenceHandler, input) => {
+      const outputShape = input.shape;
+      const glsl = getGlsl(inferenceHandler.session.backend.glContext.version);
+      const shaderSource = `
+    const float FLOAT_MAX = 1.70141184e38;
+    const float FLOAT_MIN = 1.17549435e-38;
+
+    bool isNaN(float val) {
+      return (val < 1.0 || 0.0 < val || val == 0.0) ? false : true;
+    }
+
+    highp vec4 encodeAsUint8(highp float v) {
+      if (isNaN(v)) {
+        return vec4(255, 255, 255, 255);
+      }
+
+      highp float av = abs(v);
+
+      if(av < FLOAT_MIN) {
+        return vec4(0.0, 0.0, 0.0, 0.0);
+      } else if(v > FLOAT_MAX) {
+        return vec4(0.0, 0.0, 128.0, 127.0) / 255.0;
+      } else if(v < -FLOAT_MAX) {
+        return vec4(0.0, 0.0,  128.0, 255.0) / 255.0;
+      }
+
+      highp vec4 c = vec4(0,0,0,0);
+
+      highp float e = floor(log2(av));
+      highp float m = exp2(fract(log2(av))) - 1.0;
+
+      c[2] = floor(128.0 * m);
+      m -= c[2] / 128.0;
+      c[1] = floor(32768.0 * m);
+      m -= c[1] / 32768.0;
+      c[0] = floor(8388608.0 * m);
+
+      highp float ebias = e + 127.0;
+      c[3] = floor(ebias / 2.0);
+      ebias -= c[3] * 2.0;
+      c[2] += floor(ebias) * 128.0;
+
+      c[3] += 128.0 * step(0.0, -v);
+
+      return c / 255.0;
+    }
+
+    void main() {
+      float value = ${glsl.texture2D}(X,TexCoords).r;
+      ${glsl.output} = encodeAsUint8(value);
+    }`;
+      const programInfo = {
+        name: "Uint8Encode",
+        inputTypes: [0 /* unpacked */],
+        inputNames: ["X"],
+        output: { dims: outputShape, type: input.tensor.type, textureType: 3 /* downloadUint8AsFloat */ },
+        shaderSource,
+        hasMain: true
+      };
+      return inferenceHandler.executeProgram(programInfo, [input.tensor]);
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/unpack.ts
+function getSourceCoords(rank, dims) {
+  if (rank === 1) {
+    return "rc";
+  }
+  let coords = "";
+  for (let i = 0; i < rank; i++) {
+    coords += dims[i];
+    if (i < rank - 1) {
+      coords += ",";
+    }
+  }
+  return coords;
+}
+var unpackProgramMetadata, createUnpackProgramInfo, createUnpackProgramInfoLoader;
+var init_unpack = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/unpack.ts"() {
+    "use strict";
+    init_glsl_source();
+    init_types();
+    init_utils();
+    init_packing_utils();
+    unpackProgramMetadata = {
+      name: "unpack",
+      inputNames: ["A"],
+      inputTypes: [2 /* packed */]
+    };
+    createUnpackProgramInfo = (handler, input) => {
+      const rank = input.dims.length;
+      const channels = getChannels("rc", rank);
+      const innerDims = channels.slice(-2);
+      const coordsDataType = getCoordsDataType(rank);
+      const unpackChannel = unpackFromChannel();
+      const isScalar = input.dims.length === 0;
+      const sourceCoords = isScalar ? "" : getSourceCoords(rank, channels);
+      const coords = rank <= 1 ? "rc" : `vec2(${innerDims.join(",")})`;
+      const glsl = getGlsl(handler.session.backend.glContext.version);
+      const shaderSource = `
+    ${unpackChannel}
+    void main() {
+      ${coordsDataType} rc = getOutputCoords();
+
+       // Sample the texture with the coords to get the rgba channel value.
+       vec4 packedInput = getA(${sourceCoords});
+
+       ${glsl.output} = vec4(getChannel(packedInput, ${coords}), 0, 0, 0);
+     }
+   `;
+      return {
+        ...unpackProgramMetadata,
+        hasMain: true,
+        output: { dims: input.dims, type: input.type, textureType: 0 /* unpacked */ },
+        shaderSource
+      };
+    };
+    createUnpackProgramInfoLoader = (handler, input) => ({
+      ...unpackProgramMetadata,
+      get: () => createUnpackProgramInfo(handler, input)
+    });
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/texture-data-encoder.ts
+var RedFloat32DataEncoder, RGBAFloatDataEncoder, Uint8DataEncoder;
+var init_texture_data_encoder = __esm({
+  "web/lib/onnxjs/backends/webgl/texture-data-encoder.ts"() {
+    "use strict";
+    init_instrument();
+    RedFloat32DataEncoder = class {
+      constructor(gl, channels = 1) {
+        if (channels === 1) {
+          this.internalFormat = gl.R32F;
+          this.format = gl.RED;
+          this.textureType = gl.FLOAT;
+          this.channelSize = channels;
+        } else if (channels === 4) {
+          this.internalFormat = gl.RGBA32F;
+          this.format = gl.RGBA;
+          this.textureType = gl.FLOAT;
+          this.channelSize = channels;
+        } else {
+          throw new Error(`Invalid number of channels: ${channels}`);
+        }
+      }
+      encode(src, textureSize) {
+        let result;
+        let source;
+        if (src.constructor !== Float32Array) {
+          Logger.warning("Encoder", "data was not of type Float32; creating new Float32Array");
+          source = new Float32Array(src);
+        }
+        if (textureSize * this.channelSize > src.length) {
+          Logger.warning("Encoder", "Source data too small. Allocating larger array");
+          source = src;
+          result = this.allocate(textureSize * this.channelSize);
+          source.forEach((v, i) => result[i] = v);
+        } else {
+          source = src;
+          result = source;
+        }
+        return result;
+      }
+      allocate(size) {
+        return new Float32Array(size * 4);
+      }
+      decode(buffer, dataSize) {
+        if (this.channelSize === 1) {
+          const filteredData = buffer.filter((_value, index) => index % 4 === 0).subarray(0, dataSize);
+          return filteredData;
+        }
+        return buffer.subarray(0, dataSize);
+      }
+    };
+    RGBAFloatDataEncoder = class {
+      constructor(gl, channels = 1, textureType) {
+        if (channels !== 1 && channels !== 4) {
+          throw new Error(`Invalid number of channels: ${channels}`);
+        }
+        this.internalFormat = gl.RGBA;
+        this.format = gl.RGBA;
+        this.channelSize = channels;
+        this.textureType = textureType || gl.FLOAT;
+      }
+      encode(src, textureSize) {
+        let dest = src;
+        if (this.channelSize === 1) {
+          Logger.verbose("Encoder", "Exploding into a larger array");
+          dest = this.allocate(textureSize);
+          src.forEach((v, i) => dest[i * 4] = v);
+        }
+        return dest;
+      }
+      allocate(size) {
+        return new Float32Array(size * 4);
+      }
+      decode(buffer, dataSize) {
+        if (this.channelSize === 1) {
+          const filteredData = buffer.filter((_value, index) => index % 4 === 0).subarray(0, dataSize);
+          return filteredData;
+        }
+        return buffer.subarray(0, dataSize);
+      }
+    };
+    Uint8DataEncoder = class {
+      constructor(gl, channels = 1) {
+        this.channelSize = 4;
+        if (channels === 1) {
+          this.internalFormat = gl.ALPHA;
+          this.format = gl.ALPHA;
+          this.textureType = gl.UNSIGNED_BYTE;
+          this.channelSize = channels;
+        } else if (channels === 4) {
+          this.internalFormat = gl.RGBA;
+          this.format = gl.RGBA;
+          this.textureType = gl.UNSIGNED_BYTE;
+          this.channelSize = channels;
+        } else {
+          throw new Error(`Invalid number of channels: ${channels}`);
+        }
+      }
+      encode(src, _textureSize) {
+        return new Uint8Array(src.buffer, src.byteOffset, src.byteLength);
+      }
+      allocate(size) {
+        return new Uint8Array(size * this.channelSize);
+      }
+      decode(buffer, dataSize) {
+        if (buffer instanceof Uint8Array) {
+          return buffer.subarray(0, dataSize);
+        }
+        throw new Error(`Invalid array type: ${buffer.constructor}`);
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/texture-layout.ts
+var createTextureLayoutFromTextureType, calculateTextureWidthAndHeight, createTextureLayoutFromShape;
+var init_texture_layout = __esm({
+  "web/lib/onnxjs/backends/webgl/texture-layout.ts"() {
+    "use strict";
+    init_util();
+    init_types();
+    createTextureLayoutFromTextureType = (textureLayoutStrategy, shape2, textureType) => {
+      const channel = textureType === 0 /* unpacked */ || textureType === 1 /* unpackedReversed */ ? 1 : 4;
+      const isPacked = textureType === 2 /* packed */;
+      const reverseWH = textureType === 1 /* unpackedReversed */ || textureType === 2 /* packed */;
+      const breakAxis = textureType === 4 /* packedLastDimension */ ? shape2.length - 1 : void 0;
+      const unpackedShape = textureType === 4 /* packedLastDimension */ ? shape2.map((d, i) => i === shape2.length - 1 ? d * 4 : d) : void 0;
+      return createTextureLayoutFromShape(textureLayoutStrategy, shape2, channel, unpackedShape, {
+        isPacked,
+        reverseWH,
+        breakAxis
+      });
+    };
+    calculateTextureWidthAndHeight = (textureLayoutStrategy, shape2, textureType) => {
+      const layout = createTextureLayoutFromTextureType(textureLayoutStrategy, shape2, textureType);
+      return [layout.width, layout.height];
+    };
+    createTextureLayoutFromShape = (textureLayoutStrategy, shape2, channels = 1, unpackedShape, prefs) => {
+      const isPacked = !!(prefs && prefs.isPacked);
+      const [width, height] = textureLayoutStrategy.computeTextureWH(isPacked ? unpackedShape || shape2 : shape2, prefs);
+      const rank = shape2.length;
+      let inferredDims = shape2.slice(0);
+      if (rank === 0) {
+        inferredDims = [1];
+      }
+      if (channels === 1) {
+        unpackedShape = shape2;
+      } else if (isPacked) {
+        if (channels !== 4) {
+          throw new Error("a packed texture must be 4-channel");
+        }
+        unpackedShape = shape2;
+        if (rank > 0) {
+          inferredDims[rank - 1] = Math.ceil(inferredDims[rank - 1] / 2);
+        }
+        if (rank > 1) {
+          inferredDims[rank - 2] = Math.ceil(inferredDims[rank - 2] / 2);
+        }
+      } else if (!unpackedShape) {
+        throw new Error("Unpacked shape is needed when using channels > 1");
+      }
+      return {
+        width,
+        height,
+        channels,
+        isPacked,
+        shape: inferredDims,
+        strides: ShapeUtil.computeStrides(inferredDims),
+        unpackedShape,
+        reversedWH: prefs && prefs.reverseWH
+      };
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/inference-handler.ts
+var getProgramInfoUniqueKey, WebGLInferenceHandler;
+var init_inference_handler = __esm({
+  "web/lib/onnxjs/backends/webgl/inference-handler.ts"() {
+    "use strict";
+    init_instrument();
+    init_tensor2();
+    init_util();
+    init_pack();
+    init_reshape_packed();
+    init_uint8_encode();
+    init_unpack();
+    init_texture_data_encoder();
+    init_texture_layout();
+    init_types();
+    getProgramInfoUniqueKey = (programInfo, inputTextureDatas) => {
+      const inputs = inputTextureDatas.map((texture) => `${texture.unpackedShape.join(",")};${texture.width}x${texture.height}`).join("_");
+      let key = programInfo.name;
+      if (programInfo.cacheHint) {
+        key += "[" + programInfo.cacheHint + "]";
+      }
+      key += ":" + inputs;
+      return key;
+    };
+    WebGLInferenceHandler = class {
+      constructor(session) {
+        this.session = session;
+        this.packedTextureDataCache = /* @__PURE__ */ new Map();
+        this.unpackedTextureDataCache = /* @__PURE__ */ new Map();
+      }
+      /**
+       * @returns [width, height]
+       */
+      calculateTextureWidthAndHeight(shape2, textureType) {
+        return calculateTextureWidthAndHeight(this.session.layoutStrategy, shape2, textureType);
+      }
+      executeProgram(program, inputs) {
+        if (inputs.length < program.inputNames.length) {
+          throw new Error(`Input size mustn't be less than ${program.inputNames.length}.`);
+        }
+        if (program.inputNames.length !== program.inputTypes.length) {
+          throw new Error("input names size does not match input types");
+        }
+        const inputTextureDatas = [];
+        for (let i = 0; i < program.inputNames.length; ++i) {
+          inputTextureDatas[i] = this.getOrCreateTextureData(inputs[i], program.inputTypes[i]);
+        }
+        const key = getProgramInfoUniqueKey(program, inputTextureDatas);
+        let artifact = this.session.programManager.getArtifact(key);
+        const programInfo = artifact ? artifact.programInfo : typeof program.get === "function" ? program.get() : program;
+        const outputTextureLayout = createTextureLayoutFromTextureType(
+          this.session.layoutStrategy,
+          programInfo.output.dims,
+          programInfo.output.textureType
+        );
+        const outputTextureData = this.createTextureData(outputTextureLayout, programInfo.output.type);
+        if (!artifact) {
+          artifact = this.session.programManager.build(programInfo, inputTextureDatas, outputTextureData);
+          this.session.programManager.setArtifact(key, artifact);
+        }
+        this.runProgram(artifact, inputTextureDatas, outputTextureData);
+        return outputTextureData;
+      }
+      run(program, inputs) {
+        const outputTextureData = this.executeProgram(program, inputs);
+        return outputTextureData.tensor;
+      }
+      runProgram(artifact, inputs, output) {
+        for (let i = 0; i < inputs.length; ++i) {
+          if (!!inputs[i].isPacked !== (artifact.programInfo.inputTypes[i] === 2 /* packed */)) {
+            throw new Error(`input[${i}] property packed inconsistent`);
+          }
+        }
+        if (!!output.isPacked !== (artifact.programInfo.output.textureType === 2 /* packed */)) {
+          throw new Error("output property packed inconsistent");
+        }
+        this.session.programManager.run(artifact, inputs, output);
+      }
+      /**
+       * Create a TextureData object from a tensor.
+       * Usage = EncoderUsage.UploadOnly.
+       * If a related texture data is found in cache, returns it;
+       * Otherwise:
+       *   Creates a new texture layout if not provided;
+       *   Creates WebGLTexture with the layout;
+       *   Upload tensor data to the texture;
+       *   Creates a texture data object associated with the given tensor.
+       * @param tensor the tensor with data to upload
+       */
+      getOrCreateTextureData(tensor, textureType) {
+        let td = this.getTextureData(tensor.dataId, textureType === 2 /* packed */);
+        if (!td) {
+          td = this.getTextureData(tensor.dataId, textureType !== 2 /* packed */);
+          if (td) {
+            if (textureType === 2 /* packed */) {
+              return this.pack(td);
+            } else {
+              return this.unpack(td);
+            }
+          }
+        }
+        if (!td) {
+          const layout = createTextureLayoutFromTextureType(this.session.layoutStrategy, tensor.dims, textureType);
+          if (textureType === 4 /* packedLastDimension */) {
+            const group = 1;
+            const channels = 4;
+            const shape2 = tensor.dims;
+            if (shape2.length === 4) {
+              const adjustedKernelShape = [shape2[0], Math.ceil(shape2[1] * shape2[2] * shape2[3] / channels)];
+              const adjustedLayout = createTextureLayoutFromTextureType(
+                this.session.layoutStrategy,
+                adjustedKernelShape,
+                textureType
+              );
+              let buffer = tensor.numberData;
+              if (shape2[1] * shape2[2] * shape2[3] % channels !== 0) {
+                const numFeatureMaps = shape2[0];
+                const oldRowSize = shape2[1] * shape2[2] * shape2[3];
+                const newRowSize = Math.ceil(oldRowSize * group / channels) * channels;
+                const newSize = numFeatureMaps * newRowSize;
+                buffer = new Float32Array(newSize);
+                for (let f = 0; f < numFeatureMaps; ++f) {
+                  const oldOffset = f * oldRowSize;
+                  const newOffset = f * newRowSize + f % group * oldRowSize;
+                  buffer.set(tensor.numberData.subarray(oldOffset, oldOffset + oldRowSize), newOffset);
+                }
+              }
+              return this.createTextureData(adjustedLayout, tensor.type, buffer, tensor, 1 /* UploadOnly */);
+            }
+          }
+          if (textureType === 2 /* packed */) {
+            const unpackedTextureLayout = createTextureLayoutFromShape(this.session.layoutStrategy, tensor.dims, 1, [], {
+              reverseWH: true
+            });
+            const unpackedTextureData = this.createTextureData(
+              unpackedTextureLayout,
+              tensor.type,
+              tensor.numberData,
+              tensor,
+              1 /* UploadOnly */
+            );
+            td = this.pack(unpackedTextureData);
+          } else {
+            td = this.createTextureData(layout, tensor.type, tensor.numberData, tensor, 1 /* UploadOnly */);
+          }
+        }
+        return td;
+      }
+      /**
+       * Create a TextureData object using the given data and bind to the given tensor.
+       * Usage = EncoderUsage.UploadOnly.
+       * NOTE: this function is a hack for Conv implementation. should remove this function, after rewriting Conv
+       * implementation by Graph.Transformer
+       * @param dataType the tensor data type
+       * @param data the actual data to upload
+       * @param tensor the tensor to bind. tensor's data is ignored.
+       */
+      createTextureDataFromLayoutBindTensor(layout, dataType, data, tensor) {
+        return this.createTextureData(layout, dataType, data, tensor, 1 /* UploadOnly */);
+      }
+      createTextureData(layout, dataType, data, tensor, usage) {
+        Logger.verbose("InferenceHandler", `Creating TextureData: layout:[${JSON.stringify(layout)}]`);
+        const texture = this.session.textureManager.createTextureFromLayout(dataType, layout, data, usage);
+        return this.createTextureDataFromTexture(layout, dataType, texture, tensor);
+      }
+      reshapeUnpacked(input, reshapedDims) {
+        const inputTD = this.getOrCreateTextureData(input, 0 /* unpacked */);
+        const newTextureLayout = {
+          channels: inputTD.channels,
+          height: inputTD.height,
+          width: inputTD.width,
+          // handle reshaping into scalar Tensors
+          shape: reshapedDims.length !== 0 ? reshapedDims : [1],
+          strides: ShapeUtil.computeStrides(reshapedDims),
+          unpackedShape: reshapedDims
+        };
+        const newTextureData = this.createTextureDataFromTexture(newTextureLayout, input.type, inputTD.texture);
+        return newTextureData.tensor;
+      }
+      reshapePacked(input, reshapedDims) {
+        const inputTD = this.getOrCreateTextureData(input, 2 /* packed */);
+        if (isReshapeCheap(input.dims, reshapedDims)) {
+          const newTextureLayout = {
+            channels: inputTD.channels,
+            height: inputTD.height,
+            width: inputTD.width,
+            // handle reshaping into scalar Tensors
+            shape: reshapedDims.length !== 0 ? reshapedDims : [1],
+            strides: ShapeUtil.computeStrides(reshapedDims),
+            unpackedShape: reshapedDims,
+            isPacked: true
+          };
+          const newTextureData = this.createTextureDataFromTexture(newTextureLayout, input.type, inputTD.texture);
+          return newTextureData.tensor;
+        }
+        const squeezedInputShape = processDims3D(input.dims);
+        const squeezedOutputShape = processDims3D(reshapedDims);
+        const squeezedInputTensor = this.reshapePacked(input, squeezedInputShape);
+        const squeezedOutputTensor = this.run(
+          createPackedReshape3DProgramInfoLoader(this, squeezedInputTensor, squeezedOutputShape),
+          [squeezedInputTensor]
+        );
+        const outputTensor = this.reshapePacked(squeezedOutputTensor, reshapedDims);
+        return outputTensor;
+      }
+      cast(input, type) {
+        const inputTD = this.getOrCreateTextureData(input, 0 /* unpacked */);
+        const newTextureData = this.createTextureDataFromTexture(inputTD, type, inputTD.texture);
+        return newTextureData.tensor;
+      }
+      createTextureDataFromTexture(layout, dataType, texture, tensor, tensorId) {
+        const textureData = {
+          ...layout,
+          tensor: tensor || new Tensor4(
+            layout.unpackedShape,
+            dataType,
+            (_id) => this.readTexture(textureData),
+            async (_id) => this.readTextureAsync(textureData),
+            void 0,
+            tensorId
+          ),
+          texture
+        };
+        this.setTextureData(textureData.tensor.dataId, textureData, layout.isPacked);
+        return textureData;
+      }
+      getTextureData(tensorId, isPacked = false) {
+        return this.session.isInitializer(tensorId) ? this.session.getTextureData(tensorId, isPacked) : isPacked ? this.packedTextureDataCache.get(tensorId) : this.unpackedTextureDataCache.get(tensorId);
+      }
+      setTextureData(tensorId, td, isPacked = false) {
+        if (this.session.isInitializer(tensorId)) {
+          this.session.setTextureData(tensorId, td, isPacked);
+        } else {
+          (isPacked ? this.packedTextureDataCache : this.unpackedTextureDataCache).set(tensorId, td);
+        }
+      }
+      isTextureLayoutCached(tensor, isPacked = false) {
+        return !!this.getTextureData(tensor.dataId, isPacked);
+      }
+      dispose() {
+        this.session.textureManager.clearActiveTextures();
+        this.packedTextureDataCache.forEach((td) => this.session.textureManager.releaseTexture(td));
+        this.packedTextureDataCache = /* @__PURE__ */ new Map();
+        this.unpackedTextureDataCache.forEach((td) => this.session.textureManager.releaseTexture(td));
+        this.unpackedTextureDataCache = /* @__PURE__ */ new Map();
+      }
+      readTexture(textureData) {
+        if (textureData.isPacked) {
+          return this.readTexture(this.unpack(textureData));
+        }
+        if (!this.session.backend.glContext.isFloat32DownloadSupported) {
+          return this.session.textureManager.readUint8TextureAsFloat(encodeAsUint8(this, textureData));
+        }
+        return this.session.textureManager.readTexture(textureData, textureData.tensor.type, textureData.channels);
+      }
+      async readTextureAsync(textureData) {
+        if (textureData.isPacked) {
+          return this.readTextureAsync(this.unpack(textureData));
+        }
+        if (!this.session.backend.glContext.isFloat32DownloadSupported) {
+          return this.session.textureManager.readUint8TextureAsFloat(encodeAsUint8(this, textureData));
+        }
+        return this.session.textureManager.readTextureAsync(textureData, textureData.tensor.type, textureData.channels);
+      }
+      pack(input) {
+        const outputTextureData = this.executeProgram(createPackProgramInfoLoader(this, input.tensor), [input.tensor]);
+        return outputTextureData;
+      }
+      unpack(input) {
+        const outputTextureData = this.executeProgram(createUnpackProgramInfoLoader(this, input.tensor), [input.tensor]);
+        return outputTextureData;
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/attribute-with-cache-key.ts
+var AttributeWithCacheKeyImpl, createAttributeWithCacheKey;
+var init_attribute_with_cache_key = __esm({
+  "web/lib/onnxjs/attribute-with-cache-key.ts"() {
+    "use strict";
+    AttributeWithCacheKeyImpl = class {
+      constructor(attribute) {
+        Object.assign(this, attribute);
+      }
+      get cacheKey() {
+        if (!this.key) {
+          this.key = Object.getOwnPropertyNames(this).sort().map((name2) => `${this[name2]}`).join(";");
+        }
+        return this.key;
+      }
+    };
+    createAttributeWithCacheKey = (attribute) => new AttributeWithCacheKeyImpl(attribute);
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/batch-normalization.ts
+var batchNormalizationProgramMetadata, batchNormalization, parseBatchNormalizationAttributes, createBatchNormalizationProgramInfo, validateInputs;
+var init_batch_normalization = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/batch-normalization.ts"() {
+    "use strict";
+    init_attribute_with_cache_key();
+    init_glsl_source();
+    init_types();
+    batchNormalizationProgramMetadata = {
+      name: "BatchNormalization",
+      inputNames: ["A", "Scale", "B", "Mean", "Variance"],
+      inputTypes: [
+        0 /* unpacked */,
+        0 /* unpacked */,
+        0 /* unpacked */,
+        0 /* unpacked */,
+        0 /* unpacked */
+      ]
+    };
+    batchNormalization = (inferenceHandler, inputs, attributes) => {
+      validateInputs(inputs);
+      const output = inferenceHandler.run(
+        {
+          ...batchNormalizationProgramMetadata,
+          cacheHint: attributes.cacheKey,
+          get: () => createBatchNormalizationProgramInfo(inferenceHandler, inputs, attributes)
+        },
+        inputs
+      );
+      return [output];
+    };
+    parseBatchNormalizationAttributes = (node) => {
+      const epsilon = node.attributes.getFloat("epsilon", 1e-5);
+      const momentum = node.attributes.getFloat("momentum", 0.9);
+      const spatial = node.attributes.getInt("spatial", 1);
+      return createAttributeWithCacheKey({ epsilon, momentum, spatial });
+    };
+    createBatchNormalizationProgramInfo = (inferenceHandler, inputs, attributes) => {
+      const glsl = getGlsl(inferenceHandler.session.backend.glContext.version);
+      const rank = inputs[0].dims.length;
+      const [scaleWidth, scaleHeight] = inferenceHandler.calculateTextureWidthAndHeight(
+        inputs[1].dims,
+        0 /* unpacked */
+      );
+      const shaderSource = `
+  float process(int[${rank}] indices) {
+    vec2 position = offsetToCoords(indices[1], ${scaleWidth}, ${scaleHeight});
+    float scale = getColorAsFloat(${glsl.texture2D}(Scale, position));
+    float mean = getColorAsFloat(${glsl.texture2D}(Mean, position));
+    float variance = getColorAsFloat(${glsl.texture2D}(Variance, position));
+    float b = getColorAsFloat(${glsl.texture2D}(B, position));
+
+    return scale * ( (_A(indices) - mean) / sqrt(variance + float(${attributes.epsilon})) ) + b;
+  }`;
+      return {
+        ...batchNormalizationProgramMetadata,
+        output: { dims: inputs[0].dims, type: inputs[0].type, textureType: 0 /* unpacked */ },
+        shaderSource
+      };
+    };
+    validateInputs = (inputs) => {
+      if (!inputs || inputs.length !== 5) {
+        throw new Error("BatchNormalization requires 5 inputs.");
+      }
+      const X = inputs[0];
+      const scale = inputs[1];
+      const B = inputs[2];
+      const mean = inputs[3];
+      const var_ = inputs[4];
+      if (X.dims.length < 3 || scale.dims.length !== 1 || B.dims.length !== 1 || mean.dims.length !== 1 || var_.dims.length !== 1) {
+        throw new Error("invalid input shape.");
+      }
+      if (scale.dims[0] !== X.dims[1] || B.dims[0] !== X.dims[1] || mean.dims[0] !== X.dims[1] || var_.dims[0] !== X.dims[1]) {
+        throw new Error("invalid input shape.");
+      }
+      if (X.type !== "float32" && X.type !== "float64" || scale.type !== "float32" && scale.type !== "float64" || B.type !== "float32" && B.type !== "float64" || mean.type !== "float32" && mean.type !== "float64" || var_.type !== "float32" && var_.type !== "float64") {
+        throw new Error("invalid input tensor types.");
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/glsl-definitions.ts
+var GlslContext, GlslLib, GlslLibRoutine, GlslLibRoutineNode, TopologicalSortGlslRoutines;
+var init_glsl_definitions = __esm({
+  "web/lib/onnxjs/backends/webgl/glsl-definitions.ts"() {
+    "use strict";
+    GlslContext = class {
+      constructor(glContext, programInfo, inputTextureLayouts, outputTextureLayout) {
+        this.glContext = glContext;
+        this.programInfo = programInfo;
+        this.inputTextureLayouts = inputTextureLayouts;
+        this.outputTextureLayout = outputTextureLayout;
+      }
+    };
+    GlslLib = class {
+      constructor(context) {
+        this.context = context;
+      }
+    };
+    GlslLibRoutine = class {
+      constructor(routineBody, dependencies) {
+        this.routineBody = routineBody;
+        this.dependencies = dependencies;
+      }
+    };
+    GlslLibRoutineNode = class {
+      constructor(name2, routineBody, dependencies) {
+        this.name = name2;
+        if (dependencies) {
+          this.dependencies = dependencies;
+        } else {
+          this.dependencies = [];
+        }
+        if (routineBody) {
+          this.routineBody = routineBody;
+        }
+      }
+      addDependency(node) {
+        if (node) {
+          this.dependencies.push(node);
+        }
+      }
+    };
+    TopologicalSortGlslRoutines = class {
+      static returnOrderedNodes(nodes) {
+        if (!nodes || nodes.length === 0) {
+          return [];
+        }
+        if (nodes.length === 1) {
+          return nodes;
+        }
+        const cycleCheck = /* @__PURE__ */ new Set();
+        const alreadyTraversed = /* @__PURE__ */ new Set();
+        const result = new Array();
+        this.createOrderedNodes(nodes, cycleCheck, alreadyTraversed, result);
+        return result;
+      }
+      static createOrderedNodes(graphNodes, cycleCheck, alreadyTraversed, result) {
+        for (let i = 0; i < graphNodes.length; ++i) {
+          this.dfsTraverse(graphNodes[i], cycleCheck, alreadyTraversed, result);
+        }
+      }
+      static dfsTraverse(root, cycleCheck, alreadyTraversed, result) {
+        if (!root || alreadyTraversed.has(root.name)) {
+          return;
+        }
+        if (cycleCheck.has(root.name)) {
+          throw new Error("Cyclic dependency detected. Can't topologically sort routines needed for shader.");
+        }
+        cycleCheck.add(root.name);
+        const dependencies = root.dependencies;
+        if (dependencies && dependencies.length > 0) {
+          for (let i = 0; i < dependencies.length; ++i) {
+            this.dfsTraverse(dependencies[i], cycleCheck, alreadyTraversed, result);
+          }
+        }
+        result.push(root);
+        alreadyTraversed.add(root.name);
+        cycleCheck.delete(root.name);
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/binary-op.ts
+function glslAdd() {
+  const name2 = "add_";
+  const body = `
+  float ${name2}(float a, float b) {
+    return a + b;
+  }
+  vec4 ${name2}(vec4 v1, vec4 v2) {
+    return v1 + v2;
+  }
+  `;
+  return { body, name: name2, type: 0 /* ValueBased */ };
+}
+function glslDiv() {
+  const name2 = "div_";
+  const body = `
+  float ${name2}(float a, float b) {
+    return a / b;
+  }
+  vec4 ${name2}(vec4 v1, vec4 v2) {
+    return v1 / v2;
+  }
+  `;
+  return { body, name: name2, type: 0 /* ValueBased */ };
+}
+function glslMul() {
+  const name2 = "mul_";
+  const body = `
+  float ${name2}(float a, float b) {
+    return a * b;
+  }
+  vec4 ${name2}(vec4 v1, vec4 v2) {
+    return v1 * v2;
+  }
+  `;
+  return { body, name: name2, type: 0 /* ValueBased */ };
+}
+function glslSub() {
+  const name2 = "sub_";
+  const body = `
+  float ${name2}(float a, float b) {
+    return a - b;
+  }
+  vec4 ${name2}(vec4 v1, vec4 v2) {
+    return v1 - v2;
+  }
+  `;
+  return { body, name: name2, type: 0 /* ValueBased */ };
+}
+function glslEqual() {
+  const name2 = "equal_";
+  const body = `
+  float ${name2}(float a, float b) {
+    return float(a == b);
+  }
+  vec4 ${name2}(vec4 v1, vec4 v2) {
+    return vec4(equal(v1, v2));
+  }
+  `;
+  return { body, name: name2, type: 0 /* ValueBased */ };
+}
+function glslGreater() {
+  const name2 = "greater_";
+  const body = `
+  float ${name2}(float a, float b) {
+    return float(a > b);
+  }
+  vec4 ${name2}(vec4 v1, vec4 v2) {
+    return vec4( v1.r > v2.r ,
+      v1.g > v2.g,
+      v1.b > v2.b,
+      v1.a > v2.a );
+  }
+  `;
+  return { body, name: name2, type: 0 /* ValueBased */ };
+}
+function glslLess() {
+  const name2 = "less_";
+  const body = `
+  float ${name2}(float a, float b) {
+    return float(a < b);
+  }
+  vec4 ${name2}(vec4 v1, vec4 v2) {
+    return vec4( v1.r < v2.r ,
+                v1.g < v2.g,
+                v1.b < v2.b,
+                v1.a < v2.a );
+  }
+  `;
+  return { body, name: name2, type: 0 /* ValueBased */ };
+}
+function glslAnd() {
+  const name2 = "and_";
+  const body = `
+  float ${name2}(float a, float b) {
+    return float( bool(a) && bool(b) );
+  }
+  vec4 ${name2}(vec4 v1, vec4 v2) {
+    bvec4 b1 = bvec4(v1);
+    bvec4 b2 = bvec4(v2);
+    return vec4( b1.r && b2.r ,
+                b1.g && b2.g,
+                b1.b && b2.b,
+                b1.a && b2.a );
+  }
+  `;
+  return { body, name: name2, type: 0 /* ValueBased */ };
+}
+function glslOr() {
+  const name2 = "or_";
+  const body = `
+  float ${name2}(float a, float b) {
+    return float( bool(a) || bool(b) );
+  }
+  vec4 ${name2}(vec4 v1, vec4 v2) {
+    bvec4 b1 = bvec4(v1);
+    bvec4 b2 = bvec4(v2);
+    return vec4( b1.r || b2.r ,
+                b1.g || b2.g,
+                b1.b || b2.b,
+                b1.a || b2.a );
+  }
+  `;
+  return { body, name: name2, type: 0 /* ValueBased */ };
+}
+function glslXor() {
+  const name2 = "xor_";
+  const body = `
+  float ${name2}(float a, float b) {
+    return float( bool(a) ^^ bool(b) );
+  }
+  vec4 ${name2}(vec4 v1, vec4 v2) {
+    bvec4 b1 = bvec4(v1);
+    bvec4 b2 = bvec4(v2);
+    return vec4( b1.r ^^ b2.r ,
+                b1.g ^^ b2.g,
+                b1.b ^^ b2.b,
+                b1.a ^^ b2.a );
+  }
+  `;
+  return { body, name: name2, type: 0 /* ValueBased */ };
+}
+function glslPow() {
+  return glslBuiltinBinary("pow");
+}
+function glslPRelu() {
+  const name2 = "prelu_";
+  const body = `
+  float ${name2}(float a, float b) {
+    return a < 0.0 ? a * b: a;
+  }
+  vec4 ${name2}(vec4 v1, vec4 v2) {
+    return vec4(
+      v1.r < 0.0 ? v1.r * v2.r: v1.r,
+      v1.g < 0.0 ? v1.g * v2.g: v1.g,
+      v1.b < 0.0 ? v1.b * v2.b: v1.b,
+      v1.a < 0.0 ? v1.a * v2.a: v1.a
+      );
+  }
+  `;
+  return { body, name: name2, type: 0 /* ValueBased */ };
+}
+function glslBuiltinBinary(fname) {
+  const name2 = `${fname}_`;
+  const body = `
+  float ${name2}(float a, float b) {
+    return ${fname}(a, b);
+  }
+  vec4 ${name2}(vec4 v1, vec4 v2) {
+    return ${fname}(v1, v2);
+  }
+  `;
+  return { body, name: name2, type: 0 /* ValueBased */ };
+}
+var createBinaryProgramInfoLoader, createBinaryProgramInfo, add2, and2, div, equal, greater, less, mul, or2, pow, pRelu, sub, xor2;
+var init_binary_op = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/binary-op.ts"() {
+    "use strict";
+    init_util();
+    init_glsl_definitions();
+    init_glsl_source();
+    init_types();
+    createBinaryProgramInfoLoader = (handler, inputs, glslFunc, outputTensorType = inputs[0].type, cacheKey) => {
+      const textureType = handler.session.pack ? 2 /* packed */ : 0 /* unpacked */;
+      return {
+        name: glslFunc.name,
+        inputNames: ["A", "B"],
+        inputTypes: [textureType, textureType],
+        cacheHint: cacheKey,
+        get: () => createBinaryProgramInfo(handler, inputs, glslFunc, outputTensorType)
+      };
+    };
+    createBinaryProgramInfo = (handler, inputs, glslFunc, outputTensorType = inputs[0].type) => {
+      const textureType = handler.session.pack ? 2 /* packed */ : 0 /* unpacked */;
+      const isBroadcast = !ShapeUtil.areEqual(inputs[0].dims, inputs[1].dims);
+      let outputShape = inputs[0].dims;
+      const usePackedTexture = handler.session.pack;
+      if (isBroadcast) {
+        const calculatedShape = BroadcastUtil.calcShape(inputs[0].dims, inputs[1].dims, false);
+        if (!calculatedShape) {
+          throw new Error("Can't perform binary op on the given tensors");
+        }
+        outputShape = calculatedShape;
+        const outputRank = outputShape.length;
+        const aRank = inputs[0].dims.length !== 0 ? inputs[0].dims.length : 1;
+        const bRank = inputs[1].dims.length !== 0 ? inputs[1].dims.length : 1;
+        const aBcast = inputs[0].dims.length !== 0 ? "bcastIndices_A(indices, aindices);" : "aindices[0] = 0;";
+        const bBcast = inputs[1].dims.length !== 0 ? "bcastIndices_B(indices, bindices);" : "bindices[0] = 0;";
+        const glsl2 = getGlsl(handler.session.backend.glContext.version);
+        const shaderSource2 = usePackedTexture ? `
+      ${glslFunc.body}
+      void main() {
+        vec4 a = getAAtOutCoords();
+        vec4 b = getBAtOutCoords();
+        vec4 result = ${glslFunc.name}(a, b);
+        ${glsl2.output} = result;
+      }` : `
+      ${glslFunc.body}
+      float process(int indices[${outputRank}]) {
+        int aindices[${aRank}];
+        int bindices[${bRank}];
+        ${aBcast}
+        ${bBcast}
+        return ${glslFunc.name}(_A(aindices), _B(bindices));
+      }`;
+        return {
+          name: glslFunc.name,
+          inputNames: ["A", "B"],
+          inputTypes: [textureType, textureType],
+          output: { dims: outputShape, type: outputTensorType, textureType },
+          shaderSource: shaderSource2,
+          hasMain: usePackedTexture
+        };
+      }
+      const glsl = getGlsl(handler.session.backend.glContext.version);
+      const shaderSource = `
+    ${glslFunc.body}
+    void main() {
+      vec4 v1 = ${glsl.texture2D}(A, TexCoords);
+      vec4 v2 = ${glsl.texture2D}(B, TexCoords);
+      vec4 result = ${glslFunc.name}(v1, v2);
+      ${glsl.output} = result;
+    }
+    `;
+      return {
+        name: glslFunc.name,
+        inputNames: ["A", "B"],
+        inputTypes: [textureType, textureType],
+        output: { dims: inputs[0].dims, type: outputTensorType, textureType },
+        shaderSource,
+        hasMain: true
+      };
+    };
+    add2 = (handler, inputs) => [
+      handler.run(createBinaryProgramInfoLoader(handler, inputs, glslAdd()), inputs)
+    ];
+    and2 = (handler, inputs) => [
+      handler.run(createBinaryProgramInfoLoader(handler, inputs, glslAnd(), "bool"), inputs)
+    ];
+    div = (handler, inputs) => [
+      handler.run(createBinaryProgramInfoLoader(handler, inputs, glslDiv()), inputs)
+    ];
+    equal = (handler, inputs) => [
+      handler.run(createBinaryProgramInfoLoader(handler, inputs, glslEqual(), "bool"), inputs)
+    ];
+    greater = (handler, inputs) => [
+      handler.run(createBinaryProgramInfoLoader(handler, inputs, glslGreater(), "bool"), inputs)
+    ];
+    less = (handler, inputs) => [
+      handler.run(createBinaryProgramInfoLoader(handler, inputs, glslLess(), "bool"), inputs)
+    ];
+    mul = (handler, inputs) => [
+      handler.run(createBinaryProgramInfoLoader(handler, inputs, glslMul()), inputs)
+    ];
+    or2 = (handler, inputs) => [
+      handler.run(createBinaryProgramInfoLoader(handler, inputs, glslOr(), "bool"), inputs)
+    ];
+    pow = (handler, inputs) => [
+      handler.run(createBinaryProgramInfoLoader(handler, inputs, glslPow()), inputs)
+    ];
+    pRelu = (handler, inputs) => [
+      handler.run(createBinaryProgramInfoLoader(handler, inputs, glslPRelu()), inputs)
+    ];
+    sub = (handler, inputs) => [
+      handler.run(createBinaryProgramInfoLoader(handler, inputs, glslSub()), inputs)
+    ];
+    xor2 = (handler, inputs) => [
+      handler.run(createBinaryProgramInfoLoader(handler, inputs, glslXor(), "bool"), inputs)
+    ];
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/cast.ts
+var cast, parseCastAttributes, validateInputs2;
+var init_cast = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/cast.ts"() {
+    "use strict";
+    init_util();
+    cast = (handler, inputs, to) => {
+      validateInputs2(inputs);
+      return [handler.cast(inputs[0], to)];
+    };
+    parseCastAttributes = (node) => ProtoUtil.tensorDataTypeFromProto(node.attributes.getInt("to"));
+    validateInputs2 = (inputs) => {
+      if (!inputs || inputs.length !== 1) {
+        throw new Error("Cast requires 1 input.");
+      }
+      if (inputs[0].type === "string") {
+        throw new Error("Invalid input type.");
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/concat-packed.ts
+var createPackedConcatProgramMetadata, createPackedConcatProgramInfo, createPackedConcatProgramInfoLoader, getShiftedChannelsSnippet;
+var init_concat_packed = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/concat-packed.ts"() {
+    "use strict";
+    init_glsl_source();
+    init_types();
+    init_utils();
+    init_packing_utils();
+    createPackedConcatProgramMetadata = (inputCount, cacheHint) => ({
+      name: "Concat (packed)",
+      inputNames: Array.from({ length: inputCount }, (_v, i) => `X${i}`),
+      inputTypes: Array(inputCount).fill(2 /* packed */),
+      cacheHint
+    });
+    createPackedConcatProgramInfo = (handler, metadata, inputs, axis) => {
+      const inputShape = inputs[0].dims.slice();
+      if (axis >= inputShape.length || axis < -1 * inputShape.length) {
+        throw new Error("axis specified for concat doesn't match input dimensionality");
+      }
+      if (axis < 0) {
+        axis = inputShape.length + axis;
+      }
+      const outputShape = inputShape.slice(0);
+      for (let i = 1; i < inputs.length; i++) {
+        const dataNShape = inputs[i].dims.slice();
+        for (let axisIndex = 0; axisIndex < inputShape.length; axisIndex++) {
+          if (axisIndex === axis) {
+            outputShape[axis] += dataNShape[axisIndex];
+          } else if (inputShape[axisIndex] !== dataNShape[axisIndex]) {
+            throw new Error("non concat dimensions must match");
+          }
+        }
+      }
+      const rank = outputShape.length;
+      const coords = getChannels("coords", rank);
+      const dtype = getCoordsDataType(rank);
+      const unpackChannel = unpackFromChannel();
+      const shapes = inputs.map((i) => i.dims);
+      const channels = getGlChannels(rank);
+      const offsets = new Array(shapes.length - 1);
+      offsets[0] = shapes[0][axis];
+      for (let i = 1; i < offsets.length; i++) {
+        offsets[i] = offsets[i - 1] + shapes[i][axis];
+      }
+      const channel = channels[axis];
+      const lastChannels = channels.slice(-2);
+      const allChannels = channels.join();
+      let getValueSnippet = `if (${channel} < ${offsets[0]}) {
+        return getChannel(
+            getX0(${allChannels}), vec2(${lastChannels.join()}));
+        }`;
+      for (let i = 1; i < offsets.length; i++) {
+        const shift2 = offsets[i - 1];
+        getValueSnippet += `
+            if (${channel} < ${offsets[i]}  && ${channel} >= ${offsets[i - 1]}) {
+              return getChannel(
+                getX${i}(${getShiftedChannelsSnippet(channels, channel, shift2)}),
+                vec2(${getShiftedChannelsSnippet(lastChannels, channel, shift2)}));
+            }`;
+      }
+      const lastIndex = offsets.length;
+      const shift = offsets[offsets.length - 1];
+      getValueSnippet += `
+            return getChannel(
+              getX${lastIndex}(${getShiftedChannelsSnippet(channels, channel, shift)}),
+              vec2(${getShiftedChannelsSnippet(lastChannels, channel, shift)}));`;
+      const glsl = getGlsl(handler.session.backend.glContext.version);
+      const shaderSource = `
+          ${unpackChannel}
+          float getValue(${channels.map((x) => "int " + x)}) {
+            ${getValueSnippet}
+          }
+
+          void main() {
+            ${dtype} coords = getOutputCoords();
+            int lastDim = coords.${channels[rank - 1]};
+            coords.${channels[rank - 1]} = coords.${channels[rank - 2]};
+            coords.${channels[rank - 2]} = lastDim;
+
+            vec4 result = vec4(getValue(${coords}), 0., 0., 0.);
+
+            ${coords[rank - 1]} = ${coords[rank - 1]} + 1;
+            if (${coords[rank - 1]} < ${outputShape[rank - 1]}) {
+              result.g = getValue(${coords});
+            }
+
+            ${coords[rank - 2]} = ${coords[rank - 2]} + 1;
+            if (${coords[rank - 2]} < ${outputShape[rank - 2]}) {
+              result.a = getValue(${coords});
+            }
+
+            ${coords[rank - 1]} = ${coords[rank - 1]} - 1;
+            if (${coords[rank - 2]} < ${outputShape[rank - 2]} &&
+                ${coords[rank - 1]} < ${outputShape[rank - 1]}) {
+              result.b = getValue(${coords});
+            }
+            ${glsl.output} = result;
+          }
+        `;
+      return {
+        ...metadata,
+        output: { dims: outputShape, type: inputs[0].type, textureType: 2 /* packed */ },
+        shaderSource,
+        hasMain: true
+      };
+    };
+    createPackedConcatProgramInfoLoader = (handler, inputs, attributes) => {
+      const metadata = createPackedConcatProgramMetadata(inputs.length, attributes.cacheKey);
+      return { ...metadata, get: () => createPackedConcatProgramInfo(handler, metadata, inputs, attributes.axis) };
+    };
+    getShiftedChannelsSnippet = (channels, channel, shift) => {
+      const channelIdx = channels.indexOf(channel);
+      const res = channels.map((c, idx) => {
+        if (idx === channelIdx) {
+          return `${c} - ${shift}`;
+        } else {
+          return c;
+        }
+      });
+      return res.join();
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/concat.ts
+var concat, createUnpackedConcatProgramMetadata, createUnpackedConcatProgramInfo, createUnpackedConcatProgramInfoLoader, getTextureIndexWhereDataResidesLinearSearch, getTextureIndexWhereDataResidesBinarySearch, getFetchDataFromCorrectTextureMethod, getGetSizeInConcatAxisValueFromIndexMethod, parseConcatAttributes, validateInputs3;
+var init_concat = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/concat.ts"() {
+    "use strict";
+    init_attribute_with_cache_key();
+    init_types();
+    init_concat_packed();
+    concat = (inferenceHandler, inputs, attributes) => {
+      validateInputs3(inputs);
+      if (inferenceHandler.session.pack && inputs[0].dims.length > 1) {
+        const output = inferenceHandler.run(
+          createPackedConcatProgramInfoLoader(inferenceHandler, inputs, attributes),
+          inputs
+        );
+        return [output];
+      } else {
+        const output = inferenceHandler.run(
+          createUnpackedConcatProgramInfoLoader(inferenceHandler, inputs, attributes),
+          inputs
+        );
+        return [output];
+      }
+    };
+    createUnpackedConcatProgramMetadata = (inputCount, cacheHint) => ({
+      name: "Concat",
+      inputNames: Array.from({ length: inputCount }, (_v, i) => `X${i}`),
+      inputTypes: Array(inputCount).fill(0 /* unpacked */),
+      cacheHint
+    });
+    createUnpackedConcatProgramInfo = (_handler, metadata, inputs, axis) => {
+      const inputShape = inputs[0].dims.slice();
+      if (axis >= inputShape.length || axis < -1 * inputShape.length) {
+        throw new Error("axis specified for concat doesn't match input dimensionality");
+      }
+      if (axis < 0) {
+        axis = inputShape.length + axis;
+      }
+      const outputShape = inputShape.slice(0);
+      for (let i = 1; i < inputs.length; i++) {
+        const dataNShape = inputs[i].dims.slice();
+        for (let axisIndex = 0; axisIndex < inputShape.length; axisIndex++) {
+          if (axisIndex === axis) {
+            outputShape[axis] += dataNShape[axisIndex];
+          } else if (inputShape[axisIndex] !== dataNShape[axisIndex]) {
+            throw new Error("non concat dimensions must match");
+          }
+        }
+      }
+      const rank = outputShape.length;
+      const sizeInConcatAxis = new Array(inputs.length);
+      let previousSum = 0;
+      for (let i = 0; i < sizeInConcatAxis.length; ++i) {
+        previousSum += inputs[i].dims[axis];
+        sizeInConcatAxis[i] = previousSum;
+      }
+      let getTextureIndexWhereDataResidesMethod = "";
+      if (inputs.length < 5) {
+        getTextureIndexWhereDataResidesMethod = getTextureIndexWhereDataResidesLinearSearch(sizeInConcatAxis);
+      } else {
+        getTextureIndexWhereDataResidesMethod = getTextureIndexWhereDataResidesBinarySearch(sizeInConcatAxis);
+      }
+      const fetchDataFromCorrectTextureMethod = getFetchDataFromCorrectTextureMethod(inputs.length, rank);
+      const getSizeInConcatAxisValueFromIndexMethod = getGetSizeInConcatAxisValueFromIndexMethod(sizeInConcatAxis);
+      const shaderSource = `
+        ${fetchDataFromCorrectTextureMethod}
+        ${getSizeInConcatAxisValueFromIndexMethod}
+        ${getTextureIndexWhereDataResidesMethod}
+        float process(int indices[${rank}]) {
+          int textureIndex = getTextureWhereDataResides (indices[${axis}]);
+
+          if(textureIndex != 0) {
+            indices[${axis}] = indices[${axis}] - int(getSizeInConcatAxisValueFromIndex(textureIndex-int(1)));
+          }
+
+          return fetchDataFromCorrectTexture(textureIndex, indices);
+        }`;
+      return {
+        ...metadata,
+        output: { dims: outputShape, type: inputs[0].type, textureType: 0 /* unpacked */ },
+        shaderSource
+      };
+    };
+    createUnpackedConcatProgramInfoLoader = (handler, inputs, attributes) => {
+      const metadata = createUnpackedConcatProgramMetadata(inputs.length, attributes.cacheKey);
+      return { ...metadata, get: () => createUnpackedConcatProgramInfo(handler, metadata, inputs, attributes.axis) };
+    };
+    getTextureIndexWhereDataResidesLinearSearch = (sizeInConcatAxis) => {
+      const searchAxis = sizeInConcatAxis.map(
+        (size, i) => `if(index<${size}) {return ${i};}
+`
+      );
+      return `int getTextureWhereDataResides(int index) {
+      ${searchAxis.join("")}
+    }`;
+    };
+    getTextureIndexWhereDataResidesBinarySearch = (sizeInConcatAxis) => getTextureIndexWhereDataResidesLinearSearch(sizeInConcatAxis);
+    getFetchDataFromCorrectTextureMethod = (numberOfTensors, tensorRank) => {
+      const codeLines = [`float fetchDataFromCorrectTexture(int textureIndex, int indices[${tensorRank}]) {`];
+      for (let i = 0; i < numberOfTensors; ++i) {
+        if (i === 0) {
+          codeLines.push(`	if (textureIndex == ${i}) { return _X${i}(indices); }`);
+        } else if (i === numberOfTensors - 1) {
+          codeLines.push(`	else { return _X${i}(indices); }`);
+        } else {
+          codeLines.push(`	else if (textureIndex == ${i}) { return _X${i}(indices); }`);
+        }
+      }
+      codeLines.push("	}");
+      return codeLines.join("\n");
+    };
+    getGetSizeInConcatAxisValueFromIndexMethod = (sizeInConcatAxis) => {
+      const codeLines = ["int getSizeInConcatAxisValueFromIndex(int index) {"];
+      for (let i = 0; i < sizeInConcatAxis.length; ++i) {
+        if (i === 0) {
+          codeLines.push(`	if (index == ${i}) { return ${sizeInConcatAxis[i]}; }`);
+        } else if (i === sizeInConcatAxis.length - 1) {
+          codeLines.push(`	else { return ${sizeInConcatAxis[i]}; }`);
+        } else {
+          codeLines.push(`	else if (index == ${i}) { return ${sizeInConcatAxis[i]}; }`);
+        }
+      }
+      codeLines.push("	}");
+      return codeLines.join("\n");
+    };
+    parseConcatAttributes = (node) => createAttributeWithCacheKey({ axis: node.attributes.getInt("axis") });
+    validateInputs3 = (inputs) => {
+      if (!inputs || inputs.length < 1) {
+        throw new Error("too few inputs");
+      }
+      const inputType = inputs[0].type;
+      const inputDimensionality = inputs[0].dims.length;
+      if (inputType === "string") {
+        throw new Error("string tensor is not supported yet");
+      }
+      for (const input of inputs) {
+        if (input.type !== inputType) {
+          throw new Error("input tensors should be one type");
+        }
+        if (input.dims.length !== inputDimensionality) {
+          throw new Error("input tensors should have the same shape");
+        }
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/unary-op.ts
+function glslAbs() {
+  return glslBuiltinUnary("abs");
+}
+function glslAcos() {
+  return glslBuiltinUnary("acos");
+}
+function glslAsin() {
+  return glslBuiltinUnary("asin");
+}
+function glslAtan() {
+  return glslBuiltinUnary("atan");
+}
+function glslCeil() {
+  return glslBuiltinUnary("ceil");
+}
+function glslCos() {
+  return glslBuiltinUnary("cos");
+}
+function glslElu(alpha) {
+  const name2 = "elu";
+  const body = `
+  const float alpha = float(${alpha});
+
+  float ${name2}_(float a) {
+    return a >= 0.0 ? a: (exp(a) - 1.0) * alpha;
+  }
+  vec4 ${name2}_(vec4 v) {
+    return vec4(${name2}_(v.x), ${name2}_(v.y), ${name2}_(v.z), ${name2}_(v.w));
+  }
+  `;
+  return { body, name: name2, type: 0 /* ValueBased */ };
+}
+function glslExp() {
+  return glslBuiltinUnary("exp");
+}
+function glslFloor() {
+  return glslBuiltinUnary("floor");
+}
+function glslClip(min, max) {
+  const name2 = "clip";
+  const body = `
+  const float min = float(${min});
+  const float max = float(${max});
+
+  float ${name2}_(float a) {
+    return clamp(a, min, max);
+  }
+  vec4 ${name2}_(vec4 v) {
+    return clamp(v, min, max);
+  }
+  `;
+  return { body, name: name2, type: 0 /* ValueBased */ };
+}
+function glslIdentity() {
+  const name2 = "indentity";
+  const body = `
+  float ${name2}_(float a) {
+    return a;
+  }
+  vec4 ${name2}_(vec4 v) {
+    return v;
+  }
+  `;
+  return { body, name: name2, type: 0 /* ValueBased */ };
+}
+function glslLeakyRelu(alpha) {
+  const name2 = "leakyRelu";
+  const body = `
+  const float alpha = float(${alpha});
+
+  float ${name2}_(float a) {
+    return a < 0.0 ? a * alpha : a;
+  }
+  vec4 ${name2}_(vec4 v) {
+    return vec4(${name2}_(v.x), ${name2}_(v.y), ${name2}_(v.z), ${name2}_(v.w));
+  }
+  `;
+  return { body, name: name2, type: 0 /* ValueBased */ };
+}
+function glslLog() {
+  return glslBuiltinUnary("log");
+}
+function glslNeg() {
+  const name2 = "neg";
+  const body = `
+  float ${name2}_(float a) {
+    return -a;
+  }
+  vec4 ${name2}_(vec4 v) {
+    return -v;
+  }
+  `;
+  return { body, name: name2, type: 0 /* ValueBased */ };
+}
+function glslNot() {
+  const name2 = "not";
+  const body = `
+  float ${name2}_(float a) {
+    return float( ! bool(a) );
+  }
+  bool ${name2}_(bool a) {
+    return !a;
+  }
+  vec4 ${name2}_(vec4 v) {
+    return vec4(!bool(v.x), !bool(v.y), !bool(v.z), !bool(v.w));
+  }
+  bvec4 ${name2}_(bvec4 v) {
+    return bvec4(!v.x, !v.y, !v.z, !v.w);
+  }
+  `;
+  return { body, name: name2, type: 0 /* ValueBased */ };
+}
+function glslSin() {
+  return glslBuiltinUnary("sin");
+}
+function glslRelu() {
+  const name2 = "relu";
+  const body = `
+  float ${name2}_(float a) {
+    return max( a, 0.0 );
+  }
+  vec4 ${name2}_(vec4 v) {
+    return max( v, 0.0 );
+  }
+  `;
+  return { body, name: name2, type: 0 /* ValueBased */ };
+}
+function glslSigmoid() {
+  const name2 = "sigmoid";
+  const body = `
+  float ${name2}_(float a) {
+    return 1.0 / (1.0 + exp(-a));
+  }
+  vec4 ${name2}_(vec4 v) {
+    return 1.0 / (1.0 + exp(-v));
+  }
+  `;
+  return { body, name: name2, type: 0 /* ValueBased */ };
+}
+function glslSqrt() {
+  return glslBuiltinUnary("sqrt");
+}
+function glslTan() {
+  return glslBuiltinUnary("tan");
+}
+function glslTanh() {
+  const name2 = "tanh";
+  const body = `
+  float ${name2}_(float a) {
+    a = clamp(a, -10., 10.);
+    a = exp(2.*a);
+    return (a - 1.) / (a + 1.);
+  }
+  vec4 ${name2}_(vec4 v) {
+    v = clamp(v, -10., 10.);
+    v = exp(2.*v);
+    return (v - 1.) / (v + 1.);
+  }
+  `;
+  return { body, name: name2, type: 0 /* ValueBased */ };
+}
+function glslBuiltinUnary(name2) {
+  const body = `
+  float ${name2}_(float a) {
+    return ${name2}(a);
+  }
+  vec4 ${name2}_(vec4 v) {
+    return ${name2}(v);
+  }
+  `;
+  return { body, name: name2, type: 0 /* ValueBased */ };
+}
+var createElementwiseProgramInfo, createElementwiseProgramInfoLoader, abs, acos, asin, atan, clip, parseClipAttributes, clipV11, generateClipAttributesFromInputs, ceil, cos, elu, parseEluAttributes, exp, floor, identity, leakyRelu, parseLeakyReluAttributes, log2, neg, not2, relu, sigmoid, sin, sqrt, tan, tanh;
+var init_unary_op = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/unary-op.ts"() {
+    "use strict";
+    init_attribute_with_cache_key();
+    init_util();
+    init_glsl_definitions();
+    init_glsl_source();
+    init_types();
+    createElementwiseProgramInfo = (handler, metadata, input, glslFunc) => {
+      const textureType = handler.session.pack ? 2 /* packed */ : 0 /* unpacked */;
+      const glsl = getGlsl(handler.session.backend.glContext.version);
+      return {
+        ...metadata,
+        output: { dims: input.dims, type: input.type, textureType },
+        shaderSource: `
+     ${glslFunc.body}
+     void main() {
+       vec4 v = ${glsl.texture2D}(A, TexCoords);
+       v = ${glslFunc.name}_(v);
+       ${glsl.output} = v;
+     }
+     `,
+        hasMain: true
+      };
+    };
+    createElementwiseProgramInfoLoader = (handler, input, glslFunc, cacheKey) => {
+      const textureType = handler.session.pack ? 2 /* packed */ : 0 /* unpacked */;
+      const metadata = { name: glslFunc.name, inputTypes: [textureType], inputNames: ["A"], cacheHint: cacheKey };
+      return { ...metadata, get: () => createElementwiseProgramInfo(handler, metadata, input, glslFunc) };
+    };
+    abs = (handler, inputs) => [
+      handler.run(createElementwiseProgramInfoLoader(handler, inputs[0], glslAbs()), inputs)
+    ];
+    acos = (handler, inputs) => [
+      handler.run(createElementwiseProgramInfoLoader(handler, inputs[0], glslAcos()), inputs)
+    ];
+    asin = (handler, inputs) => [
+      handler.run(createElementwiseProgramInfoLoader(handler, inputs[0], glslAsin()), inputs)
+    ];
+    atan = (handler, inputs) => [
+      handler.run(createElementwiseProgramInfoLoader(handler, inputs[0], glslAtan()), inputs)
+    ];
+    clip = (handler, inputs, attributes) => [
+      handler.run(
+        createElementwiseProgramInfoLoader(
+          handler,
+          inputs[0],
+          glslClip(attributes.min, attributes.max),
+          attributes.cacheKey
+        ),
+        inputs
+      )
+    ];
+    parseClipAttributes = (node) => createAttributeWithCacheKey({
+      min: node.attributes.getFloat("min", MIN_CLIP),
+      max: node.attributes.getFloat("max", MAX_CLIP)
+    });
+    clipV11 = (handler, inputs) => {
+      const attributes = generateClipAttributesFromInputs(handler, inputs);
+      return clip(handler, [inputs[0]], attributes);
+    };
+    generateClipAttributesFromInputs = (handler, inputs) => {
+      if (inputs.length >= 3 && (!handler.session.isInitializer(inputs[1].dataId) || !handler.session.isInitializer(inputs[2].dataId))) {
+        throw new Error("dynamic clip attributes are not allowed");
+      }
+      const min = inputs.length >= 3 ? inputs[1].numberData[0] : MIN_CLIP;
+      const max = inputs.length >= 3 ? inputs[2].numberData[0] : MAX_CLIP;
+      return createAttributeWithCacheKey({ min, max });
+    };
+    ceil = (handler, inputs) => [
+      handler.run(createElementwiseProgramInfoLoader(handler, inputs[0], glslCeil()), inputs)
+    ];
+    cos = (handler, inputs) => [
+      handler.run(createElementwiseProgramInfoLoader(handler, inputs[0], glslCos()), inputs)
+    ];
+    elu = (handler, inputs, attributes) => [
+      handler.run(
+        createElementwiseProgramInfoLoader(handler, inputs[0], glslElu(attributes.alpha), attributes.cacheKey),
+        inputs
+      )
+    ];
+    parseEluAttributes = (node) => createAttributeWithCacheKey({ alpha: node.attributes.getFloat("alpha", 1) });
+    exp = (handler, inputs) => [
+      handler.run(createElementwiseProgramInfoLoader(handler, inputs[0], glslExp()), inputs)
+    ];
+    floor = (handler, inputs) => [
+      handler.run(createElementwiseProgramInfoLoader(handler, inputs[0], glslFloor()), inputs)
+    ];
+    identity = (handler, inputs) => [
+      handler.run(createElementwiseProgramInfoLoader(handler, inputs[0], glslIdentity()), inputs)
+    ];
+    leakyRelu = (handler, inputs, attributes) => [
+      handler.run(
+        createElementwiseProgramInfoLoader(handler, inputs[0], glslLeakyRelu(attributes.alpha), attributes.cacheKey),
+        inputs
+      )
+    ];
+    parseLeakyReluAttributes = (node) => createAttributeWithCacheKey({ alpha: node.attributes.getFloat("alpha", 0.01) });
+    log2 = (handler, inputs) => [
+      handler.run(createElementwiseProgramInfoLoader(handler, inputs[0], glslLog()), inputs)
+    ];
+    neg = (handler, inputs) => [
+      handler.run(createElementwiseProgramInfoLoader(handler, inputs[0], glslNeg()), inputs)
+    ];
+    not2 = (handler, inputs) => [
+      handler.run(createElementwiseProgramInfoLoader(handler, inputs[0], glslNot()), inputs)
+    ];
+    relu = (handler, inputs) => [
+      handler.run(createElementwiseProgramInfoLoader(handler, inputs[0], glslRelu()), inputs)
+    ];
+    sigmoid = (handler, inputs) => [
+      handler.run(createElementwiseProgramInfoLoader(handler, inputs[0], glslSigmoid()), inputs)
+    ];
+    sin = (handler, inputs) => [
+      handler.run(createElementwiseProgramInfoLoader(handler, inputs[0], glslSin()), inputs)
+    ];
+    sqrt = (handler, inputs) => [
+      handler.run(createElementwiseProgramInfoLoader(handler, inputs[0], glslSqrt()), inputs)
+    ];
+    tan = (handler, inputs) => [
+      handler.run(createElementwiseProgramInfoLoader(handler, inputs[0], glslTan()), inputs)
+    ];
+    tanh = (handler, inputs) => [
+      handler.run(createElementwiseProgramInfoLoader(handler, inputs[0], glslTanh()), inputs)
+    ];
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/fuse-utils.ts
+function getActivationSnippet(attributes) {
+  let func;
+  switch (attributes.activation) {
+    case "Relu":
+      func = glslRelu();
+      break;
+    case "Sigmoid":
+      func = glslSigmoid();
+      break;
+    case "Clip":
+      func = glslClip(attributes.clipMin, attributes.clipMax);
+      break;
+    // TODO: adding other activations that can be fused.
+    default:
+      return { activationFunction: "", applyActivation: "" };
+  }
+  const activationName = func.name;
+  const activationFunction = func.body;
+  const applyActivation = `value = ${activationName}_(value);`;
+  return { activationFunction, applyActivation };
+}
+var parseInternalActivationAttributes;
+var init_fuse_utils = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/fuse-utils.ts"() {
+    "use strict";
+    init_util();
+    init_unary_op();
+    parseInternalActivationAttributes = (attributes) => {
+      const activation = attributes.getString("activation", "");
+      if (activation === "Clip") {
+        const [clipMin, clipMax] = attributes.getFloats("activation_params", [MIN_CLIP, MAX_CLIP]);
+        return { activation, clipMax, clipMin, activationCacheKey: `${activation}:${clipMin},${clipMax}` };
+      }
+      return { activation, activationCacheKey: activation };
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/conv-grouped.ts
+var createUnpackedGroupedConvProgramMetadata, createUnpackedGroupedConvProgramInfo, createUnpackedGroupedConvProgramInfoLoader;
+var init_conv_grouped = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/conv-grouped.ts"() {
+    "use strict";
+    init_instrument();
+    init_glsl_source();
+    init_types();
+    init_conv();
+    init_fuse_utils();
+    createUnpackedGroupedConvProgramMetadata = (hasBias, cacheHint) => ({
+      name: "GroupedConv",
+      inputNames: hasBias ? ["X", "W", "Bias"] : ["X", "W"],
+      inputTypes: hasBias ? [0 /* unpacked */, 0 /* unpacked */, 0 /* unpacked */] : [0 /* unpacked */, 0 /* unpacked */],
+      cacheHint
+    });
+    createUnpackedGroupedConvProgramInfo = (inferenceHandler, inputs, metadata, attributes) => {
+      const hasBias = inputs.length > 2;
+      const processBias = hasBias ? "value += getBias(output_channel);" : "";
+      const xShape = inputs[0].dims.slice();
+      const wShape = inputs[1].dims.slice();
+      const outputChannelsPerGroup = wShape[0] / attributes.group;
+      Logger.verbose(
+        "GroupedConv",
+        `autpPad:${attributes.autoPad}, dilations:${attributes.dilations}, group:${attributes.group}, kernelShape:${attributes.kernelShape}, pads:${attributes.pads}, strides:${attributes.strides}`
+      );
+      const outputShape = calculateOutputShape(xShape, wShape, attributes.dilations, attributes.pads, attributes.strides);
+      const glsl = getGlsl(inferenceHandler.session.backend.glContext.version);
+      const { activationFunction, applyActivation } = getActivationSnippet(attributes);
+      const shaderSource = `
+  const ivec2 strides = ivec2(${attributes.strides[0]}, ${attributes.strides[1]});
+  const ivec2 pads = ivec2(${attributes.pads[0]}, ${attributes.pads[1]});
+  ${activationFunction}
+  void main() {
+    ivec4 coords = getOutputCoords();
+    int batch = coords.x;
+    int output_channel = coords.y;
+    ivec2 xRCCorner = coords.zw * strides - pads;
+    int group_id = output_channel / ${outputChannelsPerGroup};
+
+    float value = 0.0;
+    for (int wInChannel = 0; wInChannel < ${wShape[1]}; wInChannel++) {
+      int input_channel = group_id * ${wShape[1]} + wInChannel;
+      for (int wHeight = 0; wHeight < ${wShape[2]}; wHeight++) {
+        int xHeight = xRCCorner.x + wHeight * ${attributes.dilations[0]};
+
+        if (xHeight < 0 || xHeight >= ${xShape[2]}) {
+          continue;
+        }
+
+        for (int wWidth = 0; wWidth < ${wShape[3]}; wWidth++) {
+          int xWidth = xRCCorner.y + wWidth * ${attributes.dilations[1]};
+          if (xWidth < 0 || xWidth >= ${xShape[3]}) {
+            continue;
+          }
+
+          float xVal = getX(batch, input_channel, xWidth, xHeight);
+          float wVal = getW(output_channel, wInChannel, wWidth, wHeight);
+          value += xVal*wVal;
+        }
+      }
+    }
+    ${processBias}
+    ${applyActivation}
+    ${glsl.output} = vec4(value, .0, .0, .0);
+  }
+`;
+      return {
+        ...metadata,
+        output: { dims: outputShape, type: inputs[0].type, textureType: 0 /* unpacked */ },
+        shaderSource,
+        hasMain: true
+      };
+    };
+    createUnpackedGroupedConvProgramInfoLoader = (inferenceHandler, inputs, attributes) => {
+      const metadata = createUnpackedGroupedConvProgramMetadata(inputs.length > 2, attributes.cacheKey);
+      return {
+        ...metadata,
+        get: () => createUnpackedGroupedConvProgramInfo(inferenceHandler, inputs, metadata, attributes)
+      };
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/im2col-pack.ts
+var createPackedIm2ColProgramMetadata, createPackedIm2ColProgramInfo, createPackedIm2ColProgramInfoLoader;
+var init_im2col_pack = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/im2col-pack.ts"() {
+    "use strict";
+    init_glsl_source();
+    init_types();
+    init_packing_utils();
+    createPackedIm2ColProgramMetadata = (cacheHint) => ({
+      name: "Im2Col (packed)",
+      inputNames: ["A"],
+      inputTypes: [2 /* packed */],
+      cacheHint
+    });
+    createPackedIm2ColProgramInfo = (inferenceHandler, metadata, x, w, outputShape, attributes) => {
+      const xshape = x.dims;
+      const wshape = w.dims;
+      const rowDim = 2;
+      const colDim = 3;
+      const rank = outputShape.length;
+      const im2colShape = [wshape[1] * wshape[2] * wshape[3], outputShape[2] * outputShape[3]];
+      const kernelSize = wshape[2] * wshape[3];
+      const unpackChannel = unpackFromChannel();
+      const glsl = getGlsl(inferenceHandler.session.backend.glContext.version);
+      let unrolled = "";
+      for (let row = 0; row <= 1; row++) {
+        for (let col = 0; col <= 1; col++) {
+          unrolled += `
+            blockIndex = rc.x + ${col};
+            pos = rc.y + ${row};
+
+            if(blockIndex < ${im2colShape[1]} && pos < ${im2colShape[0]}) {
+              offsetY = int(blockIndex / (${outputShape[rank - 1]})) * ${attributes.strides[0]} -
+                ${attributes.pads[0]};
+              d0 = offsetY + ${attributes.dilations[0]} * (imod(pos, ${kernelSize}) / ${wshape[2]});
+
+              if(d0 < ${xshape[rowDim]} && d0 >= 0) {
+                offsetX = imod(blockIndex, ${outputShape[rank - 1]}) * ${attributes.strides[1]} -
+                  ${attributes.pads[1]};
+                d1 = offsetX + ${attributes.dilations[1]} * imod(imod(pos, ${kernelSize}), ${wshape[2]});
+
+                if(d1 < ${xshape[colDim]} && d1 >= 0) {
+
+                  ch = int(float(pos)/ ${kernelSize}.);
+                    innerDims = vec2(d0, d1);
+                    result[${row * 2 + col}] = getChannel(
+                      getA(0, ch, int(innerDims.x),
+                      int(innerDims.y)), innerDims);
+                }
+              }
+            }
+
+          `;
+        }
+      }
+      const shaderSource = `
+      ${unpackChannel}
+
+      void main() {
+        ivec2 rc = getOutputCoords();
+          vec4 result = vec4(0.0);
+          int blockIndex, pos, offsetY, d0, offsetX, d1, ch;
+          vec2 innerDims;
+          ${unrolled}
+          ${glsl.output} = result;
+      }
+            `;
+      return {
+        ...metadata,
+        output: { dims: im2colShape, type: x.type, textureType: 2 /* packed */ },
+        shaderSource,
+        hasMain: true
+      };
+    };
+    createPackedIm2ColProgramInfoLoader = (inferenceHandler, x, w, outputShape, attributes) => {
+      const metadata = createPackedIm2ColProgramMetadata(attributes.cacheKey);
+      return {
+        ...metadata,
+        get: () => createPackedIm2ColProgramInfo(inferenceHandler, metadata, x, w, outputShape, attributes)
+      };
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/matmul.ts
+function createMatmulProgramInfo(metadata, inputs, activationAttributes) {
+  const aShape = inputs[0].dims;
+  const bShape = inputs[1].dims;
+  const outputShape = BroadcastUtil.calcShape(aShape, bShape, true);
+  if (!outputShape) {
+    throw new Error("Can't use matmul on the given tensors");
+  }
+  const coordsDataType = getCoordsDataType(outputShape.length);
+  const allGlChannels = getGlChannels();
+  const { activationFunction, applyActivation } = getActivationSnippet(activationAttributes);
+  const hasBias = inputs.length > 2;
+  const processBias = hasBias ? "value += getBiasForMatmul();" : "";
+  const getBiasForMatmulSnippet = hasBias ? `${getBiasForMatmul(coordsDataType, allGlChannels, inputs[2].dims, outputShape, false)}` : "";
+  const rank = outputShape.length;
+  const arank = aShape.length;
+  const brank = bShape.length;
+  const sharedDim = aShape[aShape.length - 1];
+  const shaderSource = `
+    ${activationFunction}
+    ${getBiasForMatmulSnippet}
+    float process(int indices[${rank}]) {
+        int a[${arank}];
+        int b[${brank}];
+        bcastMatmulIndices_A(indices, a);
+        bcastMatmulIndices_B(indices, b);
+
+        float value;
+        for (int k=0; k<${sharedDim}; ++k) {
+            a[${arank - 1}] = k;
+            b[${brank - 2}] = k;
+            value += _A(a) * _B(b);
+        }
+        ${processBias}
+        ${applyActivation}
+        return value;
+    }`;
+  return {
+    ...metadata,
+    output: { dims: outputShape, type: inputs[0].type, textureType: 0 /* unpacked */ },
+    shaderSource
+  };
+}
+function createMatmulProgramInfoLoader(inputs, activationAttributes) {
+  const metadata = createMatmulProgramMetadata(inputs.length > 2, activationAttributes.activationCacheKey);
+  return { ...metadata, get: () => createMatmulProgramInfo(metadata, inputs, activationAttributes) };
+}
+function getBiasForMatmul(coordsDataType, allGlChannels, inShape, outShape, isPacked) {
+  let unpackedCoordsSnippet = "";
+  const inRank = inShape.length;
+  const outRank = outShape.length;
+  const rankDiff = outRank - inRank;
+  if (outRank < 2 && inRank > 0) {
+    unpackedCoordsSnippet = "coords";
+  } else {
+    unpackedCoordsSnippet = inShape.map((_s, i) => `coords.${allGlChannels[i + rankDiff]}`).join(", ");
+  }
+  const broadcastDims = BroadcastUtil.getBroadcastDims(inShape, outShape);
+  const coordsSnippet = broadcastDims.map((d) => `coords.${allGlChannels[d + rankDiff]} = 0;`).join("\n");
+  const inSize = ShapeUtil.size(inShape);
+  const isInputScalar = inSize === 1;
+  let output = "vec4(outputValue.xx, outputValue.yy)";
+  if (isInputScalar) {
+    output = "vec4(outputValue.x)";
+  }
+  const getBiasForMatmulSource = isPacked ? `
+vec4 getBiasForMatmul() {
+  ${coordsDataType} coords = getOutputCoords();
+  ${coordsSnippet}
+  vec4 outputValue = getBias(${unpackedCoordsSnippet});
+  return ${output};
+}` : `
+float getBiasForMatmul() {
+  ${coordsDataType} coords = getOutputCoords();
+  ${coordsSnippet}
+  return getBias(coords.x);
+}`;
+  return getBiasForMatmulSource;
+}
+var matMul, parseMatMulAttributes, createMatmulProgramMetadata, validateInputs4;
+var init_matmul = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/matmul.ts"() {
+    "use strict";
+    init_util();
+    init_types();
+    init_utils();
+    init_fuse_utils();
+    init_matmul_pack();
+    matMul = (inferenceHandler, inputs, attributes) => {
+      validateInputs4(inputs);
+      if (inferenceHandler.session.pack) {
+        return [inferenceHandler.run(createPackedMatmulProgramInfoLoader(inferenceHandler, inputs, attributes), inputs)];
+      } else {
+        return [inferenceHandler.run(createMatmulProgramInfoLoader(inputs, attributes), inputs)];
+      }
+    };
+    parseMatMulAttributes = (node) => parseInternalActivationAttributes(node.attributes);
+    createMatmulProgramMetadata = (hasBias, cacheHint) => ({
+      name: "MatMul",
+      inputNames: hasBias ? ["A", "B", "Bias"] : ["A", "B"],
+      inputTypes: hasBias ? [0 /* unpacked */, 0 /* unpacked */, 0 /* unpacked */] : [0 /* unpacked */, 0 /* unpacked */],
+      cacheHint
+    });
+    validateInputs4 = (inputs) => {
+      if (!inputs || inputs.length !== 2) {
+        throw new Error("MatMul requires 2 inputs.");
+      }
+      if (inputs[0].dims[inputs[0].dims.length - 1] !== inputs[1].dims[inputs[1].dims.length - 2]) {
+        throw new Error("shared dimension does not match.");
+      }
+      if (inputs[0].type !== "float32" && inputs[0].type !== "float64" || inputs[1].type !== "float32" && inputs[1].type !== "float64") {
+        throw new Error("inputs should be float type");
+      }
+      if (inputs[0].type !== inputs[1].type) {
+        throw new Error("inputs types should match");
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/matmul-pack.ts
+function getBcastSamplerForMatmul(coordsDataType, allGlChannels, inputs, outShape) {
+  let unpackedACoordsSnippet = [];
+  let unpackedBCoordsSnippet = [];
+  const inAShape = inputs[0].dims;
+  const inBShape = inputs[1].dims;
+  const inARank = inAShape.length;
+  const inBRank = inBShape.length;
+  const outRank = outShape.length;
+  const rankADiff = outRank - inARank;
+  const rankBDiff = outRank - inBRank;
+  unpackedACoordsSnippet = inAShape.map((_s, i) => `coords.${allGlChannels[i + rankADiff]}`);
+  unpackedACoordsSnippet[inARank - 1] = "i*2";
+  unpackedACoordsSnippet.join(", ");
+  unpackedBCoordsSnippet = inBShape.map((_s, i) => `coords.${allGlChannels[i + rankBDiff]}`);
+  unpackedBCoordsSnippet[inBRank - 2] = "i*2";
+  unpackedBCoordsSnippet.join(", ");
+  const broadcastADims = BroadcastUtil.getBroadcastDims(inAShape, outShape);
+  const broadcastBDims = BroadcastUtil.getBroadcastDims(inBShape, outShape);
+  const coordsASnippet = broadcastADims.map((d) => `coords.${allGlChannels[d + rankADiff]} = 0;`).join("\n");
+  const coordsBSnippet = broadcastBDims.map((d) => `coords.${allGlChannels[d + rankBDiff]} = 0;`).join("\n");
+  const swapDimSnippet = `int lastDim = coords.${allGlChannels[outRank - 1]};
+  coords.${allGlChannels[outRank - 1]} = coords.${allGlChannels[outRank - 2]};
+  coords.${allGlChannels[outRank - 2]} = lastDim;`;
+  const getBcastSamplerMatmulSource = `
+vec4 getAAtOutCoordsMatmul(int i) {
+  ${coordsDataType} coords = getOutputCoords();
+  ${swapDimSnippet}
+  ${coordsASnippet}
+  vec4 outputValue = getA(${unpackedACoordsSnippet});
+  return outputValue;
+}
+
+vec4 getBAtOutCoordsMatmul(int i) {
+  ${coordsDataType} coords = getOutputCoords();
+  ${swapDimSnippet}
+  ${coordsBSnippet}
+  vec4 outputValue = getB(${unpackedBCoordsSnippet});
+  return outputValue;
+}`;
+  return getBcastSamplerMatmulSource;
+}
+function getA(allGlChannels, rank) {
+  let res = "";
+  for (let i = 0; i < rank - 2; i++) {
+    res += `rc.${allGlChannels[i]}, `;
+  }
+  res += `rc.${allGlChannels[rank - 2]}, i*2`;
+  return res;
+}
+function getB(allGlChannels, rank) {
+  let res = "";
+  for (let i = 0; i < rank - 2; i++) {
+    res += `rc.${allGlChannels[i]}, `;
+  }
+  res += `i*2, rc.${allGlChannels[rank - 1]}`;
+  return res;
+}
+var createPackedMatmulProgramMetadata, createPackedMatmulProgramInfo, createPackedMatmulProgramInfoLoader;
+var init_matmul_pack = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/matmul-pack.ts"() {
+    "use strict";
+    init_util();
+    init_glsl_source();
+    init_types();
+    init_utils();
+    init_fuse_utils();
+    init_matmul();
+    createPackedMatmulProgramMetadata = (hasBias, cacheHint) => ({
+      name: "MatMul (packed)",
+      inputNames: hasBias ? ["A", "B", "Bias"] : ["A", "B"],
+      inputTypes: hasBias ? [2 /* packed */, 2 /* packed */, 2 /* packed */] : [2 /* packed */, 2 /* packed */],
+      cacheHint
+    });
+    createPackedMatmulProgramInfo = (inferenceHandler, metadata, inputs, activationAttributes) => {
+      const hasBias = inputs.length > 2;
+      const processBias = hasBias ? "value += getBiasForMatmul();" : "";
+      const aShape = inputs[0].dims;
+      const bShape = inputs[1].dims;
+      const outputShape = BroadcastUtil.calcShape(aShape, bShape, true);
+      const isBroadcast = !ShapeUtil.areEqual(inputs[0].dims, inputs[1].dims);
+      if (!outputShape) {
+        throw new Error("Can't use matmul on the given tensors");
+      }
+      const sharedDim = aShape[aShape.length - 1];
+      const sharedDimIndex = Math.ceil(sharedDim / 2);
+      const aRank = aShape.length;
+      const bRank = bShape.length;
+      const glsl = getGlsl(inferenceHandler.session.backend.glContext.version);
+      const coordsDataType = getCoordsDataType(outputShape.length);
+      const outRank = outputShape.length;
+      const allGlChannels = getGlChannels();
+      const { activationFunction, applyActivation } = getActivationSnippet(activationAttributes);
+      const getBiasForMatmulSnippet = hasBias ? `${getBiasForMatmul(coordsDataType, allGlChannels, inputs[2].dims, outputShape, true)}` : "";
+      const getBcastedSamplerForMatmulSnippet = isBroadcast ? `${getBcastSamplerForMatmul(coordsDataType, allGlChannels, inputs, outputShape)}` : "";
+      const getSamplerAInLoopSnippet = isBroadcast ? "getAAtOutCoordsMatmul(i)" : `getA(${getA(allGlChannels, aRank)})`;
+      const getSamplerBInLoopSnippet = isBroadcast ? "getBAtOutCoordsMatmul(i)" : `getB(${getB(allGlChannels, bRank)})`;
+      const getOutputCoordsSnippet = isBroadcast ? "" : `${coordsDataType} rc =
+          getOutputCoords(); int lastDim = rc.${allGlChannels[outRank - 1]}; rc.${allGlChannels[outRank - 1]} =
+          rc.${allGlChannels[outRank - 2]}; rc.${allGlChannels[outRank - 2]} = lastDim;
+      `;
+      const shaderSource = `
+            ${getBcastedSamplerForMatmulSnippet}
+            ${getBiasForMatmulSnippet}
+            ${activationFunction}
+            void main() {
+              ${getOutputCoordsSnippet}
+
+              vec4 value = vec4(0);
+              for (int i = 0; i < ${sharedDimIndex}; i++) {
+                vec4 a = ${getSamplerAInLoopSnippet};
+                vec4 b = ${getSamplerBInLoopSnippet};
+
+                value += (a.rrbb * b.rgrg);
+                value += (a.ggaa * b.baba);
+              }
+              ${processBias}
+              ${applyActivation}
+              ${glsl.output} = value;
+            }`;
+      return {
+        ...metadata,
+        output: { dims: outputShape, type: inputs[0].type, textureType: 2 /* packed */ },
+        shaderSource,
+        hasMain: true
+      };
+    };
+    createPackedMatmulProgramInfoLoader = (inferenceHandler, inputs, activationAttributes) => {
+      const metadata = createPackedMatmulProgramMetadata(inputs.length > 2, activationAttributes.activationCacheKey);
+      return {
+        ...metadata,
+        get: () => createPackedMatmulProgramInfo(inferenceHandler, metadata, inputs, activationAttributes)
+      };
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/conv-pack.ts
+var conv2DPacked;
+var init_conv_pack = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/conv-pack.ts"() {
+    "use strict";
+    init_conv();
+    init_im2col_pack();
+    init_matmul_pack();
+    conv2DPacked = (inferenceHandler, inputs, attributes) => {
+      const xshape = inputs[0].dims;
+      const kshape = inputs[1].dims;
+      const outputShape = calculateOutputShape(xshape, kshape, attributes.dilations, attributes.pads, attributes.strides);
+      const im2colOutput = inferenceHandler.run(
+        createPackedIm2ColProgramInfoLoader(inferenceHandler, inputs[0], inputs[1], outputShape, attributes),
+        [inputs[0]]
+      );
+      const kernelReshaped = inferenceHandler.reshapePacked(inputs[1], [kshape[0], kshape[1] * kshape[2] * kshape[3]]);
+      const matmulInputs = inputs.length === 3 ? [kernelReshaped, im2colOutput, inputs[2]] : [kernelReshaped, im2colOutput];
+      const matmulOutput = inferenceHandler.run(
+        createPackedMatmulProgramInfoLoader(inferenceHandler, matmulInputs, attributes),
+        matmulInputs
+      );
+      const outputReshaped = inferenceHandler.reshapePacked(matmulOutput, outputShape);
+      return outputReshaped;
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/im2col.ts
+var createIm2ColProgramMetadata, createIm2ColProgramInfo, createIm2ColProgramInfoLoader, calculateIm2ColDims;
+var init_im2col = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/im2col.ts"() {
+    "use strict";
+    init_types();
+    createIm2ColProgramMetadata = (cacheHint) => ({
+      name: "Im2Col",
+      inputNames: ["X"],
+      inputTypes: [0 /* unpacked */],
+      cacheHint
+    });
+    createIm2ColProgramInfo = (_inferenceHandler, metadata, x, w, outputShape, attributes) => {
+      const xshape = x.dims;
+      const wshape = w.dims;
+      const rank = outputShape.length;
+      const im2colDims = calculateIm2ColDims(xshape, wshape, outputShape, 4);
+      const shaderSource = `
+        const int XC = ${xshape[1]};
+        const int XH = ${xshape[2]};
+        const int XW = ${xshape[3]};
+        const int KH = ${attributes.kernelShape[0]};
+        const int KW = ${attributes.kernelShape[1]};
+        const int dilationH = ${attributes.dilations[0]};
+        const int dilationW = ${attributes.dilations[1]};
+        const int strideH = ${attributes.strides[0]};
+        const int strideW = ${attributes.strides[1]};
+        const int padH = ${attributes.pads[0]};
+        const int padW = ${attributes.pads[1]};
+        const int KHKW = KH*KW;
+        const int XCKHKW = XC * KHKW;
+        const int outputChannels = 4;
+        vec4 process(int indices[${rank}]) {
+          int b  = indices[0]; // batch size
+          int oh = indices[1] * strideH - padH; //output height
+          int ow = indices[2] * strideW - padW; //output width
+          int p = indices[3] * outputChannels; //patch
+          vec4 value = vec4(0.0);
+          for(int i=0; i < outputChannels; ++i) {
+            if(p < XCKHKW) {
+              int patchC = p / KHKW;
+              int patchH = (p - patchC*KHKW) / KW;
+              int patchW = (p - patchC*KHKW) - patchH * KW;
+              int xh2 = oh + patchH * dilationH;
+              int xw2 = ow + patchW * dilationW;
+              int x[${xshape.length}];
+              x[0] = b;
+              x[1] = patchC;
+              x[2] = xh2;
+              x[3] = xw2;
+              if(xh2 >= 0 &&
+                  xh2 < XH &&
+                  xw2 >= 0 &&
+                  xw2 < XW) {
+                value[i] = _X(x);
+              }
+            }
+            ++p;
+          }
+          return value;
+        }
+        `;
+      return {
+        ...metadata,
+        output: { dims: im2colDims, type: x.type, textureType: 4 /* packedLastDimension */ },
+        shaderSource
+      };
+    };
+    createIm2ColProgramInfoLoader = (inferenceHandler, x, w, outputShape, attributes) => {
+      const metadata = createIm2ColProgramMetadata(attributes.cacheKey);
+      return {
+        ...metadata,
+        get: () => createIm2ColProgramInfo(inferenceHandler, metadata, x, w, outputShape, attributes)
+      };
+    };
+    calculateIm2ColDims = (inputShape, kernelShape, outputShape, channels = 4) => [
+      outputShape[0],
+      outputShape[2],
+      outputShape[3],
+      Math.ceil(inputShape[1] * kernelShape[2] * kernelShape[3] / channels)
+    ];
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/dot-product.ts
+var createDotProductProgramMetadata, createDotProductProgramInfo, createDotProductProgramInfoLoader;
+var init_dot_product = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/dot-product.ts"() {
+    "use strict";
+    init_util();
+    init_glsl_source();
+    init_types();
+    init_fuse_utils();
+    init_im2col();
+    createDotProductProgramMetadata = (hasBias, attributes) => ({
+      name: "ConvDotProduct",
+      inputNames: hasBias ? ["Im2Col", "K", "B"] : ["Im2Col", "K"],
+      inputTypes: hasBias ? [0 /* unpacked */, 4 /* packedLastDimension */, 0 /* unpacked */] : [0 /* unpacked */, 4 /* packedLastDimension */],
+      cacheKey: attributes.activationCacheKey
+    });
+    createDotProductProgramInfo = (inferenceHandler, metadata, inputs, outputShape, attributes) => {
+      const xshape = inputs[0].dims;
+      const kshape = inputs[1].dims;
+      const adjustedKernelShape = [kshape[0], Math.ceil(xshape[1] * kshape[2] * kshape[3] / 4)];
+      const im2colShape = calculateIm2ColDims(xshape, kshape, outputShape);
+      const [kWidth, kHeight] = inferenceHandler.calculateTextureWidthAndHeight(
+        adjustedKernelShape,
+        4 /* packedLastDimension */
+      );
+      const im2colStrides = ShapeUtil.computeStrides(im2colShape);
+      const [im2colWidth, im2colHeight] = inferenceHandler.calculateTextureWidthAndHeight(
+        im2colShape,
+        4 /* packedLastDimension */
+      );
+      const rank = outputShape.length;
+      const initValue = inputs.length < 3 ? "0.0" : "_B(b)";
+      const sharedDim = Math.ceil(xshape[1] * kshape[2] * kshape[3] / 4);
+      const { activationFunction, applyActivation } = getActivationSnippet(attributes);
+      const glsl = getGlsl(inferenceHandler.session.backend.glContext.version);
+      const shaderSource = `
+${activationFunction}
+float process(int indices[${rank}]) {
+  int b[1];
+  b[0] = indices[1];
+  int im2col[4];
+  im2col[0] = indices[0];
+  im2col[1] = indices[2];
+  im2col[2] = indices[3];
+  int im2colOffset = im2col[0] * ${im2colStrides[0]} + im2col[1] * ${im2colStrides[1]} + im2col[2] * ${im2colStrides[2]};
+  int kernelOffset = indices[1] * ${adjustedKernelShape[1]};
+  float value = ${initValue};
+  for (int i = 0; i < ${sharedDim}; ++i) {
+    vec2 im2colCoords = offsetToCoords(im2colOffset, ${im2colWidth}, ${im2colHeight});
+    vec2 kernelCoords = offsetToCoords(kernelOffset, ${kWidth}, ${kHeight});
+    value += dot(${glsl.texture2D}(Im2Col, im2colCoords), ${glsl.texture2D}(K, kernelCoords));
+    ++im2colOffset;
+    ++kernelOffset;
+  }
+  ${applyActivation}
+  return value;
+}`;
+      return {
+        ...metadata,
+        output: { dims: outputShape, type: inputs[0].type, textureType: 0 /* unpacked */ },
+        shaderSource
+      };
+    };
+    createDotProductProgramInfoLoader = (inferenceHandler, inputs, outputShape, attributes) => {
+      const metadata = createDotProductProgramMetadata(inputs.length > 2, attributes);
+      return {
+        ...metadata,
+        get: () => createDotProductProgramInfo(inferenceHandler, metadata, inputs, outputShape, attributes)
+      };
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/conv.ts
+var calculateOutputShape, conv, conv2d, conv2DUnpackedPointwise, conv2DUnpacked, getAdjustedConvAttributes, parseConvAttributes, validateInputs5;
+var init_conv = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/conv.ts"() {
+    "use strict";
+    init_attribute_with_cache_key();
+    init_util();
+    init_conv_grouped();
+    init_conv_pack();
+    init_dot_product();
+    init_fuse_utils();
+    init_im2col();
+    init_matmul();
+    calculateOutputShape = (inputShape, kernelShape, dilations, adjustPads, strides) => {
+      const batchSize = inputShape[0];
+      const inputSpatialShape = inputShape.slice(2);
+      const spatialRank = inputSpatialShape.length;
+      const outChannels = kernelShape[0];
+      const kernelSpatialShape = kernelShape.slice(2);
+      const dilatedKernelShape = kernelSpatialShape.map((v, i) => v + (v - 1) * (dilations[i] - 1));
+      const inputSpatialShapeWithPad = inputSpatialShape.map((v, i) => v + adjustPads[i] + adjustPads[i + spatialRank]);
+      const outputSpatialShape = inputSpatialShapeWithPad.map(
+        (v, i) => Math.floor((v - dilatedKernelShape[i] + strides[i]) / strides[i])
+      );
+      const outputShape = [batchSize, outChannels].concat(...outputSpatialShape);
+      return outputShape;
+    };
+    conv = (inferenceHandler, inputs, attributes) => {
+      validateInputs5(inputs, attributes);
+      return conv2d(inferenceHandler, inputs, attributes);
+    };
+    conv2d = (inferenceHandler, inputs, attributes) => {
+      const adjustedAttributes = getAdjustedConvAttributes(attributes, inputs);
+      const packMode = inferenceHandler.session.pack;
+      const isPointwise = adjustedAttributes.kernelShape[0] === 1 && adjustedAttributes.kernelShape[1] === 1;
+      if (adjustedAttributes.group > 1) {
+        const result = inferenceHandler.run(
+          createUnpackedGroupedConvProgramInfoLoader(inferenceHandler, inputs, adjustedAttributes),
+          inputs
+        );
+        return [result];
+      } else if (isPointwise && packMode) {
+        return [conv2DUnpackedPointwise(inferenceHandler, inputs, adjustedAttributes)];
+      } else if (packMode && inputs[0].dims.length === 4 && inputs[0].dims[0] === 1 && !isPointwise) {
+        return [conv2DPacked(inferenceHandler, inputs, adjustedAttributes)];
+      } else {
+        return [conv2DUnpacked(inferenceHandler, inputs, adjustedAttributes)];
+      }
+    };
+    conv2DUnpackedPointwise = (inferenceHandler, inputs, attributes) => {
+      const xshape = inputs[0].dims;
+      const kshape = inputs[1].dims;
+      const outputShape = calculateOutputShape(xshape, kshape, attributes.dilations, attributes.pads, attributes.strides);
+      const reshapedX = inferenceHandler.reshapeUnpacked(inputs[0], [xshape[1], xshape[2] * xshape[3]]);
+      const reshapedK = inferenceHandler.reshapeUnpacked(inputs[1], [kshape[0], kshape[1]]);
+      const matmulInputs = inputs.length > 2 ? [reshapedK, reshapedX, inputs[2]] : [reshapedK, reshapedX];
+      const matmulOutput = inferenceHandler.run(createMatmulProgramInfoLoader(matmulInputs, attributes), matmulInputs);
+      return inferenceHandler.reshapeUnpacked(matmulOutput, outputShape);
+    };
+    conv2DUnpacked = (inferenceHandler, inputs, attributes) => {
+      const xshape = inputs[0].dims;
+      const kshape = inputs[1].dims;
+      const outputShape = calculateOutputShape(xshape, kshape, attributes.dilations, attributes.pads, attributes.strides);
+      const xIm2Col = inferenceHandler.run(
+        createIm2ColProgramInfoLoader(inferenceHandler, inputs[0], inputs[1], outputShape, attributes),
+        [inputs[0]]
+      );
+      const dotProductInputs = inputs.length === 3 ? [xIm2Col, inputs[1], inputs[2]] : [xIm2Col, inputs[1]];
+      const output = inferenceHandler.run(
+        createDotProductProgramInfoLoader(inferenceHandler, inputs, outputShape, attributes),
+        dotProductInputs
+      );
+      return output;
+    };
+    getAdjustedConvAttributes = (attributes, inputs) => {
+      const kernelShape = attributes.kernelShape.slice();
+      if (attributes.kernelShape.length === 0) {
+        for (let i = 2; i < inputs[1].dims.length; ++i) {
+          kernelShape.push(inputs[1].dims[i]);
+        }
+      }
+      const pads = attributes.pads.slice();
+      PoolConvUtil.adjustPadsBasedOnAutoPad(
+        inputs[0].dims,
+        attributes.strides,
+        attributes.dilations,
+        kernelShape,
+        pads,
+        attributes.autoPad
+      );
+      const newAttributes = Object.assign({}, attributes);
+      Object.assign(newAttributes, { kernelShape, pads, cacheKey: attributes.cacheKey });
+      return newAttributes;
+    };
+    parseConvAttributes = (node) => {
+      const attributes = node.attributes;
+      const activationAttributes = parseInternalActivationAttributes(attributes);
+      const autoPad = attributes.getString("auto_pad", "NOTSET");
+      const dilations = attributes.getInts("dilations", [1, 1]);
+      const group = attributes.getInt("group", 1);
+      const kernelShape = attributes.getInts("kernel_shape", []);
+      const pads = attributes.getInts("pads", [0, 0, 0, 0]);
+      const strides = attributes.getInts("strides", [1, 1]);
+      return createAttributeWithCacheKey({
+        autoPad,
+        dilations,
+        group,
+        kernelShape,
+        pads,
+        strides,
+        ...activationAttributes
+      });
+    };
+    validateInputs5 = (inputs, attributes) => {
+      if (!inputs || inputs.length !== 2 && inputs.length !== 3) {
+        throw new Error("Conv requires 2 or 3 inputs");
+      }
+      if (inputs[0].dims.length !== 4 || inputs[1].dims.length !== 4) {
+        throw new Error("currently only support 2-dimensional conv");
+      }
+      const dataChannel = inputs[0].dims[1];
+      const filterInChannel = inputs[1].dims[1] * attributes.group;
+      if (dataChannel !== filterInChannel) {
+        throw new Error("FILTER_IN_CHANNEL should be equal to DATA_CHANNEL");
+      }
+      if (inputs.length === 3 && (inputs[2].dims.length !== 1 || inputs[1].dims[0] !== inputs[2].dims[0])) {
+        throw new Error("invalid bias");
+      }
+      const spatialRank = inputs[0].dims.length - 2;
+      if (attributes.dilations.length !== spatialRank) {
+        throw new Error(`dilations should be ${spatialRank}D`);
+      }
+      if (attributes.strides.length !== spatialRank) {
+        throw new Error(`strides should be ${spatialRank}D`);
+      }
+      if (attributes.pads.length !== spatialRank * 2) {
+        throw new Error(`pads should be ${spatialRank * 2}D`);
+      }
+      if (attributes.kernelShape.length !== 0 && attributes.kernelShape.length !== inputs[1].dims.length - 2) {
+        throw new Error("invalid kernel shape");
+      }
+      if (inputs[0].type !== "float32" || inputs[1].type !== "float32") {
+        throw new Error("Conv input(X,W) should be float tensor");
+      }
+      if (inputs.length === 3 && inputs[2].type !== "float32") {
+        throw new Error("Conv input(bias) should be float tensor");
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/conv-transpose.ts
+var computeTotalPad, distributePadding, calculateOutputShapeAndPads, convTranspose, convTranspose2d, createConvTransposeProgramMetadata, createUnpackedConvTransposeProgramInfo, createUnpackedConvTransposeProgramInfoLoader, convTranspose2DUnpacked, getAdjustedConvTransposeAttributes, parseConvTransposeAttributes, validateInputs6;
+var init_conv_transpose = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/conv-transpose.ts"() {
+    "use strict";
+    init_attribute_with_cache_key();
+    init_glsl_source();
+    init_types();
+    init_fuse_utils();
+    computeTotalPad = (inDim, stride, adj, kernel, dilation, outSize) => (inDim - 1) * stride + adj + (kernel - 1) * dilation + 1 - outSize;
+    distributePadding = (totalPad, autoPad, pads, head, tail) => {
+      const smallPad = Math.floor(totalPad / 2);
+      if (autoPad === "SAME_UPPER") {
+        pads[head] = smallPad;
+        pads[tail] = totalPad - smallPad;
+      } else if (autoPad === "SAME_LOWER") {
+        pads[head] = totalPad - smallPad;
+        pads[tail] = smallPad;
+      }
+    };
+    calculateOutputShapeAndPads = (inputShape, kernelShape, dilations, autoPad, pads, strides, outputPadding, outputShape) => {
+      const spatialRank = inputShape.length - 2;
+      const updateShape = outputShape.length === 0;
+      for (let i = 0; i < spatialRank; ++i) {
+        const outSize = updateShape ? inputShape[i + 2] * strides[i] : outputShape[i];
+        const totalPad = computeTotalPad(inputShape[i + 2], strides[i], pads[i], kernelShape[i], dilations[i], outSize);
+        distributePadding(totalPad, autoPad, pads, i, i + spatialRank);
+        if (updateShape) {
+          outputShape.push(
+            strides[i] * (inputShape[i + 2] - 1) + outputPadding[i] + (kernelShape[i] - 1) * dilations[i] + 1 - pads[i] - pads[i + spatialRank]
+          );
+        }
+      }
+    };
+    convTranspose = (inferenceHandler, inputs, attributes) => {
+      validateInputs6(inputs, attributes);
+      return convTranspose2d(inferenceHandler, inputs, attributes);
+    };
+    convTranspose2d = (inferenceHandler, inputs, attributes) => {
+      const adjustedAttributes = getAdjustedConvTransposeAttributes(attributes, inputs);
+      return [convTranspose2DUnpacked(inferenceHandler, inputs, adjustedAttributes)];
+    };
+    createConvTransposeProgramMetadata = (hasBias, cacheHint) => ({
+      name: "ConvTranspose",
+      inputNames: hasBias ? ["X", "W", "B"] : ["X", "W"],
+      inputTypes: hasBias ? [0 /* unpacked */, 0 /* unpacked */, 0 /* unpacked */] : [0 /* unpacked */, 0 /* unpacked */],
+      cacheHint
+    });
+    createUnpackedConvTransposeProgramInfo = (inferenceHandler, inputs, metadata, attributes) => {
+      const hasBias = inputs.length > 2;
+      const valueInit = hasBias ? "getB(output_channel)" : "0.0";
+      const xShape = inputs[0].dims;
+      const wShape = inputs[1].dims;
+      const outputChannelsPerGroup = wShape[1];
+      const inputChannelsPerGroup = wShape[0] / attributes.group;
+      const outputShape = [inputs[0].dims[0], inputs[1].dims[1] * attributes.group, ...attributes.outputShape];
+      const glsl = getGlsl(inferenceHandler.session.backend.glContext.version);
+      const { activationFunction, applyActivation } = getActivationSnippet(attributes);
+      const shaderSource = `
+  const ivec2 strides = ivec2(${attributes.strides[0]}, ${attributes.strides[1]});
+  const ivec2 pads = ivec2(${attributes.pads[0]}, ${attributes.pads[1]});
+  ${activationFunction}
+  void main() {
+    ivec4 coords = getOutputCoords();
+    int batch = coords.x;
+    int output_channel = coords.y;
+
+    ivec2 loc = coords.zw + pads;
+
+    int group_id = output_channel / ${outputChannelsPerGroup};
+    int wOutChannel = output_channel - group_id * ${outputChannelsPerGroup};
+
+    float value = ${valueInit};
+    for (int inChannelOffset = 0; inChannelOffset < ${inputChannelsPerGroup}; inChannelOffset++) {
+      int input_channel = group_id * ${inputChannelsPerGroup} + inChannelOffset;
+      for (int wWOff = 0; wWOff < ${wShape[2]}; wWOff++) {
+        for (int wHOff = 0; wHOff < ${wShape[3]}; wHOff++) {
+          ivec2 wOff = ivec2(wWOff * ${attributes.dilations[0]}, wHOff * ${attributes.dilations[1]});
+          ivec2 wLoc = loc - wOff;
+          ivec2 wLocIn = wLoc / strides;
+          if (
+            wLocIn * strides == wLoc &&
+            wLocIn.x >= 0 && wLocIn.x < ${xShape[2]} &&
+            wLocIn.y >= 0 && wLocIn.y < ${xShape[3]}
+          ) {
+            float xVal = getX(batch, input_channel, wLocIn.y, wLocIn.x);
+            float wVal = getW(input_channel, wOutChannel, wHOff, wWOff);
+            value += xVal * wVal;
+          }
+        }
+      }
+    }
+    ${applyActivation}
+    ${glsl.output} = vec4(value, .0, .0, .0);
+  }
+`;
+      return {
+        ...metadata,
+        output: { dims: outputShape, type: inputs[0].type, textureType: 0 /* unpacked */ },
+        shaderSource,
+        hasMain: true
+      };
+    };
+    createUnpackedConvTransposeProgramInfoLoader = (inferenceHandler, inputs, attributes) => {
+      const metadata = createConvTransposeProgramMetadata(inputs.length > 2, attributes.cacheKey);
+      return {
+        ...metadata,
+        get: () => createUnpackedConvTransposeProgramInfo(inferenceHandler, inputs, metadata, attributes)
+      };
+    };
+    convTranspose2DUnpacked = (inferenceHandler, inputs, attributes) => {
+      const result = inferenceHandler.run(
+        createUnpackedConvTransposeProgramInfoLoader(inferenceHandler, inputs, attributes),
+        inputs
+      );
+      return result;
+    };
+    getAdjustedConvTransposeAttributes = (attributes, inputs) => {
+      const kernelShape = attributes.kernelShape.slice();
+      if (attributes.kernelShape.length === 0) {
+        for (let i = 2; i < inputs[1].dims.length; ++i) {
+          kernelShape.push(inputs[1].dims[i]);
+        }
+      }
+      const pads = attributes.pads.slice();
+      const outputShape = attributes.outputShape.slice();
+      const inputShape = inputs[0].dims;
+      calculateOutputShapeAndPads(
+        inputShape,
+        kernelShape,
+        attributes.dilations,
+        attributes.autoPad,
+        pads,
+        attributes.strides,
+        attributes.outputPadding,
+        outputShape
+      );
+      const newAttributes = Object.assign({}, attributes);
+      Object.assign(newAttributes, { kernelShape, pads, outputShape, cacheKey: attributes.cacheKey });
+      return newAttributes;
+    };
+    parseConvTransposeAttributes = (node) => {
+      const attributes = node.attributes;
+      const activationAttributes = parseInternalActivationAttributes(attributes);
+      const autoPad = attributes.getString("auto_pad", "NOTSET");
+      const dilations = attributes.getInts("dilations", [1, 1]);
+      const group = attributes.getInt("group", 1);
+      const kernelShape = attributes.getInts("kernel_shape", []);
+      const outputPadding = attributes.getInts("output_padding", [0, 0]);
+      const outputShape = attributes.getInts("output_shape", []);
+      const pads = attributes.getInts("pads", [0, 0, 0, 0]);
+      const strides = attributes.getInts("strides", [1, 1]);
+      return createAttributeWithCacheKey({
+        autoPad,
+        dilations,
+        group,
+        kernelShape,
+        outputPadding,
+        outputShape,
+        pads,
+        strides,
+        ...activationAttributes
+      });
+    };
+    validateInputs6 = (inputs, attributes) => {
+      if (!inputs || inputs.length !== 2 && inputs.length !== 3) {
+        throw new Error("Conv requires 2 or 3 inputs");
+      }
+      if (inputs[0].dims.length !== 4 || inputs[1].dims.length !== 4) {
+        throw new Error("currently only support 2-dimensional conv");
+      }
+      const dataChannel = inputs[0].dims[1];
+      const filterInChannel = inputs[1].dims[0];
+      if (dataChannel !== filterInChannel) {
+        throw new Error("FILTER_IN_CHANNEL should be equal to DATA_CHANNEL");
+      }
+      const featureMaps = inputs[1].dims[1] * attributes.group;
+      if (inputs.length === 3 && (inputs[2].dims.length !== 1 || inputs[2].dims[0] !== featureMaps)) {
+        throw new Error("invalid bias");
+      }
+      const spatialRank = inputs[0].dims.length - 2;
+      if (attributes.dilations.length !== spatialRank) {
+        throw new Error(`dilations should be ${spatialRank}D`);
+      }
+      if (attributes.strides.length !== spatialRank) {
+        throw new Error(`strides should be ${spatialRank}D`);
+      }
+      if (attributes.pads.length !== spatialRank * 2) {
+        throw new Error(`pads should be ${spatialRank * 2}D`);
+      }
+      if (attributes.outputPadding.length !== spatialRank) {
+        throw new Error(`output_padding should be ${spatialRank}D`);
+      }
+      if (attributes.kernelShape.length !== 0 && attributes.kernelShape.length !== inputs[1].dims.length - 2) {
+        throw new Error("invalid kernel shape");
+      }
+      if (attributes.outputShape.length !== 0 && attributes.outputShape.length !== inputs[0].dims.length - 2) {
+        throw new Error("invalid output shape");
+      }
+      if (inputs[0].type !== "float32" || inputs[1].type !== "float32") {
+        throw new Error("ConvTranspose input(X,W) should be float tensor");
+      }
+      if (inputs.length === 3 && inputs[2].type !== "float32") {
+        throw new Error("ConvTranspose input(bias) should be float tensor");
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/transpose.ts
+var transposeProgramMetadata, transpose, parseTransposeAttributes, createTransposeProgramInfo, getAdjustedPerm, getOutputShape, getPermFunctionBody, validateInputs7;
+var init_transpose = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/transpose.ts"() {
+    "use strict";
+    init_attribute_with_cache_key();
+    init_util();
+    init_types();
+    transposeProgramMetadata = {
+      name: "Transpose",
+      inputNames: ["A"],
+      inputTypes: [0 /* unpacked */]
+    };
+    transpose = (inferenceHandler, inputs, attributes) => {
+      validateInputs7(inputs);
+      const output = inferenceHandler.run(
+        {
+          ...transposeProgramMetadata,
+          cacheHint: attributes.cacheKey,
+          get: () => createTransposeProgramInfo(inferenceHandler, inputs[0], attributes.perm)
+        },
+        inputs
+      );
+      return [output];
+    };
+    parseTransposeAttributes = (node) => createAttributeWithCacheKey({ perm: node.attributes.getInts("perm", []) });
+    createTransposeProgramInfo = (_inferenceHandler, input, perm) => {
+      const inputShape = input.dims;
+      perm = getAdjustedPerm(inputShape, perm);
+      const unpackedOutputShape = getOutputShape(inputShape, perm);
+      const rank = inputShape.length;
+      const shaderSource = `
+      ${getPermFunctionBody("perm", perm, rank)}
+      float process(int indices[${rank}]) {
+        int a[${rank}];
+        perm(a, indices);
+        return _A(a);
+      }`;
+      return {
+        ...transposeProgramMetadata,
+        output: { dims: unpackedOutputShape, type: input.type, textureType: 0 /* unpacked */ },
+        shaderSource
+      };
+    };
+    getAdjustedPerm = (inputShape, perm) => {
+      if (perm && perm.length !== inputShape.length) {
+        perm = [...inputShape.keys()].reverse();
+      }
+      return perm;
+    };
+    getOutputShape = (inputShape, perm) => {
+      perm = getAdjustedPerm(inputShape, perm);
+      return ShapeUtil.sortBasedOnPerm(inputShape, perm);
+    };
+    getPermFunctionBody = (name2, perm, rank) => {
+      const reverseFunc = [];
+      reverseFunc.push(`void ${name2}(out int a[${rank}], int src[${rank}]) {`);
+      for (let i = 0; i < rank; ++i) {
+        reverseFunc.push(`	a[${perm[i]}]=src[${i}];`);
+      }
+      reverseFunc.push("	}");
+      return reverseFunc.join("\n");
+    };
+    validateInputs7 = (inputs) => {
+      if (!inputs || inputs.length !== 1) {
+        throw new Error("Transpose requires 1 input.");
+      }
+      if (inputs[0].type !== "float32" && inputs[0].type !== "float64") {
+        throw new Error("input should be float tensor");
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/depth-to-space.ts
+var depthToSpace, parseDepthToSpaceAttributes, validateInputs8;
+var init_depth_to_space = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/depth-to-space.ts"() {
+    "use strict";
+    init_transpose();
+    depthToSpace = (inferenceHandler, inputs, attributes) => {
+      validateInputs8(inputs);
+      const blocksize = attributes.blocksize;
+      const blocksizeSqr = blocksize * blocksize;
+      const transposePerm = attributes.mode === "DCR" ? [0, 3, 4, 1, 5, 2] : [0, 1, 4, 2, 5, 3];
+      const firstReshapeShape = attributes.mode === "DCR" ? [
+        inputs[0].dims[0],
+        blocksize,
+        blocksize,
+        inputs[0].dims[1] / blocksizeSqr,
+        inputs[0].dims[2],
+        inputs[0].dims[3]
+      ] : [
+        inputs[0].dims[0],
+        inputs[0].dims[1] / blocksizeSqr,
+        blocksize,
+        blocksize,
+        inputs[0].dims[2],
+        inputs[0].dims[3]
+      ];
+      const firstReshapedTensor = inferenceHandler.reshapeUnpacked(inputs[0], firstReshapeShape);
+      const transposeAttributes = { perm: transposePerm, cacheKey: `${transposePerm}` };
+      const [transposeOutput] = transpose(inferenceHandler, [firstReshapedTensor], transposeAttributes);
+      const secondReshapeShape = [
+        inputs[0].dims[0],
+        inputs[0].dims[1] / blocksizeSqr,
+        inputs[0].dims[2] * blocksize,
+        inputs[0].dims[3] * blocksize
+      ];
+      const result = inferenceHandler.reshapeUnpacked(transposeOutput, secondReshapeShape);
+      return [result];
+    };
+    parseDepthToSpaceAttributes = (node) => {
+      const blocksize = node.attributes.getInt("blocksize");
+      if (blocksize < 1) {
+        throw new Error(`blocksize must be >= 1, but got : ${blocksize} for DepthToSpace`);
+      }
+      const mode = node.attributes.getString("mode", "DCR");
+      if (mode !== "DCR" && mode !== "CRD") {
+        throw new Error(`unrecognized mode: ${mode} for DepthToSpace`);
+      }
+      return { mode, blocksize };
+    };
+    validateInputs8 = (inputs) => {
+      if (inputs.length !== 1) {
+        throw new Error(`DepthToSpace expect 1 inputs, but got ${inputs.length}`);
+      }
+      if (inputs[0].type === "string" || inputs[0].dims.length !== 4) {
+        throw new TypeError("DepthToSpace input should be a 4-D numeric tensor");
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/flatten.ts
+var flatten, parseFlattenAttributes, validateInputs9;
+var init_flatten = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/flatten.ts"() {
+    "use strict";
+    init_util();
+    flatten = (inferenceHandler, inputs, axis) => {
+      validateInputs9(inputs, axis);
+      const outputDims = ShapeUtil.flattenShape(inputs[0].dims, axis);
+      return [inferenceHandler.reshapeUnpacked(inputs[0], outputDims)];
+    };
+    parseFlattenAttributes = (node) => node.attributes.getInt("axis", 1);
+    validateInputs9 = (inputs, axis) => {
+      if (!inputs || inputs.length !== 1) {
+        throw new Error("Flatten requires 1 input.");
+      }
+      const r = inputs[0].dims.length;
+      if (r === 0) {
+        throw new Error("scalar tensor is not supported.");
+      }
+      if (axis < -r || axis > r) {
+        throw new Error("Invalid axis");
+      }
+      if (inputs[0].type === "string") {
+        throw new Error("string tensor is not supported.");
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/operators.ts
+var NUMBER_TYPES;
+var init_operators = __esm({
+  "web/lib/onnxjs/operators.ts"() {
+    "use strict";
+    NUMBER_TYPES = [
+      "float32",
+      "float64",
+      "int32",
+      "int16",
+      "int8",
+      "uint16",
+      "uint32",
+      "uint8"
+    ];
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/gather.ts
+var gather, parseGatherAttributes, gatherProgramMetadata, createGatherProgramInfo, createGatherProgramInfoLoader, validateInputs10;
+var init_gather = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/gather.ts"() {
+    "use strict";
+    init_attribute_with_cache_key();
+    init_operators();
+    init_util();
+    init_types();
+    gather = (inferenceHandler, inputs, attributes) => {
+      validateInputs10(inputs, attributes.axis);
+      const output = inferenceHandler.run(createGatherProgramInfoLoader(inferenceHandler, inputs, attributes), inputs);
+      return [output];
+    };
+    parseGatherAttributes = (node) => createAttributeWithCacheKey({ axis: node.attributes.getInt("axis", 0) });
+    gatherProgramMetadata = {
+      name: "Gather",
+      inputNames: ["A", "B"],
+      inputTypes: [0 /* unpacked */, 0 /* unpacked */]
+    };
+    createGatherProgramInfo = (_handler, metadata, inputs, axis) => {
+      const inputShape = inputs[0].dims.slice();
+      const indexDataShape = inputs[1].dims.slice();
+      const outputShape = new Array(inputShape.length + indexDataShape.length - 1);
+      axis = ShapeUtil.normalizeAxis(axis, inputShape.length);
+      const indexCopyOps = [];
+      for (let i = 0; i < outputShape.length; i++) {
+        if (i < axis) {
+          outputShape[i] = inputShape[i];
+          indexCopyOps.push(`inputIdx[${i}] = outputIdx[${i}];`);
+        } else {
+          if (i < axis + indexDataShape.length) {
+            outputShape[i] = indexDataShape[i - axis];
+            indexCopyOps.push(`indexDataIdx[${i - axis}] = outputIdx[${i}];`);
+          } else {
+            outputShape[i] = inputShape[i - indexDataShape.length + 1];
+            indexCopyOps.push(`inputIdx[${i - indexDataShape.length + 1}] = outputIdx[${i}];`);
+          }
+        }
+      }
+      const orank = outputShape.length || 1;
+      const irank = inputShape.length;
+      const iDrank = indexDataShape.length || 1;
+      const shaderSource = `
+      float process(int outputIdx[${orank}]) {
+        int inputIdx[${irank}];
+        int indexDataIdx[${iDrank}];
+        indexDataIdx[0] = 0;
+        ${indexCopyOps.join("\n        ")}
+        int idx = int(_B(indexDataIdx));
+        inputIdx[${axis}] = idx < 0 ? idx + ${inputShape[axis]} : idx;
+        return _A(inputIdx);
+      }`;
+      return {
+        ...metadata,
+        output: { dims: outputShape, type: inputs[0].type, textureType: 0 /* unpacked */ },
+        shaderSource
+      };
+    };
+    createGatherProgramInfoLoader = (handler, inputs, attributes) => {
+      const metadata = { ...gatherProgramMetadata, cacheHint: attributes.cacheKey };
+      return { ...metadata, get: () => createGatherProgramInfo(handler, metadata, inputs, attributes.axis) };
+    };
+    validateInputs10 = (inputs, axis) => {
+      if (!inputs || inputs.length !== 2) {
+        throw new Error("Gather requires 2 inputs.");
+      }
+      const tensorRank = inputs[0].dims.length;
+      if (tensorRank < 1) {
+        throw new Error("Invalid input shape.");
+      }
+      if (axis < -tensorRank || axis > tensorRank - 1) {
+        throw new Error("Invalid axis.");
+      }
+      if (NUMBER_TYPES.indexOf(inputs[0].type) === -1) {
+        throw new Error("Invaid input type.");
+      }
+      if (inputs[1].type !== "int32" && inputs[1].type !== "int16") {
+        throw new Error("Invaid input type.");
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/gemm.ts
+var gemm, parseGemmAttributes, parseGemmAttributesV7, parseGemmAttributesV11, createGemmProgramInfoLoader, createGemmProgramInfo, validateInputs11;
+var init_gemm = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/gemm.ts"() {
+    "use strict";
+    init_attribute_with_cache_key();
+    init_util();
+    init_types();
+    gemm = (inferenceHandler, inputs, attributes) => {
+      validateInputs11(inputs, attributes);
+      const output = inferenceHandler.run(createGemmProgramInfoLoader(inputs, attributes), inputs);
+      return [output];
+    };
+    parseGemmAttributes = (node, isOptionalC) => {
+      const transA = node.attributes.getInt("transA", 0) !== 0;
+      const transB = node.attributes.getInt("transB", 0) !== 0;
+      const alpha = node.attributes.getFloat("alpha", 1);
+      const beta = node.attributes.getFloat("beta", 1);
+      return createAttributeWithCacheKey({ transA, transB, alpha, beta, isOptionalC });
+    };
+    parseGemmAttributesV7 = (node) => parseGemmAttributes(node, false);
+    parseGemmAttributesV11 = (node) => parseGemmAttributes(node, true);
+    createGemmProgramInfoLoader = (inputs, attributes) => {
+      const metadata = {
+        name: "Gemm",
+        inputNames: inputs.length === 3 ? ["A", "B", "C"] : ["A", "B"],
+        inputTypes: inputs.length === 3 ? [0 /* unpacked */, 0 /* unpacked */, 0 /* unpacked */] : [0 /* unpacked */, 0 /* unpacked */],
+        key: attributes.cacheKey
+      };
+      return { ...metadata, get: () => createGemmProgramInfo(metadata, inputs, attributes) };
+    };
+    createGemmProgramInfo = (metadata, inputs, attributes) => {
+      const aShape = inputs[0].dims.slice();
+      const bShape = inputs[1].dims.slice();
+      const [M, N] = GemmUtil.getShapeOfGemmResult(
+        aShape,
+        attributes.transA,
+        bShape,
+        attributes.transB,
+        inputs.length === 3 ? inputs[2].dims : void 0
+      );
+      const outputShape = [M, N];
+      if (!outputShape) {
+        throw new Error("Can't use gemm on the given tensors");
+      }
+      let sharedDim = aShape[aShape.length - 1];
+      let line = "";
+      if (attributes.transA) {
+        sharedDim = aShape[0];
+      }
+      if (attributes.transA && attributes.transB) {
+        line = "value += _A_T(a) * _B_T(b);";
+      } else if (attributes.transA && !attributes.transB) {
+        line = "value += _A_T(a) * _B(b);";
+      } else if (!attributes.transA && attributes.transB) {
+        line = "value += _A(a) * _B_T(b);";
+      } else if (!attributes.transA && !attributes.transB) {
+        line = "value += _A(a) * _B(b);";
+      }
+      const rank = outputShape.length;
+      const declareC = inputs.length === 3 ? `int c[${inputs[2].dims.length}];` : "";
+      const broadcastC = inputs.length === 3 ? "bcastIndices_C(indices, c);" : "";
+      const calculateC = inputs.length === 3 ? "value += beta * _C(c);" : "";
+      const shaderSource = `
+      float process(int indices[${rank}]) {
+          int a[${rank}];
+          int b[${rank}];
+          ${declareC}
+
+          copyVec(indices, a);
+          copyVec(indices, b);
+          ${broadcastC}
+
+          float value = 0.0;
+          for (int k=0; k<${sharedDim}; ++k) {
+              a[${rank - 1}] = k;
+              b[${rank - 2}] = k;
+              ${line}
+          }
+
+          value = value * alpha;
+          ${calculateC}
+          return value;
+      }`;
+      return {
+        ...metadata,
+        output: { dims: outputShape, type: inputs[0].type, textureType: 0 /* unpacked */ },
+        variables: [
+          { name: "alpha", type: "float", data: attributes.alpha },
+          { name: "beta", type: "float", data: attributes.beta }
+        ],
+        shaderSource
+      };
+    };
+    validateInputs11 = (inputs, attributes) => {
+      if (!inputs) {
+        throw new Error("Input is missing");
+      }
+      if (attributes.isOptionalC && (inputs.length < 2 || inputs.length > 3)) {
+        throw new Error("Invaid input shape.");
+      }
+      if (!attributes.isOptionalC && inputs.length !== 3) {
+        throw new Error("Gemm requires 3 inputs");
+      }
+      if (inputs.length === 3 && inputs[2].dims.length !== 1 && inputs[2].dims.length !== 2) {
+        throw new Error("Invalid input shape of C");
+      }
+      if (inputs[0].type !== "float32" && inputs[0].type !== "float64" || inputs[1].type !== "float32" && inputs[1].type !== "float64" || inputs.length === 3 && inputs[2].type !== "float32" && inputs[2].type !== "float64") {
+        throw new Error("Invalid input type.");
+      }
+      if (inputs[0].type !== inputs[1].type || inputs.length === 3 && inputs[0].type !== inputs[2].type) {
+        throw new Error("Input types are mismatched");
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/image-scaler.ts
+var imageScaler, parseImageScalerAttributes, imageScalerProgramMetadata, createImageScalerProgramInfo, createImageScalerProgramInfoLoader, createGetBiasMethod, validateInputs12;
+var init_image_scaler = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/image-scaler.ts"() {
+    "use strict";
+    init_attribute_with_cache_key();
+    init_types();
+    imageScaler = (inferenceHandler, inputs, attributes) => {
+      validateInputs12(inputs);
+      const output = inferenceHandler.run(createImageScalerProgramInfoLoader(inferenceHandler, inputs, attributes), inputs);
+      return [output];
+    };
+    parseImageScalerAttributes = (node) => {
+      const scale = node.attributes.getFloat("scale");
+      const bias = node.attributes.getFloats("bias");
+      return createAttributeWithCacheKey({ scale, bias });
+    };
+    imageScalerProgramMetadata = {
+      name: "ImageScaler",
+      inputNames: ["X"],
+      inputTypes: [0 /* unpacked */]
+    };
+    createImageScalerProgramInfo = (_handler, metadata, inputs, attributes) => {
+      const outputShape = inputs[0].dims.slice();
+      const rank = outputShape.length;
+      const getBiasMethod = createGetBiasMethod(attributes.bias.length);
+      const shaderSource = `
+      ${getBiasMethod}
+      float process(int indices[${rank}]) {
+        return _X(indices) * scale + getBias(bias, indices[1]);
+      }`;
+      return {
+        ...metadata,
+        output: { dims: outputShape, type: inputs[0].type, textureType: 0 /* unpacked */ },
+        variables: [
+          { name: "bias", type: "float", arrayLength: attributes.bias.length, data: attributes.bias },
+          { name: "scale", type: "float", data: attributes.scale }
+        ],
+        shaderSource
+      };
+    };
+    createImageScalerProgramInfoLoader = (handler, inputs, attributes) => {
+      const metadata = { ...imageScalerProgramMetadata, cacheHint: attributes.cacheKey };
+      return { ...metadata, get: () => createImageScalerProgramInfo(handler, metadata, inputs, attributes) };
+    };
+    createGetBiasMethod = (numChannels) => {
+      const codeLines = [`float getBias(float bias[${numChannels}], int channel) {`];
+      for (let i = 0; i < numChannels; ++i) {
+        if (i === 0) {
+          codeLines.push(`	if (channel == ${i}) { return bias[${i}]; }`);
+        } else if (i === numChannels - 1) {
+          codeLines.push(`	else { return bias[${i}]; }`);
+        } else {
+          codeLines.push(`	else if (channel == ${i}) { return bias[${i}]; }`);
+        }
+      }
+      codeLines.push("	}");
+      return codeLines.join("\n");
+    };
+    validateInputs12 = (inputs) => {
+      if (!inputs || inputs.length !== 1) {
+        throw new Error("ImageScaler requires 1 input.");
+      }
+      if (inputs[0].dims.length !== 4) {
+        throw new Error("Invalid input shape.");
+      }
+      if (inputs[0].type !== "float32" && inputs[0].type !== "float64") {
+        throw new Error("Invalid input type.");
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/instance-normalization.ts
+var instanceNormalization, parseInstanceNormalizationAttributes, meanAndVarianceProgramMetadata, createMeanAndVarianceProgramInfo, createMeanAndVarianceProgramInfoLoader, computeOutputProgramMetadata, createComputeOutputProgramInfo, createComputeOutputProgramInfoLoader, validateInputs13;
+var init_instance_normalization = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/instance-normalization.ts"() {
+    "use strict";
+    init_glsl_source();
+    init_types();
+    instanceNormalization = (inferenceHandler, inputs, epsilon) => {
+      validateInputs13(inputs);
+      const meanAndVariance = inferenceHandler.run(createMeanAndVarianceProgramInfoLoader(inputs[0]), inputs);
+      const output = inferenceHandler.run(
+        createComputeOutputProgramInfoLoader(inferenceHandler, inputs[0], epsilon, meanAndVariance.dims),
+        [inputs[0], meanAndVariance, inputs[1], inputs[2]]
+      );
+      return [output];
+    };
+    parseInstanceNormalizationAttributes = (node) => node.attributes.getFloat("epsilon", 1e-5);
+    meanAndVarianceProgramMetadata = {
+      name: "InstanceNormalization_MeanAndVariance",
+      inputNames: ["X"],
+      inputTypes: [0 /* unpacked */]
+    };
+    createMeanAndVarianceProgramInfo = (metadata, input) => {
+      const xDims = input.dims.slice();
+      const channel = xDims[1];
+      const channelSize = xDims[2] * xDims[3];
+      const outputShape = [xDims[0], channel];
+      const shaderSource = `
+      vec4 process(int[2] indices) {
+        vec4 v = vec4(0.0);
+        int a[4];
+        a[0] = indices[0];
+        a[1] = indices[1];
+        float temp = 0.0;
+        for(int a2=0; a2<${xDims[2]}; a2++) {
+          a[2] = a2;
+          for(int a3=0; a3<${xDims[3]}; a3++) {
+            a[3] = a3;
+            float x = _X(a);
+            temp += x;
+          }
+        }
+        float mean = temp / float(${channelSize});
+        temp = 0.0;
+        for(int a2=0; a2<${xDims[2]}; a2++) {
+          a[2] = a2;
+          for(int a3=0; a3<${xDims[3]}; a3++) {
+            a[3] = a3;
+            float x = _X(a);
+            temp += (x - mean) * (x - mean);
+          }
+        }
+        v.r = mean;
+        v.g = temp / float(${channelSize});
+
+        return v;
+      }`;
+      return {
+        ...metadata,
+        output: { dims: outputShape, type: input.type, textureType: 4 /* packedLastDimension */ },
+        shaderSource
+      };
+    };
+    createMeanAndVarianceProgramInfoLoader = (input) => ({
+      ...meanAndVarianceProgramMetadata,
+      get: () => createMeanAndVarianceProgramInfo(meanAndVarianceProgramMetadata, input)
+    });
+    computeOutputProgramMetadata = {
+      name: "InstanceNormalization_ComputeOutput",
+      inputNames: ["X", "MeanAndVariance", "Scale", "B"],
+      inputTypes: [0 /* unpacked */, 4 /* packedLastDimension */, 0 /* unpacked */, 0 /* unpacked */]
+    };
+    createComputeOutputProgramInfo = (inferenceHandler, metadata, input, epsilon, meanAndVarianceShape) => {
+      const glsl = getGlsl(inferenceHandler.session.backend.glContext.version);
+      const [textureWidth, textureHeight] = inferenceHandler.calculateTextureWidthAndHeight(
+        meanAndVarianceShape,
+        4 /* packedLastDimension */
+      );
+      const [meanAndVarianceWidth, meanAndVarianceHeight] = [textureWidth / 4, textureHeight];
+      const shaderSource = `
+      vec4 get_MeanAndVariance(int[2] mv) {
+        int offset = indicesToOffset_MeanAndVariance(mv);
+        vec2 coords = offsetToCoords(offset, ${meanAndVarianceWidth}, ${meanAndVarianceHeight});
+        return ${glsl.texture2D}(MeanAndVariance, coords);
+      }
+
+      float process(int[4] indices) {
+        int mv[2];
+        mv[0] = indices[0];
+        mv[1] = indices[1];
+        vec4 mean_and_variance = get_MeanAndVariance(mv);
+        float mean = mean_and_variance.r;
+        float variance = mean_and_variance.g;
+
+        int sb[1];
+        sb[0] = indices[1];
+        float scale = _Scale(sb);
+        float b = _B(sb);
+
+        return scale * (_X(indices) - mean) / sqrt(variance + epsilon) + b;
+      }`;
+      return {
+        ...metadata,
+        output: { dims: input.dims, type: input.type, textureType: 0 /* unpacked */ },
+        variables: [{ name: "epsilon", type: "float", data: epsilon }],
+        shaderSource
+      };
+    };
+    createComputeOutputProgramInfoLoader = (inferenceHandler, input, epsilon, meanAndVarianceShape) => {
+      const metadata = { ...computeOutputProgramMetadata, cacheHint: `${epsilon}` };
+      return {
+        ...metadata,
+        get: () => createComputeOutputProgramInfo(inferenceHandler, metadata, input, epsilon, meanAndVarianceShape)
+      };
+    };
+    validateInputs13 = (inputs) => {
+      if (!inputs || inputs.length !== 3) {
+        throw new Error("InstanceNormalization requires 3 inputs.");
+      }
+      const X = inputs[0];
+      const scale = inputs[1];
+      const B = inputs[2];
+      if (X.dims.length < 3 || scale.dims.length !== 1 || B.dims.length !== 1) {
+        throw new Error("Invalid input shape.");
+      }
+      if (scale.dims[0] !== X.dims[1] || B.dims[0] !== X.dims[1]) {
+        throw new Error("Input shapes are mismatched.");
+      }
+      if (X.type !== "float32" && X.type !== "float64" || scale.type !== "float32" && scale.type !== "float64" || B.type !== "float32" && B.type !== "float64") {
+        throw new Error("Invalid input type.");
+      }
+      if (inputs[0].dims.length !== 4) {
+        throw new Error("Only support 4-D input shape.");
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/lrn.ts
+function createLrnProgramInfo(inputs, attributes) {
+  const C = inputs[0].dims[1];
+  const rank = inputs[0].dims.length;
+  const from = -Math.floor((attributes.size - 1) / 2);
+  const to = Math.ceil((attributes.size - 1) / 2);
+  const alpha = `float(${attributes.alpha}) / float(${attributes.size})`;
+  const bias = `float(${attributes.bias})`;
+  const beta = `float(${attributes.beta})`;
+  const shaderSource = `
+    float process(int indices[${rank}]) {
+        int c = indices[1];
+        float x = _X(indices);
+        float square_sum = 0.0;
+
+        for (int i = ${from}; i <= ${to}; i++) {
+          int idx = c + i;
+          if (c >= 0 && c < ${C}) {
+            indices[1] = idx;
+            float j = _X(indices);
+            square_sum += j * j;
+          }
+        }
+        return x / pow(${bias} + ${alpha} * square_sum, ${beta});
+    }`;
+  return {
+    ...lrnProgramMetadata,
+    cacheHint: attributes.cacheKey,
+    output: { dims: inputs[0].dims, type: inputs[0].type, textureType: 0 /* unpacked */ },
+    shaderSource
+  };
+}
+function createLrnProgramInfoLoader(inputs, attributes) {
+  return { ...lrnProgramMetadata, cacheHint: attributes.cacheKey, get: () => createLrnProgramInfo(inputs, attributes) };
+}
+var lrn, parseLrnAttributes, lrnProgramMetadata, validateInputs14;
+var init_lrn = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/lrn.ts"() {
+    "use strict";
+    init_attribute_with_cache_key();
+    init_types();
+    lrn = (inferenceHandler, inputs, attributes) => {
+      validateInputs14(inputs);
+      return [inferenceHandler.run(createLrnProgramInfoLoader(inputs, attributes), inputs)];
+    };
+    parseLrnAttributes = (node) => {
+      const alpha = node.attributes.getFloat("alpha", 1e-4);
+      const beta = node.attributes.getFloat("beta", 0.75);
+      const bias = node.attributes.getFloat("bias", 1);
+      const size = node.attributes.getInt("size");
+      return createAttributeWithCacheKey({ alpha, beta, bias, size });
+    };
+    lrnProgramMetadata = {
+      name: "LRN",
+      inputNames: ["X"],
+      inputTypes: [0 /* unpacked */]
+    };
+    validateInputs14 = (inputs) => {
+      if (!inputs || inputs.length !== 1) {
+        throw new Error("LRN requires 1 input.");
+      }
+      if (inputs[0].dims.length !== 4) {
+        throw new Error('currently only support LRN for input with "NCHW" format');
+      }
+      if (inputs[0].type !== "float32") {
+        throw new Error("input should be float type");
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/pad.ts
+var padProgramMetadata, padV2, parsePadAttributesV2, padV11, parsePadAttributesV11, generatePadAttributesFromInputs, createPadProgramInfo, validateInputsV2, validateInputsV11, getPadFunction, getPadConstant, getPadReflect, getPadEdge;
+var init_pad = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/pad.ts"() {
+    "use strict";
+    init_attribute_with_cache_key();
+    init_util();
+    init_glsl_source();
+    init_types();
+    padProgramMetadata = {
+      name: "Pad",
+      inputNames: ["A"],
+      inputTypes: [0 /* unpacked */]
+    };
+    padV2 = (inferenceHandler, inputs, attributes) => {
+      validateInputsV2(inputs);
+      const output = inferenceHandler.run(
+        {
+          ...padProgramMetadata,
+          cacheHint: attributes.cacheKey,
+          get: () => createPadProgramInfo(inferenceHandler, inputs[0], attributes)
+        },
+        inputs
+      );
+      return [output];
+    };
+    parsePadAttributesV2 = (node) => {
+      const mode = node.attributes.getString("mode", "constant");
+      const value = node.attributes.getFloat("value", 0);
+      const pads = node.attributes.getInts("pads");
+      return createAttributeWithCacheKey({ mode, value, pads });
+    };
+    padV11 = (inferenceHandler, inputs, mode) => {
+      validateInputsV11(inputs);
+      const attrubutes = generatePadAttributesFromInputs(inferenceHandler, inputs, mode);
+      return padV2(inferenceHandler, [inputs[0]], attrubutes);
+    };
+    parsePadAttributesV11 = (node) => node.attributes.getString("mode", "constant");
+    generatePadAttributesFromInputs = (inferenceHandler, inputs, mode) => {
+      if (!inferenceHandler.session.isInitializer(inputs[1].dataId) || inputs.length >= 3 && !inferenceHandler.session.isInitializer(inputs[2].dataId)) {
+        throw new Error("dynamic pad attributes are not allowed");
+      }
+      const pads = Array.from(inputs[1].integerData);
+      const value = inputs.length >= 3 ? inputs[2].floatData[0] : 0;
+      return createAttributeWithCacheKey({ mode, pads, value });
+    };
+    createPadProgramInfo = (inferenceHandler, input, attributes) => {
+      const outputShape = ShapeUtil.padShape(input.dims.slice(), attributes.pads);
+      const rank = outputShape.length;
+      const padFunction = getPadFunction(inferenceHandler, input, attributes);
+      const shaderSource = `
+      ${padFunction}
+      float process(int[${rank}] indices) {
+          return padA(indices);
+      }`;
+      return {
+        name: "Pad",
+        inputNames: ["A"],
+        inputTypes: [0 /* unpacked */],
+        output: { dims: outputShape, type: input.type, textureType: 0 /* unpacked */ },
+        shaderSource
+      };
+    };
+    validateInputsV2 = (inputs) => {
+      if (!inputs || inputs.length !== 1) {
+        throw new Error("Pad requires 1 input");
+      }
+      if (inputs[0].type !== "float32" && inputs[0].type !== "float64") {
+        throw new Error("Invalid input type.");
+      }
+    };
+    validateInputsV11 = (inputs) => {
+      if (!inputs || inputs.length !== 2 && inputs.length !== 3) {
+        throw new Error("Pad requires 2 or 3 inputs");
+      }
+      if (inputs[1].type !== "int32") {
+        throw new Error("Invalid input type.");
+      }
+      if (inputs.length >= 3 && inputs[2].type === "string") {
+        throw new Error("Invalid input type.");
+      }
+    };
+    getPadFunction = (inferenceHandler, input, attributes) => {
+      const glsl = getGlsl(inferenceHandler.session.backend.glContext.version);
+      const [width, height] = inferenceHandler.calculateTextureWidthAndHeight(input.dims, 0 /* unpacked */);
+      const strides = ShapeUtil.computeStrides(input.dims);
+      switch (attributes.mode) {
+        case "constant":
+          return getPadConstant(glsl, input.dims, strides, width, height, attributes.pads, attributes.value);
+        case "reflect":
+          return getPadReflect(glsl, input.dims, strides, width, height, attributes.pads);
+        case "edge":
+          return getPadEdge(glsl, input.dims, strides, width, height, attributes.pads);
+        default:
+          throw new Error("Invalid mode");
+      }
+    };
+    getPadConstant = (glsl, shape2, strides, width, height, pads, value) => {
+      const rank = shape2.length;
+      let block = "";
+      for (let i = rank - 1; i >= 0; --i) {
+        block += `
+        k = m[${i}] - ${pads[i]};
+        if (k < 0)  return constant;
+        if (k >= ${shape2[i]}) return constant;
+        offset += k * ${strides[i]};
+        `;
+      }
+      return `
+      float padA(int m[${rank}]) {
+        const float constant = float(${value});
+        int offset = 0;
+        int k = 0;
+        ${block}
+        vec2 coords = offsetToCoords(offset, ${width}, ${height});
+        float value = getColorAsFloat(${glsl.texture2D}(A, coords));
+        return value;
+      }
+      `;
+    };
+    getPadReflect = (glsl, shape2, strides, width, height, pads) => {
+      const rank = shape2.length;
+      let block = "";
+      for (let i = rank - 1; i >= 0; --i) {
+        block += `
+        k = m[${i}] - ${pads[i]};
+        if (k < 0) { k = -k; }
+        {
+          const int _2n_1 = ${2 * (shape2[i] - 1)};
+          k = int( mod( float(k), float(_2n_1) ) ) ;
+          if(k >= ${shape2[i]}) { k = _2n_1 - k; }
+        }
+        offset += k * ${strides[i]};
+        `;
+      }
+      return `
+      float padA(int m[${rank}]) {
+        int offset = 0;
+        int k = 0;
+        ${block}
+        vec2 coords = offsetToCoords(offset, ${width}, ${height});
+        float value = getColorAsFloat(${glsl.texture2D}(A, coords));
+        return value;
+      }
+      `;
+    };
+    getPadEdge = (glsl, shape2, strides, width, height, pads) => {
+      const rank = shape2.length;
+      let block = "";
+      for (let i = rank - 1; i >= 0; --i) {
+        block += `
+        k = m[${i}] - ${pads[i]};
+        if (k < 0)  k = 0;
+        if (k >= ${shape2[i]}) k = ${shape2[i] - 1};
+        offset += k * ${strides[i]};
+      `;
+      }
+      return `
+      float padA(int m[${rank}]) {
+        int offset = 0;
+        int k = 0;
+        ${block}
+        vec2 coords = offsetToCoords(offset, ${width}, ${height});
+        float value = getColorAsFloat(${glsl.texture2D}(A, coords));
+        return value;
+      }
+      `;
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/pool.ts
+var averagePool, parseAveragePoolAttributes, createAveragePoolProgramInfo, globalAveragePool, parseGlobalAveragePoolAttributes, maxPool, parseMaxPoolAttributes, createMaxPoolProgramInfo, getAdjustedPoolAttributesAndOutputShape, globalMaxPoolAttributes, globalMaxPoolMetadata, globalMaxPool, validateInputs15, generatePoolingCode, copyArray, offsetToIndices;
+var init_pool = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/pool.ts"() {
+    "use strict";
+    init_attribute_with_cache_key();
+    init_util();
+    init_types();
+    averagePool = (inferenceHandler, inputs, attributes) => {
+      validateInputs15(inputs);
+      const metadata = {
+        name: "AveragePool",
+        inputNames: ["X"],
+        inputTypes: [0 /* unpacked */],
+        cacheHint: attributes.cacheKey
+      };
+      const output = inferenceHandler.run(
+        { ...metadata, get: () => createAveragePoolProgramInfo(inputs, metadata, false, attributes) },
+        inputs
+      );
+      return [output];
+    };
+    parseAveragePoolAttributes = (node) => {
+      const autoPad = node.attributes.getString("auto_pad", "NOTSET");
+      const ceilMode = node.attributes.getInt("ceil_mode", 0);
+      const countIncludePad = node.attributes.getInt("count_include_pad", 0) === 0 ? false : true;
+      const kernelShape = node.attributes.getInts("kernel_shape");
+      const strides = node.attributes.getInts("strides", []);
+      const pads = node.attributes.getInts("pads", []);
+      if (ceilMode !== 0) {
+        throw new Error("using ceil() in shape computation is not yet supported for AveragePool");
+      }
+      return createAttributeWithCacheKey({ autoPad, ceilMode, countIncludePad, kernelShape, strides, pads });
+    };
+    createAveragePoolProgramInfo = (inputs, metadata, isGlobalOperator, attributes) => {
+      const [adjustedAttributes, outputShape] = getAdjustedPoolAttributesAndOutputShape(
+        inputs,
+        attributes,
+        isGlobalOperator
+      );
+      const kernelSize = ShapeUtil.size(adjustedAttributes.kernelShape);
+      const op1 = "value += _X(x);";
+      let op2 = "";
+      if (adjustedAttributes.countIncludePad) {
+        op2 += `value /= float(${kernelSize});`;
+      } else {
+        op2 += `value /= float(${kernelSize} - pad);`;
+      }
+      const poolingCode = generatePoolingCode(inputs[0].dims, adjustedAttributes, op1, op2, "0.0");
+      const shaderSource = `
+        ${poolingCode}
+      `;
+      return {
+        ...metadata,
+        output: { dims: outputShape, type: inputs[0].type, textureType: 0 /* unpacked */ },
+        shaderSource
+      };
+    };
+    globalAveragePool = (inferenceHandler, inputs, attributes) => {
+      validateInputs15(inputs);
+      const metadata = {
+        name: "GlobalAveragePool",
+        inputNames: ["X"],
+        inputTypes: [0 /* unpacked */],
+        cacheHint: `${attributes.countIncludePad}`
+      };
+      const output = inferenceHandler.run(
+        { ...metadata, get: () => createAveragePoolProgramInfo(inputs, metadata, true, attributes) },
+        inputs
+      );
+      return [output];
+    };
+    parseGlobalAveragePoolAttributes = (node) => {
+      const countIncludePad = node.attributes.getInt("count_include_pad", 0) === 0 ? false : true;
+      return createAttributeWithCacheKey({
+        autoPad: "",
+        ceilMode: 0,
+        countIncludePad,
+        kernelShape: [],
+        strides: [],
+        pads: []
+      });
+    };
+    maxPool = (inferenceHandler, inputs, attributes) => {
+      validateInputs15(inputs);
+      const metadata = {
+        name: "MaxPool",
+        inputNames: ["X"],
+        inputTypes: [0 /* unpacked */],
+        cacheHint: attributes.cacheKey
+      };
+      const output = inferenceHandler.run(
+        { ...metadata, get: () => createMaxPoolProgramInfo(inputs, metadata, false, attributes) },
+        inputs
+      );
+      return [output];
+    };
+    parseMaxPoolAttributes = (node) => {
+      const autoPad = node.attributes.getString("auto_pad", "NOTSET");
+      const ceilMode = node.attributes.getInt("ceil_mode", 0);
+      const kernelShape = node.attributes.getInts("kernel_shape");
+      const strides = node.attributes.getInts("strides", []);
+      const pads = node.attributes.getInts("pads", []);
+      const storageOrder = node.attributes.getInt("storage_order", 0);
+      const dilations = node.attributes.getInts("dilations", []);
+      if (storageOrder !== 0) {
+        throw new Error("column major storage order is not yet supported for MaxPool");
+      }
+      if (ceilMode !== 0) {
+        throw new Error("using ceil() in shape computation is not yet supported for MaxPool");
+      }
+      return createAttributeWithCacheKey({
+        autoPad,
+        ceilMode,
+        countIncludePad: false,
+        kernelShape,
+        strides,
+        pads,
+        storageOrder,
+        dilations
+      });
+    };
+    createMaxPoolProgramInfo = (inputs, metadata, isGlobalOperator, attributes) => {
+      const [adjustedAttributes, outputShape] = getAdjustedPoolAttributesAndOutputShape(
+        inputs,
+        attributes,
+        isGlobalOperator
+      );
+      const op1 = `
+      value = max(_X(x), value);
+    `;
+      const op2 = "";
+      const poolingCode = generatePoolingCode(inputs[0].dims, adjustedAttributes, op1, op2, "-1e5");
+      const shaderSource = `
+      ${poolingCode}
+    `;
+      return {
+        ...metadata,
+        output: { dims: outputShape, type: inputs[0].type, textureType: 0 /* unpacked */ },
+        shaderSource
+      };
+    };
+    getAdjustedPoolAttributesAndOutputShape = (inputs, attributes, isGlobalOperator) => {
+      const inputShape = inputs[0].dims.slice();
+      const hasDilations = Object.hasOwnProperty.call(attributes, "dilations");
+      const kernelShape = attributes.kernelShape.slice();
+      const strides = attributes.strides.slice();
+      const dilations = hasDilations ? attributes.dilations.slice() : [];
+      const pads = attributes.pads.slice();
+      PoolConvUtil.adjustPoolAttributes(isGlobalOperator, inputShape, kernelShape, strides, dilations, pads);
+      const outputShape = PoolConvUtil.computePoolOutputShape(
+        isGlobalOperator,
+        inputShape,
+        strides,
+        dilations,
+        kernelShape,
+        pads,
+        attributes.autoPad
+      );
+      const newAttributes = Object.assign({}, attributes);
+      if (hasDilations) {
+        Object.assign(newAttributes, { kernelShape, strides, pads, dilations, cacheKey: attributes.cacheKey });
+      } else {
+        Object.assign(newAttributes, { kernelShape, strides, pads, cacheKey: attributes.cacheKey });
+      }
+      return [newAttributes, outputShape];
+    };
+    globalMaxPoolAttributes = {
+      autoPad: "",
+      ceilMode: 0,
+      countIncludePad: false,
+      kernelShape: [],
+      strides: [],
+      pads: [],
+      storageOrder: 0,
+      dilations: [],
+      cacheKey: ""
+    };
+    globalMaxPoolMetadata = {
+      name: "GlobalMaxPool",
+      inputNames: ["X"],
+      inputTypes: [0 /* unpacked */]
+    };
+    globalMaxPool = (inferenceHandler, inputs) => {
+      validateInputs15(inputs);
+      const output = inferenceHandler.run(
+        {
+          ...globalMaxPoolMetadata,
+          get: () => createMaxPoolProgramInfo(inputs, globalMaxPoolMetadata, true, globalMaxPoolAttributes)
+        },
+        inputs
+      );
+      return [output];
+    };
+    validateInputs15 = (inputs) => {
+      if (!inputs || inputs.length !== 1) {
+        throw new Error("Pool ops requires 1 input.");
+      }
+      if (inputs[0].type !== "float32" && inputs[0].type !== "float64") {
+        throw new Error("Invalid input type.");
+      }
+    };
+    generatePoolingCode = (inputDims, attributes, op1, op2, start) => {
+      const rank = inputDims.length;
+      if (attributes.kernelShape.length <= 2) {
+        const kw = attributes.kernelShape[attributes.kernelShape.length - 1];
+        const sw = attributes.strides[attributes.strides.length - 1];
+        const pwStart = attributes.pads[attributes.pads.length / 2 - 1];
+        const pwEnd = attributes.pads[attributes.pads.length - 1];
+        const dimW = inputDims[rank - 1];
+        let codeW = "";
+        let codeH = "";
+        let codeHEnd = "";
+        if (pwStart + pwEnd !== 0) {
+          codeW = `
+          for (int i = 0; i < ${kw}; i++) {
+            x[${rank} - 1] = indices[${rank} - 1] * ${sw} - ${pwStart} + i;
+            if (x[${rank} - 1] < 0 || x[${rank} - 1] >= ${dimW}) {
+              pad++;
+              continue;
+            }
+            ${op1}
+          }`;
+        } else {
+          codeW = `
+          for (int i = 0; i < ${kw}; i++) {
+            x[${rank} - 1] = indices[${rank} - 1] * ${sw} - ${pwStart} + i;
+            ${op1}
+          }`;
+        }
+        if (attributes.kernelShape.length === 2) {
+          const kh = attributes.kernelShape[attributes.kernelShape.length - 2];
+          const sh = attributes.strides[attributes.strides.length - 2];
+          const phStart = attributes.pads[attributes.pads.length / 2 - 2];
+          const phEnd = attributes.pads[attributes.pads.length - 2];
+          const dimH = inputDims[rank - 2];
+          if (phStart + phEnd !== 0) {
+            codeH = `
+            for (int j = 0; j < ${kh}; j++) {
+              x[${rank} - 2] = indices[${rank} - 2] * ${sh} - ${phStart} + j;
+              if (x[${rank} - 2] < 0 || x[${rank} - 2] >= ${dimH}) {
+                pad+= ${kw};
+                continue;
+              }
+          `;
+          } else {
+            codeH = `
+            for (int j = 0; j < ${kh}; j++) {
+              x[${rank} - 2] = indices[${rank} - 2] * ${sh} - ${phStart} + j;
+            `;
+          }
+          codeHEnd = `
+          }
+        `;
+        }
+        const poolingCode = `
+        float process(int indices[${rank}]) {
+          int x[${rank}];
+          copyVec(indices, x);
+
+          float value = ${start};
+          int pad = 0;
+          ${codeH}
+          ${codeW}
+          ${codeHEnd}
+          ${op2}
+          return value;
+        }
+      `;
+        return poolingCode;
+      } else {
+        const kernelSize = ShapeUtil.size(attributes.kernelShape);
+        const kernelStrides = ShapeUtil.computeStrides(attributes.kernelShape);
+        const stridesRank = kernelStrides.length;
+        const padsRank = attributes.pads.length;
+        const offsetToIndicesFunction = offsetToIndices(stridesRank);
+        const copyInputDims = copyArray(inputDims, "inputDims");
+        const copyPads = copyArray(attributes.pads, "pads");
+        const copyKernelStrides = copyArray(kernelStrides, "kernelStrides");
+        const copyStrides = copyArray(attributes.strides, "strides");
+        const hasPads = attributes.pads.reduce((sum2, cur) => sum2 + cur);
+        let padCode = "";
+        if (hasPads) {
+          padCode = `
+            if (x[j] >= inputDims[j] || x[j] < 0) {
+              pad++;
+              isPad = true;
+              break;
+            }
+          }
+          if (!isPad) {
+            ${op1}
+          }`;
+        } else {
+          padCode = `
+          }
+          ${op1}
+        `;
+        }
+        const poolingCode = `
+        ${offsetToIndicesFunction}
+        float process(int indices[${rank}]) {
+          int x[${rank}];
+          copyVec(indices, x);
+          int offset[${stridesRank}];
+          int pads[${padsRank}];
+          int inputDims[${rank}];
+          int kernelStrides[${stridesRank}];
+          int strides[${stridesRank}];
+          ${copyPads}
+          ${copyInputDims}
+          ${copyStrides}
+          ${copyKernelStrides}
+
+          float value = ${start};
+          int pad = 0;
+          bool isPad = false;
+          for (int i = 0; i < ${kernelSize}; i++) {
+            offsetToIndices(i, kernelStrides, offset);
+            isPad = false;
+            for (int j = ${rank} - ${stridesRank}; j < ${rank}; j++) {
+              x[j] = indices[j] * strides[j - ${rank} + ${stridesRank}]
+                + offset[j - ${rank} + ${stridesRank}] - pads[j - 2];
+              ${padCode}
+          }
+          ${op2}
+
+          return value;
+        }
+      `;
+        return poolingCode;
+      }
+    };
+    copyArray = (array, arrayName) => {
+      let block = "";
+      for (let i = 0; i < array.length; i++) {
+        block += `
+      ${arrayName}[${i}] = ${array[i]};
+    `;
+      }
+      return block;
+    };
+    offsetToIndices = (rank) => `
+  void offsetToIndices(int offset, int[${rank}] strides, out int[${rank}] indices) {
+    if (${rank} == 0) {
+      return;
+    }
+    for (int i = 0; i < ${rank} - 1; ++i) {
+      indices[i] = offset / strides[i];
+      offset -= indices[i] * strides[i];
+    }
+    indices[${rank} - 1] = offset;
+  }`;
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/reduce.ts
+var reduce, parseReduceAttributes, createReduceProgramInfo, validateInputs16, reduceSum, reduceMean, reduceMax, reduceMin, reduceProd, reduceLogSum, reduceLogSumSquare;
+var init_reduce = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/reduce.ts"() {
+    "use strict";
+    init_attribute_with_cache_key();
+    init_operators();
+    init_util();
+    init_types();
+    reduce = (inferenceHandler, inputs, attributes, name2, reduceOp) => {
+      validateInputs16(inputs);
+      const reduceProgramMetadata = {
+        name: name2,
+        inputNames: ["A"],
+        inputTypes: [0 /* unpacked */]
+      };
+      const output = inferenceHandler.run(
+        {
+          ...reduceProgramMetadata,
+          cacheHint: attributes.cacheKey,
+          get: () => createReduceProgramInfo(inferenceHandler, inputs, attributes, name2, reduceOp, reduceProgramMetadata)
+        },
+        inputs
+      );
+      return [output];
+    };
+    parseReduceAttributes = (node) => {
+      const axes = node.attributes.getInts("axes", []);
+      const keepDims = node.attributes.getInt("keepdims", 1) === 1;
+      return createAttributeWithCacheKey({ axes, keepDims });
+    };
+    createReduceProgramInfo = (_handler, inputs, attributes, _name, reduceOp, reduceProgramMetadata) => {
+      const outputShape = [];
+      const iRank = inputs[0].dims.length || 1;
+      const idxCopy = [];
+      const axes = ShapeUtil.normalizeAxes(attributes.axes, inputs[0].dims.length);
+      const ops = reduceOp(inputs, axes);
+      let reduceOps = ops[1];
+      for (let k = 0; k < inputs[0].dims.length; k++) {
+        if (axes.indexOf(k) >= 0 || axes.length === 0) {
+          if (attributes.keepDims) {
+            outputShape.push(1);
+          }
+          reduceOps = `
+          for(int j${k} = 0; j${k} < ${inputs[0].dims[k]}; j${k}++) {
+            inputIdx[${k}] = j${k};
+            ${reduceOps}
+          }`;
+        } else {
+          idxCopy.push(`inputIdx[${k}] = outputIdx[${outputShape.length}];`);
+          outputShape.push(inputs[0].dims[k]);
+        }
+      }
+      const oRank = outputShape.length || 1;
+      const shaderSource = `
+      float process(int outputIdx[${oRank}]) {
+        float value;                 // final result
+        int inputIdx[${iRank}];      // addressing input data
+        ${idxCopy.join("\n")}
+        ${ops[0]}       // init ops for reduce max/min
+        ${reduceOps}
+        ${ops[2]}       // final computation for reduce mean
+        return value;
+      }`;
+      return {
+        ...reduceProgramMetadata,
+        output: { dims: outputShape, type: inputs[0].type, textureType: 0 /* unpacked */ },
+        shaderSource
+      };
+    };
+    validateInputs16 = (inputs) => {
+      if (!inputs || inputs.length !== 1) {
+        throw new Error("Reduce op requires 1 input.");
+      }
+      if (NUMBER_TYPES.indexOf(inputs[0].type) === -1) {
+        throw new Error("Invalid input type.");
+      }
+    };
+    reduceSum = (inferenceHandler, inputs, attributes) => {
+      const reduceOp = () => ["value = 0.0;", "value += _A(inputIdx);", ""];
+      return reduce(inferenceHandler, inputs, attributes, "ReduceSum", reduceOp);
+    };
+    reduceMean = (inferenceHandler, inputs, attributes) => {
+      const reduceOp = (inputs2, axes) => {
+        let size = 1;
+        for (let k = 0; k < inputs2[0].dims.length; k++) {
+          if (axes.indexOf(k) >= 0 || axes.length === 0) {
+            size *= inputs2[0].dims[k];
+          }
+        }
+        return ["value = 0.0;", "value += _A(inputIdx);", `value /= ${size}.;`];
+      };
+      return reduce(inferenceHandler, inputs, attributes, "ReduceMean", reduceOp);
+    };
+    reduceMax = (inferenceHandler, inputs, attributes) => {
+      const reduceOp = (inputs2, axes) => {
+        const idxZero = [];
+        for (let k = 0; k < inputs2[0].dims.length; k++) {
+          if (axes.indexOf(k) >= 0 || axes.length === 0) {
+            idxZero.push(`inputIdx[${k}] = 0;`);
+          }
+        }
+        return [`${idxZero.join("\n")}
+value = _A(inputIdx);`, "value = max(value, _A(inputIdx));", ""];
+      };
+      return reduce(inferenceHandler, inputs, attributes, "ReduceMax", reduceOp);
+    };
+    reduceMin = (inferenceHandler, inputs, attributes) => {
+      const reduceOp = (inputs2, axes) => {
+        const idxZero = [];
+        for (let k = 0; k < inputs2[0].dims.length; k++) {
+          if (axes.indexOf(k) >= 0 || axes.length === 0) {
+            idxZero.push(`inputIdx[${k}] = 0;`);
+          }
+        }
+        return [`${idxZero.join("\n")}
+value = _A(inputIdx);`, "value = min(value, _A(inputIdx));", ""];
+      };
+      return reduce(inferenceHandler, inputs, attributes, "ReduceMin", reduceOp);
+    };
+    reduceProd = (inferenceHandler, inputs, attributes) => {
+      const reduceOp = () => ["value = 1.0;", "value *= _A(inputIdx);", ""];
+      return reduce(inferenceHandler, inputs, attributes, "ReduceProd", reduceOp);
+    };
+    reduceLogSum = (inferenceHandler, inputs, attributes) => {
+      const reduceOp = () => ["value = 0.0;", "value += _A(inputIdx);", "value = log(value);"];
+      return reduce(inferenceHandler, inputs, attributes, "ReduceLogSum", reduceOp);
+    };
+    reduceLogSumSquare = (inferenceHandler, inputs, attributes) => {
+      const reduceOp = () => ["float t; value = 0.0;", "t = _A(inputIdx); value += t * t;", ""];
+      return reduce(inferenceHandler, inputs, attributes, "ReduceLogSumSquare", reduceOp);
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/reshape.ts
+var reshape;
+var init_reshape = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/reshape.ts"() {
+    "use strict";
+    init_util();
+    reshape = (handler, inputs) => {
+      const reshapedDims = ShapeUtil.calculateReshapedDims(inputs[0].dims, inputs[1].integerData);
+      if (handler.session.pack) {
+        return [handler.reshapePacked(inputs[0], reshapedDims)];
+      } else {
+        return [handler.reshapeUnpacked(inputs[0], reshapedDims)];
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/upsample.ts
+var upsampleProgramMetadata, upsample, parseUpsampleAttributesV7, parseUpsampleAttributesV9, parseUpsampleAttributes, createUpsampleProgramInfo, validateInputs17, scalesValidation;
+var init_upsample = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/upsample.ts"() {
+    "use strict";
+    init_attribute_with_cache_key();
+    init_glsl_source();
+    init_types();
+    upsampleProgramMetadata = {
+      name: "Upsample",
+      inputNames: ["X"],
+      inputTypes: [0 /* unpacked */]
+    };
+    upsample = (inferenceHandler, inputs, attributes) => {
+      validateInputs17(inputs, attributes);
+      const output = inferenceHandler.run(
+        {
+          ...upsampleProgramMetadata,
+          cacheHint: attributes.cacheKey,
+          get: () => createUpsampleProgramInfo(inferenceHandler, inputs, attributes)
+        },
+        inputs
+      );
+      return [output];
+    };
+    parseUpsampleAttributesV7 = (node) => parseUpsampleAttributes(node, 7);
+    parseUpsampleAttributesV9 = (node) => parseUpsampleAttributes(node, 9);
+    parseUpsampleAttributes = (node, opset) => {
+      const isResize = opset >= 10;
+      const mode = node.attributes.getString("mode", "nearest");
+      if (mode !== "nearest" && mode !== "linear" && (opset < 11 || mode !== "cubic")) {
+        throw new Error(`unrecognized mode: ${mode}`);
+      }
+      let scales = [];
+      if (opset < 9) {
+        scales = node.attributes.getFloats("scales");
+        scalesValidation(scales, mode, isResize);
+      }
+      const extrapolationValue = node.attributes.getFloat("extrapolation_value", 0);
+      const coordinateTransformMode = opset > 10 ? node.attributes.getString("coordinate_transformation_mode", "half_pixel") : "asymmetric";
+      if ([
+        "asymmetric",
+        "pytorch_half_pixel",
+        "tf_half_pixel_for_nn",
+        "align_corners",
+        "tf_crop_and_resize",
+        "half_pixel"
+      ].indexOf(coordinateTransformMode) === -1) {
+        throw new Error(`coordinate_transform_mode '${coordinateTransformMode}' is not supported`);
+      }
+      const needRoiInput = coordinateTransformMode === "tf_crop_and_resize";
+      const useExtrapolation = needRoiInput;
+      const nearestMode = mode === "nearest" && opset >= 11 ? node.attributes.getString("nearest_mode", "round_prefer_floor") : "";
+      if (["round_prefer_floor", "round_prefer_ceil", "floor", "ceil", ""].indexOf(nearestMode) === -1) {
+        throw new Error(`nearest_mode '${nearestMode}' is not supported`);
+      }
+      const cubicCoefficientA = node.attributes.getFloat("cubic_coeff_a", -0.75);
+      const excludeOutside = node.attributes.getInt("exclude_outside", 0) !== 0;
+      if (excludeOutside && mode !== "cubic") {
+        throw new Error("exclude_outside can be set to 1 only when mode is CUBIC.");
+      }
+      const useNearest2xOptimization = opset < 11 ? true : mode === "nearest" && coordinateTransformMode === "asymmetric" && nearestMode === "floor";
+      let roiInputIdx = 0;
+      let scalesInputIdx = 0;
+      let sizesInputIdx = 0;
+      if (opset > 10) {
+        if (node.inputs.length > 2) {
+          roiInputIdx = 1;
+          scalesInputIdx = 2;
+          sizesInputIdx = 3;
+        } else {
+          scalesInputIdx = 1;
+          sizesInputIdx = 2;
+        }
+      } else if (opset === 9) {
+        scalesInputIdx = 1;
+      }
+      return createAttributeWithCacheKey({
+        opset,
+        isResize,
+        mode,
+        scales,
+        extrapolationValue,
+        coordinateTransformMode,
+        useExtrapolation,
+        needRoiInput,
+        nearestMode,
+        cubicCoefficientA,
+        excludeOutside,
+        useNearest2xOptimization,
+        roiInputIdx,
+        scalesInputIdx,
+        sizesInputIdx
+      });
+    };
+    createUpsampleProgramInfo = (inferenceHandler, inputs, attributes) => {
+      const glsl = getGlsl(inferenceHandler.session.backend.glContext.version);
+      const [inputWidth, inputHeight] = inferenceHandler.calculateTextureWidthAndHeight(
+        inputs[0].dims,
+        0 /* unpacked */
+      );
+      const outputShape = inputs[0].dims.map((dim2, i) => Math.floor(dim2 * attributes.scales[i]));
+      const [outputWidth, outputHeight] = inferenceHandler.calculateTextureWidthAndHeight(
+        outputShape,
+        0 /* unpacked */
+      );
+      const dim = outputShape.length;
+      const outputPitches = new Array(dim);
+      const inputPitches = new Array(dim);
+      let precalculatedPitches = `
+      int output_pitches[${dim}];
+      int input_pitches[${dim}];
+      `;
+      for (let d = dim - 1; d >= 0; d--) {
+        outputPitches[d] = d === dim - 1 ? 1 : outputPitches[d + 1] * outputShape[d + 1];
+        inputPitches[d] = d === dim - 1 ? 1 : inputPitches[d + 1] * inputs[0].dims[d + 1];
+        precalculatedPitches += `
+        output_pitches[${d}] = ${outputPitches[d]};
+        input_pitches[${d}] = ${inputPitches[d]};
+        `;
+      }
+      const getInputFloatFunction = `
+      float getInputFloat(int index) {
+        vec2 coords = offsetToCoords(index, ${inputWidth}, ${inputHeight});
+        float value = getColorAsFloat(${glsl.texture2D}(X, coords));
+        return value;
+      }
+      `;
+      const shaderSource = attributes.mode === "nearest" ? (
+        // nearest
+        `
+    ${getInputFloatFunction}
+    float process(int indices[${dim}]) {
+      int input_index = 0;
+      int output_index = coordsToOffset(TexCoords, ${outputWidth}, ${outputHeight});
+
+      ${precalculatedPitches}
+
+      int d, m;
+      for (int dim = 0; dim < ${dim}; ++dim) {
+        d = output_index / output_pitches[dim];
+        m = output_index - d * output_pitches[dim];
+        output_index = m;
+
+        if (scales[dim] != 1 && d > 0) {
+          int d2 = d / scales[dim];
+          m = d - d2 * scales[dim];
+          d = d2;
+        }
+        input_index += input_pitches[dim] * d;
+      }
+
+      return getInputFloat(input_index);
+    }`
+      ) : dim === 4 ? (
+        // bilinear 4D
+        `
+    ${getInputFloatFunction}
+    float process(int indices[4]) {
+      int input_index = 0;
+      int output_index = coordsToOffset(TexCoords, ${outputWidth}, ${outputHeight});
+
+      ${precalculatedPitches}
+
+      int m;
+      int index_of_dim0, index_of_dim1, index_of_dim2, index_of_dim3;
+      index_of_dim0 = output_index / output_pitches[0];
+      m = output_index - index_of_dim0 * output_pitches[0];
+      index_of_dim1 = m / output_pitches[1];
+      m = m - index_of_dim1 * output_pitches[1];
+      index_of_dim2 = m / output_pitches[2];
+      m = m - index_of_dim2 * output_pitches[2];
+      index_of_dim3 = m;
+
+      int index_of_input_dim2, index_of_input_dim3, x_offset, y_offset;
+      index_of_input_dim2 = index_of_dim2 / scales[2];
+      y_offset = index_of_dim2 - index_of_input_dim2 * scales[2];
+      index_of_input_dim3 = index_of_dim3 / scales[3];
+      x_offset = index_of_dim3 - index_of_input_dim3 * scales[3];
+
+      input_index = index_of_dim0 * input_pitches[0] +
+            index_of_dim1 * input_pitches[1] +
+            index_of_input_dim2 * input_pitches[2] +
+            index_of_input_dim3;
+
+      float x00 = getInputFloat(input_index);
+      float x10, x01, x11;
+
+      bool end_of_dim2 = false;
+      if (index_of_input_dim2 == (${inputs[0].dims[2]} - 1)) {
+        // It's the end in dimension 2
+        x01 = x00;
+        end_of_dim2 = true;
+      } else {
+        x01 = getInputFloat(input_index + input_pitches[2]);
+      }
+
+      if (index_of_input_dim3 == (input_pitches[2] - 1)) {
+        // It's the end in dimension 3
+        x10 = x00;
+        x11 = x01;
+      }
+      else {
+        x10 = getInputFloat(input_index + 1);
+        x11 = end_of_dim2 ? x10 : getInputFloat(input_index + input_pitches[2] + 1);
+      }
+
+      float y0 = x00 + float(y_offset) * (x01 - x00) / float(scales[2]);
+      float y1 = x10 + float(y_offset) * (x11 - x10) / float(scales[2]);
+      return y0 + float(x_offset) * (y1 - y0) / float(scales[3]);
+    }`
+      ) : (
+        // bilinear 2D
+        `
+    ${getInputFloatFunction}
+    float process(int indices[2]) {
+      int input_index = 0;
+      int output_index = coordsToOffset(TexCoords, ${outputWidth}, ${outputHeight});
+
+      ${precalculatedPitches}
+
+      int m;
+      int index_of_dim0, index_of_dim1;
+      index_of_dim0 = output_index / output_pitches[0];
+      m = output_index - index_of_dim0 * output_pitches[0];
+      index_of_dim1 = m;
+
+      int index_of_input_dim0, index_of_input_dim1, x_offset, y_offset;
+      index_of_input_dim0 = index_of_dim0 / scales[0];
+      y_offset = index_of_dim0 - index_of_input_dim0 * scales[0];
+      index_of_input_dim1 = index_of_dim1 / scales[1];
+      x_offset = index_of_dim1 - index_of_input_dim1 * scales[1];
+
+      input_index = index_of_input_dim0 * input_pitches[0] + index_of_input_dim1;
+
+      float x00 = getInputFloat(input_index);
+      float x10, x01, x11;
+
+      bool end_of_dim0 = false;
+      if (index_of_input_dim0 == (${inputs[0].dims[0]} - 1)) {
+        // It's the end in dimension 0
+        x01 = x00;
+        end_of_dim0 = true;
+      } else {
+        x01 = getInputFloat(input_index + input_pitches[0]);
+      }
+
+      if (index_of_input_dim1 == (input_pitches[0] - 1)) {
+        // It's the end in dimension 1
+        x10 = x00;
+        x11 = x01;
+      }
+      else {
+        x10 = getInputFloat(input_index + 1);
+        x11 = end_of_dim0 ? x10 : getInputFloat(input_index + input_pitches[0] + 1);
+      }
+
+      float y0 = x00 + float(y_offset) * (x01 - x00) / float(scales[0]);
+      float y1 = x10 + float(y_offset) * (x11 - x10) / float(scales[0]);
+      return y0 + float(x_offset) * (y1 - y0) / float(scales[1]);
+    }`
+      );
+      return {
+        ...upsampleProgramMetadata,
+        output: { dims: outputShape, type: inputs[0].type, textureType: 0 /* unpacked */ },
+        shaderSource,
+        variables: [
+          {
+            name: "scales",
+            type: "int",
+            arrayLength: attributes.scales.length,
+            data: attributes.scales.map((x) => Math.ceil(x))
+          }
+        ]
+      };
+    };
+    validateInputs17 = (inputs, attribute) => {
+      if (!inputs || attribute.opset < 9 && inputs.length !== 1 || attribute.opset >= 9 && attribute.opset < 11 && inputs.length !== 2 || attribute.opset >= 11 && inputs.length < 2) {
+        throw new Error("invalid inputs.");
+      }
+      if (attribute.scales.length > 0 && inputs[0].dims.length !== attribute.scales.length) {
+        throw new Error("Invalid input shape.");
+      }
+      if (inputs[0].type === "string") {
+        throw new Error("Invalid input tensor types.");
+      }
+    };
+    scalesValidation = (scales, mode, isResize) => {
+      if (!isResize) {
+        for (const scale of scales) {
+          if (scale < 1) {
+            throw new Error("Scale value should be greater than or equal to 1.");
+          }
+        }
+      } else {
+        for (const scale of scales) {
+          if (scale <= 0) {
+            throw new Error("Scale value should be greater than 0.");
+          }
+        }
+      }
+      if (mode === "linear" || mode === "cubic") {
+        if (scales.length !== 2 && (scales.length !== 4 || scales[0] !== 1 || scales[1] !== 1)) {
+          throw new Error(`'Linear' mode and 'Cubic' mode only support 2-D inputs ('Bilinear', 'Bicubic')         or 4-D inputs with the corresponding outermost 2 scale values being 1         in the ${isResize ? "Resize" : "Upsample"} opeartor.`);
+        }
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/resize-packed.ts
+var resizeProgramMetadata, resize, parseResizeAttributesV10, parseResizeAttributesV11, createPackedResizeProgramInfo, prepareInputs, parseScalesData, parseScalesDataFromOutputSize;
+var init_resize_packed = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/resize-packed.ts"() {
+    "use strict";
+    init_glsl_source();
+    init_types();
+    init_utils();
+    init_packing_utils();
+    init_upsample();
+    resizeProgramMetadata = {
+      name: "Resize",
+      inputNames: ["A"],
+      inputTypes: [2 /* packed */]
+    };
+    resize = (inferenceHandler, inputs, attributes) => {
+      validateInputs17(inputs, attributes);
+      const output = inferenceHandler.run(
+        {
+          ...resizeProgramMetadata,
+          cacheHint: attributes.cacheKey,
+          get: () => createPackedResizeProgramInfo(inferenceHandler, inputs, attributes)
+        },
+        inputs
+      );
+      return [output];
+    };
+    parseResizeAttributesV10 = (node) => parseUpsampleAttributes(node, 10);
+    parseResizeAttributesV11 = (node) => parseUpsampleAttributes(node, 11);
+    createPackedResizeProgramInfo = (inferenceHandler, inputs, attributes) => {
+      const glsl = getGlsl(inferenceHandler.session.backend.glContext.version);
+      const [scales, outputShape] = prepareInputs(inputs, attributes);
+      const isSame = scales.every((s) => s === 1) && attributes.coordinateTransformMode !== "tf_crop_and_resize";
+      if (isSame) {
+        return {
+          ...resizeProgramMetadata,
+          output: { dims: outputShape, type: inputs[0].type, textureType: 2 /* packed */ },
+          hasMain: true,
+          shaderSource: `void main() {
+                    vec4 v = ${glsl.texture2D}(X, TexCoords);
+                    ${glsl.output} = v;
+                }`
+        };
+      }
+      const dim = outputShape.length;
+      if (dim < 2) {
+        throw new Error(`output dimension should be at least 2, but got ${dim}`);
+      }
+      const outputHeight = outputShape[dim - 2];
+      const outputWidth = outputShape[dim - 1];
+      const inputShape = inputs[0].dims;
+      if (dim !== inputShape.length) {
+        throw new Error(`output dimension should match input ${inputShape.length}, but got ${dim}`);
+      }
+      const inputHeight = inputShape[dim - 2];
+      const inputWidth = inputShape[dim - 1];
+      const scalesHeight = scales[dim - 2];
+      const scalesWidth = scales[dim - 1];
+      let getSourceFracIndex = "";
+      if (attributes.mode !== "linear") {
+        throw new Error(`resize (packed) does not support mode: '${attributes.mode}'`);
+      }
+      switch (attributes.coordinateTransformMode) {
+        case "asymmetric":
+          getSourceFracIndex = `
+                    vec4 getSourceFracIndex(ivec4 coords) {
+                        return vec4(coords) / scaleWHWH;
+                    }
+                `;
+          break;
+        case "half_pixel":
+          getSourceFracIndex = `
+                    vec4 getSourceFracIndex(ivec4 coords) {
+                        return (vec4(coords) + 0.5) / scaleWHWH - 0.5;
+                    }
+                `;
+          break;
+        case "pytorch_half_pixel":
+          getSourceFracIndex = `
+                    vec4 getSourceFracIndex(ivec4 coords) {
+                        vec4 fcoords = vec4(coords);
+                        return vec4(
+                            ${outputWidth}.0 > 1.0 ? (fcoords.x + 0.5) / scaleWHWH.x - 0.5 : 0.0,
+                            ${outputHeight}.0 > 1.0 ? (fcoords.y + 0.5) / scaleWHWH.y - 0.5 : 0.0,
+                            ${outputWidth}.0 > 1.0 ? (fcoords.z + 0.5) / scaleWHWH.z - 0.5 : 0.0,
+                            ${outputHeight}.0 > 1.0 ? (fcoords.w + 0.5) / scaleWHWH.w - 0.5 : 0.0
+                          );
+                    }
+                `;
+          break;
+        case "align_corners":
+          getSourceFracIndex = `
+                    vec4 getSourceFracIndex(ivec4 coords) {
+                        vec4 resized = vec4(${outputWidth}.0 - 1.0, ${outputHeight}.0 - 1.0, ${outputWidth}.0 - 1.0,
+                            ${outputHeight}.0 - 1.0);
+                        vec4 original = vec4(${inputWidth}.0 - 1.0, ${inputHeight}.0 - 1.0, ${inputWidth}.0 - 1.0,
+                            ${inputHeight}.0 - 1.0);
+                        vec4 new_scale = original / resized;
+                        return vec4(coords) * new_scale;
+                    }
+                `;
+          break;
+        default:
+          throw new Error(`resize (packed) does not support coordinateTransformMode:                                 '${attributes.coordinateTransformMode}'`);
+      }
+      const coordsDataType = getCoordsDataType(dim);
+      const unpackChannel = unpackFromChannel();
+      const shaderSource = `
+            const vec2 inputWH = vec2(${inputHeight}.0, ${inputWidth}.0);
+            const vec4 scaleWHWH = vec4(float(${scalesHeight}), float(${scalesWidth}), float(${scalesHeight}), float(${scalesWidth}));
+            ${unpackChannel}
+            ${getSourceFracIndex}
+            float getAValue(int x10, int r, int c, int d) {
+                return getChannel(getA(x10, r, c, d), vec2(c, d));
+            }
+            void main() {
+                ${coordsDataType} rc = getOutputCoords();
+
+                int batch = rc[0];
+                int depth = rc[1];
+
+                // retrieve the 4 coordinates that is used in the 4 packed output values.
+                ivec4 coords = ivec4(rc.wz, rc.w + 1, rc.z + 1);
+
+                // calculate the source index in fraction
+                vec4 sourceFrac = getSourceFracIndex(coords);
+
+                // get the lower and upper bound of the 4 values that will be packed into one texel.
+                ivec4 x00 = ivec4(max(sourceFrac.xy, vec2(0.0)), min(inputWH - 1.0, ceil(sourceFrac.xy)));
+                ivec4 x01 = ivec4(max(sourceFrac.xw, vec2(0.0)), min(inputWH - 1.0, ceil(sourceFrac.xw)));
+                ivec4 x10 = ivec4(max(sourceFrac.zy, vec2(0.0)), min(inputWH - 1.0, ceil(sourceFrac.zy)));
+                ivec4 x11 = ivec4(max(sourceFrac.zw, vec2(0.0)), min(inputWH - 1.0, ceil(sourceFrac.zw)));
+
+                bool hasNextRow = rc.w < ${outputHeight - 1};
+                bool hasNextCol = rc.z < ${outputWidth - 1};
+
+                // pack x00, x01, x10, x11's top-left corner into one vec4 structure
+                vec4 topLeft = vec4(
+                    getAValue(batch, depth, x00.x, x00.y),
+                    hasNextCol ? getAValue(batch, depth, x01.x, x01.y) : 0.0,
+                    hasNextRow ? getAValue(batch, depth, x10.x, x10.y) : 0.0,
+                    (hasNextRow && hasNextCol) ? getAValue(batch, depth, x11.x, x11.y) : 0.0);
+
+                // pack x00, x01, x10, x11's top-right corner into one vec4 structure
+                vec4 topRight = vec4(
+                    getAValue(batch, depth, x00.x, x00.w),
+                    hasNextCol ? getAValue(batch, depth, x01.x, x01.w) : 0.0,
+                    hasNextRow ? getAValue(batch, depth, x10.x, x10.w) : 0.0,
+                    (hasNextRow && hasNextCol) ? getAValue(batch, depth, x11.x, x11.w) : 0.0);
+
+                // pack x00, x01, x10, x11's bottom-left corner into one vec4 structure
+                vec4 bottomLeft = vec4(
+                    getAValue(batch, depth, x00.z, x00.y),
+                    hasNextCol ? getAValue(batch, depth, x01.z, x01.y) : 0.0,
+                    hasNextRow ? getAValue(batch, depth, x10.z, x10.y) : 0.0,
+                    (hasNextRow && hasNextCol) ? getAValue(batch, depth, x11.z, x11.y) : 0.0);
+
+                // pack x00, x01, x10, x11's bottom-right corner into one vec4 structure
+                vec4 bottomRight = vec4(
+                    getAValue(batch, depth, x00.z, x00.w),
+                    hasNextCol ? getAValue(batch, depth, x01.z, x01.w) : 0.0,
+                    hasNextRow ? getAValue(batch, depth, x10.z, x10.w) : 0.0,
+                    (hasNextRow && hasNextCol) ? getAValue(batch, depth, x11.z, x11.w) : 0.0);
+
+                // calculate the interpolation fraction on u and v direction
+                vec4 frac = vec4(sourceFrac) - floor(sourceFrac);
+                vec4 clampFrac = clamp(frac, vec4(0.0), vec4(1.0));
+
+                vec4 top = mix(topLeft, topRight, clampFrac.ywyw);
+                vec4 bottom = mix(bottomLeft, bottomRight, clampFrac.ywyw);
+                vec4 newValue = mix(top, bottom, clampFrac.xxzz);
+
+                ${glsl.output} = vec4(newValue);
+            }
+        `;
+      return {
+        ...resizeProgramMetadata,
+        output: { dims: outputShape, type: inputs[0].type, textureType: 2 /* packed */ },
+        hasMain: true,
+        shaderSource
+      };
+    };
+    prepareInputs = (inputs, attributes) => {
+      const x = inputs[0];
+      const xDims = x.dims;
+      let scales = attributes.scales;
+      let outputSizes;
+      if (scales.length === 0) {
+        const scalesTensor = inputs[attributes.scalesInputIdx];
+        if (scalesTensor && scalesTensor.size !== 0) {
+          if (inputs[attributes.sizesInputIdx]) {
+            throw new Error("Only one of scales or sizes must be provided as input.");
+          }
+          scales = parseScalesData(scalesTensor, attributes.mode, attributes.isResize);
+        } else {
+          const sizesTensor = inputs[attributes.sizesInputIdx];
+          if (!sizesTensor || sizesTensor.size === 0) {
+            throw new Error("Either scales or sizes MUST be provided as input.");
+          }
+          outputSizes = Array.from(sizesTensor.integerData);
+          scales = parseScalesDataFromOutputSize(outputSizes, xDims, attributes.mode, attributes.isResize);
+        }
+      } else {
+        if (inputs[attributes.sizesInputIdx]) {
+          throw new Error("Only one of scales or sizes must be provided as input.");
+        }
+      }
+      const yDims = outputSizes || xDims.map((dim, i) => Math.floor(dim * scales[i]));
+      return [scales, yDims];
+    };
+    parseScalesData = (scale, mode, isResize) => {
+      const scales = Array.from(scale.floatData);
+      scalesValidation(scales, mode, isResize);
+      return scales;
+    };
+    parseScalesDataFromOutputSize = (yDims, xDims, mode, isResize) => {
+      const length = xDims.length;
+      const scales = new Array(length);
+      for (let i = 0, end = length; i < end; i++) {
+        if (xDims[i] === 0) {
+          if (yDims[i] !== 0) {
+            throw new Error("Input dim is zero but required output dim is non-zero.");
+          }
+          scales[i] = 1;
+        } else {
+          scales[i] = yDims[i] / xDims[i];
+        }
+      }
+      scalesValidation(scales, mode, isResize);
+      return scales;
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/shape.ts
+var shape, validateInputs18;
+var init_shape = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/shape.ts"() {
+    "use strict";
+    init_tensor2();
+    shape = (_inferenceHandler, inputs) => {
+      validateInputs18(inputs);
+      return [new Tensor4([inputs[0].dims.length], "int32", void 0, void 0, new Int32Array(inputs[0].dims))];
+    };
+    validateInputs18 = (inputs) => {
+      if (!inputs || inputs.length !== 1) {
+        throw new Error("Shape requires 1 input.");
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/slice.ts
+var sliceProgramMetadata, slice, parseSliceAttributes, createSliceProgramInfo, validateInputs19, sliceV10, generateSliceAttributesFromInputs, validateInputsV10;
+var init_slice = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/slice.ts"() {
+    "use strict";
+    init_attribute_with_cache_key();
+    init_operators();
+    init_util();
+    init_types();
+    sliceProgramMetadata = {
+      name: "Slice",
+      inputNames: ["A"],
+      inputTypes: [0 /* unpacked */]
+    };
+    slice = (inferenceHandler, inputs, attributes) => {
+      validateInputs19(inputs);
+      const output = inferenceHandler.run(
+        {
+          ...sliceProgramMetadata,
+          cacheHint: attributes.cacheKey,
+          get: () => createSliceProgramInfo(inferenceHandler, inputs[0], attributes)
+        },
+        inputs
+      );
+      return [output];
+    };
+    parseSliceAttributes = (node) => {
+      const starts = node.attributes.getInts("starts");
+      const ends = node.attributes.getInts("ends");
+      const axes = node.attributes.getInts("axes", []);
+      return createAttributeWithCacheKey({ starts, ends, axes });
+    };
+    createSliceProgramInfo = (_inferenceHandler, input, attributes) => {
+      const axes = attributes.axes.length === 0 ? input.dims.slice(0).map((_val, i) => i) : attributes.axes;
+      const normalizedAxes = ShapeUtil.normalizeAxes(axes, input.dims.length);
+      const starts = attributes.starts.map((start, i) => {
+        if (start > input.dims[normalizedAxes[i]] - 1) {
+          return input.dims[normalizedAxes[i]];
+        }
+        return ShapeUtil.normalizeAxis(start, input.dims[normalizedAxes[i]]);
+      });
+      const ends = attributes.ends.map((end, i) => {
+        if (end > input.dims[normalizedAxes[i]] - 1) {
+          return input.dims[normalizedAxes[i]];
+        }
+        return ShapeUtil.normalizeAxis(end, input.dims[normalizedAxes[i]]);
+      });
+      const outputShape = input.dims.slice();
+      const sliceOps = [];
+      for (let i = 0; i < normalizedAxes.length; i++) {
+        outputShape[normalizedAxes[i]] = ends[i] - starts[i];
+        if (starts[i] > 0) {
+          sliceOps.push(`outputIdx[${normalizedAxes[i]}] += ${starts[i]};`);
+        }
+      }
+      const rank = outputShape.length;
+      const shaderSource = `
+      float process(int outputIdx[${rank}]) {
+        ${sliceOps.join("\n      ")}
+        return _A(outputIdx);
+      }`;
+      return {
+        ...sliceProgramMetadata,
+        output: { dims: outputShape, type: input.type, textureType: 0 /* unpacked */ },
+        shaderSource
+      };
+    };
+    validateInputs19 = (inputs) => {
+      if (!inputs || inputs.length !== 1) {
+        throw new Error("Slice requires 1 input.");
+      }
+      if (NUMBER_TYPES.indexOf(inputs[0].type) === -1) {
+        throw new Error("Invalid input type.");
+      }
+    };
+    sliceV10 = (inferenceHandler, inputs) => {
+      validateInputsV10(inputs);
+      const attributes = generateSliceAttributesFromInputs(inferenceHandler, inputs);
+      const output = inferenceHandler.run(
+        {
+          ...sliceProgramMetadata,
+          cacheHint: attributes.cacheKey,
+          get: () => createSliceProgramInfo(inferenceHandler, inputs[0], attributes)
+        },
+        [inputs[0]]
+      );
+      return [output];
+    };
+    generateSliceAttributesFromInputs = (inferenceHandler, inputs) => {
+      if (!inferenceHandler.session.isInitializer(inputs[1].dataId) || !inferenceHandler.session.isInitializer(inputs[2].dataId) || inputs.length >= 4 && !inferenceHandler.session.isInitializer(inputs[3].dataId) || inputs.length >= 5 && !inferenceHandler.session.isInitializer(inputs[4].dataId)) {
+        throw new Error("dynamic slice attributes are not allowed");
+      }
+      if (inputs.length >= 5 && inputs[4].integerData.some((i) => i !== 1)) {
+        throw new Error("currently non-1 steps is not supported for Slice");
+      }
+      const starts = Array.from(inputs[1].integerData);
+      const ends = Array.from(inputs[2].integerData);
+      const axes = inputs.length >= 4 ? Array.from(inputs[3].integerData) : [];
+      const cacheKey = `${axes};${starts};${ends}`;
+      return { starts, ends, axes, cacheKey };
+    };
+    validateInputsV10 = (inputs) => {
+      if (!inputs || inputs.length < 3 || inputs.length > 5) {
+        throw new Error("Invalid input number.");
+      }
+      if (inputs[1].type !== "int32" || inputs[1].dims.length !== 1) {
+        throw new Error("Invalid input type.");
+      }
+      if (inputs[2].type !== "int32" || inputs[2].dims.length !== 1) {
+        throw new Error("Invalid input type.");
+      }
+      if (inputs.length >= 4 && (inputs[3].type !== "int32" || inputs[3].dims.length !== 1)) {
+        throw new Error("Invalid input type.");
+      }
+      if (inputs.length >= 5 && (inputs[4].type !== "int32" || inputs[4].dims.length !== 1)) {
+        throw new Error("Invalid input type.");
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/softmax.ts
+var softmaxComputeMaxProgramMetadata, softmaxComputeScaleProgramMetadata, softmaxProgramMetadata, softmax, parseSoftmaxAttributes, parseSoftmaxAttributesV13, softmaxV13, computeSoftmax, createComputeMaxProgramInfo, createComputScaleProgramInfo, createSoftMaxProgramInfo, validateInputs20;
+var init_softmax = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/softmax.ts"() {
+    "use strict";
+    init_attribute_with_cache_key();
+    init_util();
+    init_glsl_source();
+    init_types();
+    init_transpose();
+    softmaxComputeMaxProgramMetadata = {
+      name: "SoftmaxComputeMax",
+      inputNames: ["A"],
+      inputTypes: [0 /* unpacked */]
+    };
+    softmaxComputeScaleProgramMetadata = {
+      name: "SoftmaxComputeScale",
+      inputNames: ["A", "Max"],
+      inputTypes: [0 /* unpacked */, 0 /* unpacked */]
+    };
+    softmaxProgramMetadata = {
+      name: "SoftMax",
+      inputNames: ["A", "Max", "Norm"],
+      inputTypes: [0 /* unpacked */, 0 /* unpacked */, 0 /* unpacked */]
+    };
+    softmax = (inferenceHandler, inputs, attributes) => {
+      validateInputs20(inputs);
+      const inputShape = inputs[0].dims.slice();
+      const axis = ShapeUtil.normalizeAxis(attributes.axis, inputShape.length);
+      const logicalRowCount = ShapeUtil.sizeToDimension(inputShape, axis);
+      const featureCount = ShapeUtil.sizeFromDimension(inputShape, axis);
+      const output = computeSoftmax(inferenceHandler, inputs, attributes, logicalRowCount, featureCount);
+      return output;
+    };
+    parseSoftmaxAttributes = (node) => createAttributeWithCacheKey({ axis: node.attributes.getInt("axis", 1) });
+    parseSoftmaxAttributesV13 = (node) => createAttributeWithCacheKey({ axis: node.attributes.getInt("axis", -1) });
+    softmaxV13 = (inferenceHandler, inputs, attributes) => {
+      validateInputs20(inputs);
+      const inputShape = inputs[0].dims.slice();
+      const axis = ShapeUtil.normalizeAxis(attributes.axis, inputShape.length);
+      const rank = inputShape.length;
+      const isTransposeRequired = axis !== rank - 1 ? true : false;
+      const transposedInputShape = [];
+      let perm = [];
+      let transposedInputs = [];
+      let transposeAttribute;
+      if (isTransposeRequired) {
+        perm = Array.from({ length: rank }).map((_, i) => i);
+        perm[axis] = rank - 1;
+        perm[rank - 1] = axis;
+        perm.map((p) => transposedInputShape.push(inputShape[p]));
+        transposeAttribute = createAttributeWithCacheKey({ perm });
+        transposedInputs = transpose(inferenceHandler, inputs, transposeAttribute);
+      }
+      const logicalRowCount = isTransposeRequired ? ShapeUtil.sizeToDimension(transposedInputShape, rank - 1) : ShapeUtil.sizeToDimension(inputShape, rank - 1);
+      const featureCount = isTransposeRequired ? ShapeUtil.sizeFromDimension(transposedInputShape, rank - 1) : ShapeUtil.sizeFromDimension(inputShape, rank - 1);
+      const output = computeSoftmax(
+        inferenceHandler,
+        isTransposeRequired ? transposedInputs : inputs,
+        attributes,
+        logicalRowCount,
+        featureCount
+      );
+      if (isTransposeRequired) {
+        const reversedOutput = transpose(inferenceHandler, output, transposeAttribute);
+        return reversedOutput;
+      } else {
+        return output;
+      }
+    };
+    computeSoftmax = (inferenceHandler, inputs, attributes, logicalRowCount, featureCount) => {
+      const computeMaxProgramInfo = createComputeMaxProgramInfo(
+        inferenceHandler,
+        inputs[0],
+        logicalRowCount,
+        featureCount,
+        [logicalRowCount]
+      );
+      const max = inferenceHandler.run(
+        { ...softmaxComputeMaxProgramMetadata, cacheHint: attributes.cacheKey, get: () => computeMaxProgramInfo },
+        inputs
+      );
+      const computeScaleProgramInfo = createComputScaleProgramInfo(
+        inferenceHandler,
+        inputs[0],
+        logicalRowCount,
+        featureCount,
+        computeMaxProgramInfo.output.dims,
+        [logicalRowCount]
+      );
+      const scale = inferenceHandler.run(
+        { ...softmaxComputeScaleProgramMetadata, cacheHint: attributes.cacheKey, get: () => computeScaleProgramInfo },
+        [inputs[0], max]
+      );
+      const softMaxProgramInfo = createSoftMaxProgramInfo(
+        inferenceHandler,
+        inputs[0],
+        logicalRowCount,
+        featureCount,
+        computeMaxProgramInfo.output.dims,
+        computeScaleProgramInfo.output.dims
+      );
+      const output = inferenceHandler.run(
+        { ...softmaxProgramMetadata, cacheHint: attributes.cacheKey, get: () => softMaxProgramInfo },
+        [inputs[0], max, scale]
+      );
+      return [output];
+    };
+    createComputeMaxProgramInfo = (inferenceHandler, input, logicalRowCount, featureCount, outputShape) => {
+      const [textureWidth, textureHeight] = inferenceHandler.calculateTextureWidthAndHeight(
+        input.dims,
+        0 /* unpacked */
+      );
+      const rank = outputShape.length;
+      if (logicalRowCount < 1 || featureCount < 1) {
+        throw new Error("Logical row count N and feature count D must be greater than or equal to 1");
+      }
+      if (outputShape.length !== 1) {
+        throw new Error("Dimensionality of the output should be 1");
+      }
+      if (outputShape[0] !== logicalRowCount) {
+        throw new Error("Shape of the output should be equal to logical row count");
+      }
+      const glsl = getGlsl(inferenceHandler.session.backend.glContext.version);
+      const shaderSource = `
+      float process(int[${rank}] indices) {
+        int logical_row_start_offset = indices[0] * ${featureCount};
+
+        float max = getColorAsFloat(${glsl.texture2D}(A, offsetToCoords(logical_row_start_offset, ${textureWidth},
+        ${textureHeight} )));
+        for(int i=1; i<${featureCount}; ++i)
+        {
+          float current = getColorAsFloat(${glsl.texture2D}(A, offsetToCoords(logical_row_start_offset + i,
+            ${textureWidth}, ${textureHeight})));
+          if(current > max)
+          max = current;
+        }
+
+        return max;
+      }`;
+      return {
+        ...softmaxComputeMaxProgramMetadata,
+        output: { dims: outputShape, type: input.type, textureType: 0 /* unpacked */ },
+        shaderSource
+      };
+    };
+    createComputScaleProgramInfo = (inferenceHandler, input, logicalRowCount, featureCount, maxElementPerLogicalRow, outputShape) => {
+      const [textureWidth, textureHeight] = inferenceHandler.calculateTextureWidthAndHeight(
+        input.dims,
+        0 /* unpacked */
+      );
+      const rank = outputShape.length;
+      if (logicalRowCount < 1 || featureCount < 1) {
+        throw new Error("Logical row count N and feature count D must be greater than or equal to 1");
+      }
+      if (outputShape.length !== 1) {
+        throw new Error("Dimensionality of the output should be 1");
+      }
+      if (outputShape[0] !== logicalRowCount) {
+        throw new Error("Shape of the output should be equal to logical row count");
+      }
+      if (maxElementPerLogicalRow.length !== 1) {
+        throw new Error("Dimensionality of the intermediate results should be 1");
+      }
+      if (maxElementPerLogicalRow[0] !== logicalRowCount) {
+        throw new Error("Shape of the intermediate results should be equal to logical row count");
+      }
+      const glsl = getGlsl(inferenceHandler.session.backend.glContext.version);
+      const shaderSource = `
+      float process(int[${rank}] indices) {
+        int logical_row_start_offset = indices[0] * ${featureCount};
+
+        float norm_factor = 0.0;
+        float max = _Max(indices);
+        for(int i=0; i<${featureCount}; ++i)
+        {
+          norm_factor += exp(getColorAsFloat(${glsl.texture2D}(A, offsetToCoords(logical_row_start_offset + i,
+            ${textureWidth}, ${textureHeight}))) - max);
+        }
+
+        return norm_factor;
+      }`;
+      return {
+        ...softmaxComputeScaleProgramMetadata,
+        output: { dims: outputShape, type: input.type, textureType: 0 /* unpacked */ },
+        shaderSource
+      };
+    };
+    createSoftMaxProgramInfo = (inferenceHandler, input, logicalRowCount, featureCount, maxElementPerLogicalRow, normalizationPerLogicalRow) => {
+      const [textureWidth, textureHeight] = inferenceHandler.calculateTextureWidthAndHeight(
+        input.dims,
+        0 /* unpacked */
+      );
+      const rank = input.dims.length;
+      if (logicalRowCount < 1 || featureCount < 1) {
+        throw new Error("Logical row count N and feature count D must be greater than or equal to 1");
+      }
+      if (maxElementPerLogicalRow.length !== 1 || normalizationPerLogicalRow.length !== 1) {
+        throw new Error("Dimensionality of the intermediate results should be 1");
+      }
+      if (maxElementPerLogicalRow[0] !== logicalRowCount || normalizationPerLogicalRow[0] !== logicalRowCount) {
+        throw new Error("Shape of the intermediate results should be equal to logical row count");
+      }
+      const shaderSource = `
+      float process(int[${rank}] indices) {
+
+      // get offset of current logical tensor index from the 2-D texture coordinates (TexCoords)
+      int offset = coordsToOffset(TexCoords, ${textureWidth}, ${textureHeight});
+
+      //determine the logical row for this index
+      int logical_row_index[1];
+      logical_row_index[0] = offset / ${featureCount};
+
+      float norm_factor = _Norm(logical_row_index);
+
+      // avoid possible division by 0
+      // if norm_facor is 0, all elements are zero
+      // if so, return 0
+      if(norm_factor == 0.0)
+        return 0.0;
+
+      return exp(_A(indices) - _Max(logical_row_index)) / norm_factor;
+    }`;
+      return {
+        ...softmaxProgramMetadata,
+        output: { dims: input.dims, type: input.type, textureType: 0 /* unpacked */ },
+        shaderSource
+      };
+    };
+    validateInputs20 = (inputs) => {
+      if (!inputs || inputs.length !== 1) {
+        throw new Error("Softmax requires 1 input.");
+      }
+      if (inputs[0].type !== "float32" && inputs[0].type !== "float64") {
+        throw new Error("Invalid input type");
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/split.ts
+var splitProgramMetadata, split, parseSplitAttributes, getProgramCount, createSplitProgramInfo, validateInputs21;
+var init_split = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/split.ts"() {
+    "use strict";
+    init_attribute_with_cache_key();
+    init_util();
+    init_types();
+    splitProgramMetadata = {
+      name: "Split",
+      inputNames: ["A"],
+      inputTypes: [0 /* unpacked */]
+    };
+    split = (inferenceHandler, inputs, attributes) => {
+      validateInputs21(inputs);
+      const axis = ShapeUtil.normalizeAxis(attributes.axis, inputs[0].dims.length);
+      const count = getProgramCount(inferenceHandler, inputs, axis, attributes);
+      const output = [];
+      for (let i = 0; i < count; ++i) {
+        output.push(
+          inferenceHandler.run(
+            {
+              ...splitProgramMetadata,
+              cacheHint: `${attributes.cacheKey};${i}`,
+              get: () => createSplitProgramInfo(inferenceHandler, inputs[0], attributes, axis, i)
+            },
+            inputs
+          )
+        );
+      }
+      return output;
+    };
+    parseSplitAttributes = (node) => {
+      const axis = node.attributes.getInt("axis", 0);
+      const split2 = node.attributes.getInts("split", []);
+      const numOutputs = node.outputs.length;
+      return createAttributeWithCacheKey({ axis, split: split2, numOutputs });
+    };
+    getProgramCount = (_inferenceHandler, inputs, axis, attributes) => {
+      const [, offsets] = SplitUtil.splitShape(inputs[0].dims, axis, attributes.split, attributes.numOutputs);
+      return offsets.length;
+    };
+    createSplitProgramInfo = (_inferenceHandler, input, attributes, axis, index) => {
+      const [shapes, offsets] = SplitUtil.splitShape(input.dims, axis, attributes.split, attributes.numOutputs);
+      const offset = offsets[index];
+      const outputShape = shapes[index];
+      const rank = outputShape.length;
+      const shaderSource = `
+      float process(int indices[${rank}]) {
+        indices[${axis}] += ${offset};
+        return _A(indices);
+      }
+    `;
+      return {
+        ...splitProgramMetadata,
+        cacheHint: `${attributes.cacheKey}:${index}`,
+        output: { dims: outputShape, type: input.type, textureType: 0 /* unpacked */ },
+        shaderSource
+      };
+    };
+    validateInputs21 = (inputs) => {
+      if (!inputs || inputs.length !== 1) {
+        throw new Error("Split requires one input.");
+      }
+      if (inputs[0].type !== "int8" && inputs[0].type !== "uint8" && inputs[0].type !== "int16" && inputs[0].type !== "uint16" && inputs[0].type !== "int32" && inputs[0].type !== "uint32" && inputs[0].type !== "float32" && inputs[0].type !== "float64" && inputs[0].type !== "bool") {
+        throw new Error("Invalid input type.");
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/squeeze.ts
+var squeeze, squeezeV13, parseSqueezeAttributes, validateInputs22, validateInputsV13;
+var init_squeeze = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/squeeze.ts"() {
+    "use strict";
+    init_util();
+    squeeze = (inferenceHandler, inputs, axes) => {
+      validateInputs22(inputs);
+      const outputShape = ShapeUtil.squeezeShape(inputs[0].dims, axes);
+      const output = inferenceHandler.reshapeUnpacked(inputs[0], outputShape);
+      return [output];
+    };
+    squeezeV13 = (inferenceHandler, inputs) => {
+      validateInputsV13(inputs);
+      return squeeze(inferenceHandler, [inputs[0]], Array.from(inputs[1].integerData));
+    };
+    parseSqueezeAttributes = (node) => node.attributes.getInts("axes");
+    validateInputs22 = (inputs) => {
+      if (!inputs || inputs.length !== 1) {
+        throw new Error("Squeeze requires 1 input.");
+      }
+      if (inputs[0].type === "string") {
+        throw new Error("invalid input tensor types.");
+      }
+    };
+    validateInputsV13 = (inputs) => {
+      if (!inputs || inputs.length !== 2) {
+        throw new Error("Squeeze requires 2 inputs.");
+      }
+      if (inputs[1].type !== "int32") {
+        throw new Error("Invalid input type.");
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/sum.ts
+var sum, createSumProgramInfo, validateInputs23;
+var init_sum = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/sum.ts"() {
+    "use strict";
+    init_glsl_source();
+    init_types();
+    sum = (inferenceHandler, inputs) => {
+      validateInputs23(inputs);
+      const sumProgramMetadata = {
+        name: "Sum",
+        inputNames: inputs.map((_v, i) => `X${i}`),
+        inputTypes: new Array(inputs.length).fill(0 /* unpacked */)
+      };
+      const output = inferenceHandler.run(
+        { ...sumProgramMetadata, get: () => createSumProgramInfo(inferenceHandler, inputs, sumProgramMetadata) },
+        inputs
+      );
+      return [output];
+    };
+    createSumProgramInfo = (inferenceHandler, inputs, sumProgramMetadata) => {
+      const glsl = getGlsl(inferenceHandler.session.backend.glContext.version);
+      const outputShape = inputs[0].dims.slice();
+      const sumLine = inputs.map((_v, i) => `${glsl.texture2D}(X${i},TexCoords)`).join(" + ");
+      const shaderSource = `
+      void main() {
+        vec4 result = ${sumLine};
+        ${glsl.output} = result;
+      }
+    `;
+      return {
+        ...sumProgramMetadata,
+        output: { dims: outputShape, type: inputs[0].type, textureType: 0 /* unpacked */ },
+        hasMain: true,
+        shaderSource
+      };
+    };
+    validateInputs23 = (inputs) => {
+      if (!inputs || inputs.length === 0) {
+        throw new Error("Sum requires inputs.");
+      }
+      const length = inputs[0].dims.length;
+      for (let i = 1; i < inputs.length; i++) {
+        if (length !== inputs[i].dims.length) {
+          throw new Error("Input shapes are mismatched.");
+        }
+        for (let j = 0; j < length; j++) {
+          if (inputs[0].dims[j] !== inputs[i].dims[j]) {
+            throw new Error("Input shapes are not matched.");
+          }
+        }
+      }
+      if (inputs[0].type !== "float32" && inputs[0].type !== "float64") {
+        throw new Error("Invalid input type.");
+      }
+      for (let i = 1; i < inputs.length; i++) {
+        if (inputs[0].type !== inputs[i].type) {
+          throw new Error("Input types are not matched.");
+        }
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/tile.ts
+var tile, createTileProgramInfo, validateInputs24;
+var init_tile = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/tile.ts"() {
+    "use strict";
+    init_operators();
+    init_types();
+    tile = (inferenceHandler, inputs) => {
+      validateInputs24(inputs);
+      const tileProgramMetadata = {
+        name: "Tile",
+        inputNames: ["A"],
+        inputTypes: [0 /* unpacked */]
+      };
+      const output = inferenceHandler.run(
+        { ...tileProgramMetadata, get: () => createTileProgramInfo(inferenceHandler, inputs, tileProgramMetadata) },
+        inputs
+      );
+      return [output];
+    };
+    createTileProgramInfo = (_handler, inputs, tileProgramMetadata) => {
+      const inputShape = inputs[0].dims.slice();
+      const outputShape = new Array(inputShape.length);
+      const tileOps = [];
+      for (let i = 0; i < inputShape.length; i++) {
+        outputShape[i] = inputShape[i] * inputs[1].numberData[i];
+        tileOps.push(`inputIdx[${i}] = int(mod(float(outputIdx[${i}]), ${inputShape[i]}.));`);
+      }
+      const rank = outputShape.length;
+      const shaderSource = `
+      float process(int outputIdx[${rank}]) {
+        int inputIdx[${rank}];
+        ${tileOps.join("\n")}
+        return _A(inputIdx);
+      }
+    `;
+      return {
+        ...tileProgramMetadata,
+        output: { dims: outputShape, type: inputs[0].type, textureType: 0 /* unpacked */ },
+        shaderSource
+      };
+    };
+    validateInputs24 = (inputs) => {
+      if (!inputs || inputs.length !== 2) {
+        throw new Error("Tile requires 2 input.");
+      }
+      if (inputs[1].dims.length !== 1) {
+        throw new Error("The second input shape must 1 dimension.");
+      }
+      if (inputs[1].dims[0] !== inputs[0].dims.length) {
+        throw new Error("Invalid input shape.");
+      }
+      if (NUMBER_TYPES.indexOf(inputs[0].type) === -1) {
+        throw new Error("Invalid input type.");
+      }
+      if (inputs[1].type !== "int32" && inputs[1].type !== "int16") {
+        throw new Error("Invalid repeat type.");
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/ops/unsqueeze.ts
+var unsqueeze, unsqueezeV13, parseUnsqueezeAttributes, validateInputs25, validateInputsV132;
+var init_unsqueeze = __esm({
+  "web/lib/onnxjs/backends/webgl/ops/unsqueeze.ts"() {
+    "use strict";
+    init_util();
+    unsqueeze = (inferenceHandler, inputs, axes) => {
+      validateInputs25(inputs);
+      const outputShape = ShapeUtil.unsqueezeShape(inputs[0].dims, axes);
+      const output = inferenceHandler.reshapeUnpacked(inputs[0], outputShape);
+      return [output];
+    };
+    unsqueezeV13 = (inferenceHandler, inputs) => {
+      validateInputsV132(inputs);
+      return unsqueeze(inferenceHandler, [inputs[0]], Array.from(inputs[1].integerData));
+    };
+    parseUnsqueezeAttributes = (node) => node.attributes.getInts("axes");
+    validateInputs25 = (inputs) => {
+      if (!inputs || inputs.length !== 1) {
+        throw new Error("Unsqueeze requires 1 input.");
+      }
+      if (inputs[0].type === "string") {
+        throw new Error("invalid input tensor types.");
+      }
+    };
+    validateInputsV132 = (inputs) => {
+      if (!inputs || inputs.length !== 2) {
+        throw new Error("Unsqueeze requires 2 inputs.");
+      }
+      if (inputs[1].type !== "int32") {
+        throw new Error("Invalid input type.");
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/op-resolve-rules.ts
+var WEBGL_OP_RESOLVE_RULES;
+var init_op_resolve_rules = __esm({
+  "web/lib/onnxjs/backends/webgl/op-resolve-rules.ts"() {
+    "use strict";
+    init_batch_normalization();
+    init_binary_op();
+    init_cast();
+    init_concat();
+    init_conv();
+    init_conv_transpose();
+    init_depth_to_space();
+    init_flatten();
+    init_gather();
+    init_gemm();
+    init_image_scaler();
+    init_instance_normalization();
+    init_lrn();
+    init_matmul();
+    init_pad();
+    init_pool();
+    init_reduce();
+    init_reshape();
+    init_resize_packed();
+    init_shape();
+    init_slice();
+    init_softmax();
+    init_split();
+    init_squeeze();
+    init_sum();
+    init_tile();
+    init_transpose();
+    init_unary_op();
+    init_unsqueeze();
+    init_upsample();
+    WEBGL_OP_RESOLVE_RULES = [
+      ["Abs", "", "6+", abs],
+      ["Acos", "", "7+", acos],
+      ["Add", "", "7+", add2],
+      ["And", "", "7+", and2],
+      ["Asin", "", "7+", asin],
+      ["Atan", "", "7+", atan],
+      // TODO: support new attributes for AveragePool-10
+      ["AveragePool", "", "7+", averagePool, parseAveragePoolAttributes],
+      ["BatchNormalization", "", "7+", batchNormalization, parseBatchNormalizationAttributes],
+      ["Cast", "", "6+", cast, parseCastAttributes],
+      ["Ceil", "", "6+", ceil],
+      ["Clip", "", "6-10", clip, parseClipAttributes],
+      ["Clip", "", "11+", clipV11],
+      ["Concat", "", "4+", concat, parseConcatAttributes],
+      ["Conv", "", "1+", conv, parseConvAttributes],
+      ["ConvTranspose", "", "1+", convTranspose, parseConvTransposeAttributes],
+      ["Cos", "", "7+", cos],
+      ["Div", "", "7+", div],
+      ["Dropout", "", "7+", identity],
+      ["DepthToSpace", "", "1+", depthToSpace, parseDepthToSpaceAttributes],
+      ["Equal", "", "7+", equal],
+      ["Elu", "", "6+", elu, parseEluAttributes],
+      ["Exp", "", "6+", exp],
+      ["Flatten", "", "1+", flatten, parseFlattenAttributes],
+      ["Floor", "", "6+", floor],
+      ["FusedConv", "com.microsoft", "1+", conv, parseConvAttributes],
+      ["Gather", "", "1+", gather, parseGatherAttributes],
+      ["Gemm", "", "7-10", gemm, parseGemmAttributesV7],
+      ["Gemm", "", "11+", gemm, parseGemmAttributesV11],
+      ["GlobalAveragePool", "", "1+", globalAveragePool, parseGlobalAveragePoolAttributes],
+      ["GlobalMaxPool", "", "1+", globalMaxPool],
+      ["Greater", "", "7+", greater],
+      ["Identity", "", "1+", identity],
+      ["ImageScaler", "", "1+", imageScaler, parseImageScalerAttributes],
+      ["InstanceNormalization", "", "6+", instanceNormalization, parseInstanceNormalizationAttributes],
+      ["LeakyRelu", "", "6+", leakyRelu, parseLeakyReluAttributes],
+      ["Less", "", "7+", less],
+      ["LRN", "", "1+", lrn, parseLrnAttributes],
+      ["Log", "", "6+", log2],
+      ["MatMul", "", "1+", matMul, parseMatMulAttributes],
+      // TODO: support new attributes for MaxPool-8 and MaxPool-10
+      ["MaxPool", "", "1+", maxPool, parseMaxPoolAttributes],
+      ["Mul", "", "7+", mul],
+      ["Neg", "", "6+", neg],
+      ["Not", "", "1+", not2],
+      ["Or", "", "7+", or2],
+      ["Pad", "", "2-10", padV2, parsePadAttributesV2],
+      ["Pad", "", "11+", padV11, parsePadAttributesV11],
+      ["Pow", "", "7+", pow],
+      ["PRelu", "", "7+", pRelu],
+      ["ReduceLogSum", "", "1+", reduceLogSum, parseReduceAttributes],
+      ["ReduceMax", "", "1+", reduceMax, parseReduceAttributes],
+      ["ReduceMean", "", "1+", reduceMean, parseReduceAttributes],
+      ["ReduceMin", "", "1+", reduceMin, parseReduceAttributes],
+      ["ReduceProd", "", "1+", reduceProd, parseReduceAttributes],
+      ["ReduceSum", "", "1-12", reduceSum, parseReduceAttributes],
+      ["ReduceSumSquare", "", "1+", reduceLogSumSquare, parseReduceAttributes],
+      ["Relu", "", "6+", relu],
+      ["Reshape", "", "5+", reshape],
+      ["Resize", "", "10", resize, parseResizeAttributesV10],
+      ["Resize", "", "11+", resize, parseResizeAttributesV11],
+      ["Shape", "", "1+", shape],
+      ["Sigmoid", "", "6+", sigmoid],
+      ["Sin", "", "7+", sin],
+      ["Slice", "", "10+", sliceV10],
+      // TODO: support 'steps' for Slice-10
+      ["Slice", "", "1-9", slice, parseSliceAttributes],
+      // The "semantic" meaning of axis has changed in opset-13.
+      ["Softmax", "", "1-12", softmax, parseSoftmaxAttributes],
+      ["Softmax", "", "13+", softmaxV13, parseSoftmaxAttributesV13],
+      // 'Split' operator has an optional attribute 'split'
+      // this attribute determines how the specified axis of input data is split.
+      // When the attribute is missing, we need the count of number of outputs
+      // so that we can determine the 'split' attribute from the runtime input to the Operator
+      ["Split", "", "2-12", split, parseSplitAttributes],
+      ["Sqrt", "", "6+", sqrt],
+      ["Squeeze", "", "1-12", squeeze, parseSqueezeAttributes],
+      ["Squeeze", "", "13+", squeezeV13],
+      ["Sub", "", "7+", sub],
+      ["Sum", "", "6+", sum],
+      ["Tan", "", "7+", tan],
+      ["Tanh", "", "6+", tanh],
+      ["Tile", "", "6+", tile],
+      ["Transpose", "", "1+", transpose, parseTransposeAttributes],
+      ["Upsample", "", "7-8", upsample, parseUpsampleAttributesV7],
+      ["Upsample", "", "9", upsample, parseUpsampleAttributesV9],
+      ["Unsqueeze", "", "1-12", unsqueeze, parseUnsqueezeAttributes],
+      ["Unsqueeze", "", "13+", unsqueezeV13],
+      ["Xor", "", "7+", xor2]
+    ];
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/glsl-function-inliner.ts
+function replaceInlines(script) {
+  const inlineDefs = {};
+  let match;
+  while ((match = INLINE_FUNC_DEF_REGEX.exec(script)) !== null) {
+    const params = match[3].split(",").map((s) => {
+      const tokens = s.trim().split(" ");
+      if (tokens && tokens.length === 2) {
+        return { type: tokens[0], name: tokens[1] };
+      }
+      return null;
+    }).filter((v) => v !== null);
+    inlineDefs[match[2]] = { params, body: match[4] };
+  }
+  for (const name2 in inlineDefs) {
+    const regexString = FUNC_CALL_REGEX.replace("__FUNC__", name2);
+    const regex = new RegExp(regexString, "gm");
+    while ((match = regex.exec(script)) !== null) {
+      const type = match[1];
+      const variable = match[2];
+      const params = match[3].split(",");
+      const declLine = type ? `${type} ${variable};` : "";
+      let newBody = inlineDefs[name2].body;
+      let paramRedecLine = "";
+      inlineDefs[name2].params.forEach((v, i) => {
+        if (v) {
+          paramRedecLine += `${v.type} ${v.name} = ${params[i]};
+`;
+        }
+      });
+      newBody = `${paramRedecLine}
+ ${newBody}`;
+      newBody = newBody.replace("return", `${variable} = `);
+      const replacement = `
+      ${declLine}
+      {
+        ${newBody}
+      }
+      `;
+      script = script.replace(match[0], replacement);
+    }
+  }
+  script = script.replace(INLINE_FUNC_DEF_REGEX, "");
+  return script;
+}
+var INLINE_FUNC_DEF_REGEX, FUNC_CALL_REGEX;
+var init_glsl_function_inliner = __esm({
+  "web/lib/onnxjs/backends/webgl/glsl-function-inliner.ts"() {
+    "use strict";
+    INLINE_FUNC_DEF_REGEX = /@inline[\s\n\r]+(\w+)[\s\n\r]+([0-9a-zA-Z_]+)\s*\(([^)]*)\)\s*{(([^}]|[\n\r])*)}/gm;
+    FUNC_CALL_REGEX = "(\\w+)?\\s+([_0-9a-zA-Z]+)\\s+=\\s+__FUNC__\\((.*)\\)\\s*;";
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/texture-layout-strategy.ts
+function squeezeShape(shape2, axis) {
+  const newShape = [];
+  const keptDims = [];
+  const isEmptyArray = axis != null && Array.isArray(axis) && axis.length === 0;
+  const axes = axis == null || isEmptyArray ? null : parseAxisParam(axis, shape2).sort();
+  let j = 0;
+  for (let i = 0; i < shape2.length; ++i) {
+    if (axes != null) {
+      if (axes[j] === i && shape2[i] !== 1) {
+        throw new Error(`Can't squeeze axis ${i} since its dim '${shape2[i]}' is not 1`);
+      }
+      if ((axes[j] == null || axes[j] > i) && shape2[i] === 1) {
+        newShape.push(shape2[i]);
+        keptDims.push(i);
+      }
+      if (axes[j] <= i) {
+        j++;
+      }
+    }
+    if (shape2[i] !== 1) {
+      newShape.push(shape2[i]);
+      keptDims.push(i);
+    }
+  }
+  return { newShape, keptDims };
+}
+function parseAxisParam(axis, shape2) {
+  const rank = shape2.length;
+  axis = axis == null ? shape2.map((_s, i) => i) : [].concat(axis);
+  assert(
+    axis.every((ax) => ax >= -rank && ax < rank),
+    () => `All values in axis param must be in range [-${rank}, ${rank}) but got axis ${axis}`
+  );
+  assert(axis.every(isInt), () => `All values in axis param must be integers but got axis ${axis}`);
+  return axis.map((a) => a < 0 ? rank + a : a);
+}
+function isInt(a) {
+  return a % 1 === 0;
+}
+function sizeFromShape(shape2) {
+  if (shape2.length === 0) {
+    return 1;
+  }
+  let size = shape2[0];
+  for (let i = 1; i < shape2.length; i++) {
+    size *= shape2[i];
+  }
+  return size;
+}
+function sizeToSquarishShape(size) {
+  const width = Math.ceil(Math.sqrt(size));
+  return [width, Math.ceil(size / width)];
+}
+var PreferLogicalStrategy;
+var init_texture_layout_strategy = __esm({
+  "web/lib/onnxjs/backends/webgl/texture-layout-strategy.ts"() {
+    "use strict";
+    init_instrument();
+    init_util();
+    PreferLogicalStrategy = class {
+      constructor(maxTextureSize) {
+        this.maxTextureSize = maxTextureSize;
+      }
+      computeTextureWH(shape2, prefs) {
+        const wh = this.computeTexture(shape2, prefs);
+        if (prefs && prefs.isPacked) {
+          wh[0] /= 2;
+          wh[1] /= 2;
+        }
+        if (prefs && prefs.reverseWH) {
+          return [wh[1], wh[0]];
+        }
+        return wh;
+      }
+      computeTexture(shape2, prefs) {
+        const isPacked = prefs && prefs.isPacked;
+        if (shape2.length === 0) {
+          return isPacked ? [2, 2] : [1, 1];
+        }
+        let maxTextureSize = this.maxTextureSize;
+        if (prefs && prefs.breakAxis !== void 0) {
+          const wsize = prefs.breakAxis >= shape2.length ? 1 : shape2.slice(prefs.breakAxis).reduce((a, b) => a * b);
+          const hsize = prefs.breakAxis <= 0 ? 1 : shape2.slice(0, prefs.breakAxis).reduce((a, b) => a * b);
+          if (wsize > maxTextureSize || hsize > maxTextureSize) {
+            Logger.verbose(
+              "TextureLayout",
+              `Given width/height preferences were unattainable: shape:${shape2}, breakAxis:${prefs.breakAxis}`
+            );
+          } else {
+            return [wsize, hsize];
+          }
+        }
+        let logShape = shape2.slice(0);
+        if (isPacked) {
+          maxTextureSize = maxTextureSize * 2;
+          logShape = logShape.map(
+            (_d, i) => i >= logShape.length - 2 ? logShape[i] % 2 === 0 ? logShape[i] : logShape[i] + 1 : logShape[i]
+          );
+          if (logShape.length === 1) {
+            logShape = [2, logShape[0]];
+          }
+        }
+        if (logShape.length !== 2) {
+          const squeezeResult = squeezeShape(logShape);
+          logShape = squeezeResult.newShape;
+        }
+        const size = sizeFromShape(logShape);
+        if (logShape.length <= 1 && size <= maxTextureSize) {
+          return [1, size];
+        } else if (logShape.length === 2 && logShape[0] <= maxTextureSize && logShape[1] <= maxTextureSize) {
+          return logShape;
+        } else if (logShape.length === 3 && logShape[0] * logShape[1] <= maxTextureSize && logShape[2] <= maxTextureSize) {
+          return [logShape[0] * logShape[1], logShape[2]];
+        } else if (logShape.length === 3 && logShape[0] <= maxTextureSize && logShape[1] * logShape[2] <= maxTextureSize) {
+          return [logShape[0], logShape[1] * logShape[2]];
+        } else if (logShape.length === 4 && logShape[0] * logShape[1] * logShape[2] <= maxTextureSize && logShape[3] <= maxTextureSize) {
+          return [logShape[0] * logShape[1] * logShape[2], logShape[3]];
+        } else if (logShape.length === 4 && logShape[0] <= maxTextureSize && logShape[1] * logShape[2] * logShape[3] <= maxTextureSize) {
+          return [logShape[0], logShape[1] * logShape[2] * logShape[3]];
+        } else {
+          if (isPacked) {
+            return sizeToSquarishShape(size / 4).map((d) => d * 2);
+          }
+          return sizeToSquarishShape(size);
+        }
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/glsl-coordinate-lib.ts
+var CoordsGlslLib;
+var init_glsl_coordinate_lib = __esm({
+  "web/lib/onnxjs/backends/webgl/glsl-coordinate-lib.ts"() {
+    "use strict";
+    init_util();
+    init_glsl_definitions();
+    init_glsl_source();
+    init_texture_layout_strategy();
+    init_utils();
+    CoordsGlslLib = class extends GlslLib {
+      constructor(context) {
+        super(context);
+      }
+      getFunctions() {
+        return {
+          ...this.offsetToCoords(),
+          ...this.coordsToOffset(),
+          ...this.toVec(),
+          ...this.valueFrom(),
+          // TODO return these only when packing is enabled.
+          ...this.getCommonUtilFuncs(),
+          ...this.getInputsSamplingSnippets(),
+          ...this.getOutputSamplingSnippet()
+        };
+      }
+      getCustomTypes() {
+        return {};
+      }
+      /**
+       * Produces a function that can map from
+       * 2D normalzied coordinates (s,t) to a flat offset
+       */
+      offsetToCoords() {
+        const funcName = "offsetToCoords";
+        return {
+          offsetToCoords: new GlslLibRoutine(`
+      vec2 ${funcName}(int offset, int width, int height) {
+        int t = offset / width;
+        int s = offset - t*width;
+        vec2 coords = (vec2(s,t) + vec2(0.5,0.5)) / vec2(width, height);
+        return coords;
+      }
+      `)
+        };
+      }
+      /**
+       * Produces a function that can map from
+       * 2D normalzied coordinates (s,t) to a flat offset
+       */
+      coordsToOffset() {
+        const funcName = "coordsToOffset";
+        return {
+          coordsToOffset: new GlslLibRoutine(`
+      int ${funcName}(vec2 coords, int width, int height) {
+        float s = coords.s * float(width);
+        float t = coords.t * float(height);
+        int offset = int(t) * width + int(s);
+        return offset;
+      }
+      `)
+        };
+      }
+      /**
+       * Generates code for output sampler.
+       */
+      getOutputSamplingSnippet() {
+        const outputLayout = this.context.outputTextureLayout;
+        if (outputLayout.isPacked) {
+          return this.getPackedOutputSamplingSnippet(outputLayout);
+        } else {
+          return this.getUnpackedOutputSamplingSnippet(outputLayout);
+        }
+      }
+      /**
+       * Generates code for packed output sampler.
+       */
+      getPackedOutputSamplingSnippet(outputLayout) {
+        const outShape = outputLayout.unpackedShape;
+        const outTexShape = [outputLayout.width, outputLayout.height];
+        const result = {};
+        const funcName = "getOutputCoords";
+        switch (outShape.length) {
+          case 0:
+            result[funcName] = this.getOutputScalarCoords();
+            break;
+          case 1:
+            result[funcName] = this.getOutputPacked1DCoords(outShape, outTexShape);
+            break;
+          case 2:
+            result[funcName] = this.getOutputPacked2DCoords(outShape, outTexShape);
+            break;
+          case 3:
+            result[funcName] = this.getOutputPacked3DCoords(
+              outShape,
+              outTexShape
+            );
+            break;
+          default:
+            result[funcName] = this.getOutputPackedNDCoords(outShape, outTexShape);
+        }
+        const glsl = getGlsl(this.context.glContext.version);
+        const floatTextureSetRGBASource = `
+      void setOutput(vec4 val) {
+        ${glsl.output} = val;
+      }
+    `;
+        const floatTextureSetRGBAFuncName = "floatTextureSetRGBA";
+        result[floatTextureSetRGBAFuncName] = new GlslLibRoutine(floatTextureSetRGBASource);
+        return result;
+      }
+      /**
+       * Generates code for unpacked output sampler.
+       */
+      getUnpackedOutputSamplingSnippet(outputLayout) {
+        const outShape = outputLayout.unpackedShape;
+        const outTexShape = [outputLayout.width, outputLayout.height];
+        const result = {};
+        const funcName = "getOutputCoords";
+        switch (outShape.length) {
+          case 0:
+            result[funcName] = this.getOutputScalarCoords();
+            break;
+          case 1:
+            result[funcName] = this.getOutputUnpacked1DCoords(outShape, outTexShape);
+            break;
+          case 2:
+            result[funcName] = this.getOutputUnpacked2DCoords(
+              outShape,
+              outTexShape
+            );
+            break;
+          case 3:
+            result[funcName] = this.getOutputUnpacked3DCoords(
+              outShape,
+              outTexShape
+            );
+            break;
+          case 4:
+            result[funcName] = this.getOutputUnpacked4DCoords(
+              outShape,
+              outTexShape
+            );
+            break;
+          case 5:
+            result[funcName] = this.getOutputUnpacked5DCoords(
+              outShape,
+              outTexShape
+            );
+            break;
+          case 6:
+            result[funcName] = this.getOutputUnpacked6DCoords(
+              outShape,
+              outTexShape
+            );
+            break;
+          default:
+            throw new Error(`Unsupported output dimensionality: ${outShape.length}`);
+        }
+        const glsl = getGlsl(this.context.glContext.version);
+        const floatTextureSetRSource = `
+        void setOutput(float val) {
+          ${glsl.output} = vec4(val, 0, 0, 0);
+        }
+    `;
+        const floatTextureSetRFuncName = "floatTextureSetR";
+        result[floatTextureSetRFuncName] = new GlslLibRoutine(floatTextureSetRSource);
+        return result;
+      }
+      /**
+       * Scalar output coordinates.
+       */
+      getOutputScalarCoords() {
+        return new GlslLibRoutine(`
+      int getOutputCoords() {
+        return 0;
+      }
+    `);
+      }
+      /**
+       * 1D packed output coordinates.
+       */
+      getOutputPacked1DCoords(_shape, texShape) {
+        const packedTexShape = texShape;
+        let source = "";
+        if (packedTexShape[0] === 1) {
+          source = `
+          int getOutputCoords() {
+            return 2 * int(TexCoords.y * ${packedTexShape[1]}.0);
+          }
+        `;
+          return new GlslLibRoutine(source);
+        }
+        if (packedTexShape[1] === 1) {
+          source = `
+          int getOutputCoords() {
+            return 2 * int(TexCoords.x * ${packedTexShape[0]}.0);
+          }
+        `;
+          return new GlslLibRoutine(source);
+        }
+        source = `
+        int getOutputCoords() {
+          ivec2 resTexRC = ivec2(TexCoords.xy *
+                                 vec2(${packedTexShape[0]}, ${packedTexShape[1]}));
+          return 2 * (resTexRC.y * ${packedTexShape[0]} + resTexRC.x);
+        }
+      `;
+        return new GlslLibRoutine(source);
+      }
+      /**
+       * 2D packed output coordinates.
+       */
+      getOutputPacked2DCoords(shape2, texShape) {
+        let source = "";
+        if (ArrayUtil.arraysEqual(shape2, texShape)) {
+          source = `
+        ivec2 getOutputCoords() {
+          return 2 * ivec2(TexCoords.xy * vec2(${texShape[0]}, ${texShape[1]}));
+        }
+      `;
+          return new GlslLibRoutine(source);
+        }
+        const packedTexShape = texShape;
+        const texelsInLogicalRow = Math.ceil(shape2[1] / 2);
+        source = `
+        ivec2 getOutputCoords() {
+          ivec2 resTexRC = ivec2(TexCoords.xy *
+                                vec2(${packedTexShape[0]}, ${packedTexShape[1]}));
+
+          int index = resTexRC.y * ${packedTexShape[0]} + resTexRC.x;
+
+          // reverse r and c order for packed texture
+          int r = imod(index, ${texelsInLogicalRow}) * 2;
+          int c = 2 * (index / ${texelsInLogicalRow});
+
+          return ivec2(r, c);
+        }
+      `;
+        return new GlslLibRoutine(source);
+      }
+      /**
+       * 3D packed output coordinates.
+       */
+      getOutputPacked3DCoords(shape2, texShape) {
+        const packedTexShape = [texShape[0], texShape[1]];
+        const texelsInLogicalRow = Math.ceil(shape2[2] / 2);
+        const texelsInBatch = texelsInLogicalRow * Math.ceil(shape2[1] / 2);
+        const source = `
+        ivec3 getOutputCoords() {
+          ivec2 resTexRC = ivec2(TexCoords.xy *
+                                vec2(${packedTexShape[0]}, ${packedTexShape[1]}));
+          int index = resTexRC.y * ${packedTexShape[0]} + resTexRC.x;
+
+          int b = index / ${texelsInBatch};
+          index -= b * ${texelsInBatch};
+
+          // reverse r and c order for packed texture
+          int r = imod(index, ${texelsInLogicalRow}) * 2;
+          int c = 2 * (index / ${texelsInLogicalRow});
+
+          return ivec3(b, r, c);
+        }
+      `;
+        return new GlslLibRoutine(source);
+      }
+      /**
+       * ND packed output coordinates.
+       */
+      getOutputPackedNDCoords(shape2, texShape) {
+        const packedTexShape = [texShape[0], texShape[1]];
+        const texelsInLogicalRow = Math.ceil(shape2[shape2.length - 1] / 2);
+        const texelsInBatch = texelsInLogicalRow * Math.ceil(shape2[shape2.length - 2] / 2);
+        let texelsInBatchN = texelsInBatch;
+        let batches = "";
+        let coords = "b, r, c";
+        for (let b = 2; b < shape2.length - 1; b++) {
+          texelsInBatchN *= shape2[shape2.length - b - 1];
+          batches = `
+      int b${b} = index / ${texelsInBatchN};
+      index -= b${b} * ${texelsInBatchN};
+    ` + batches;
+          coords = `b${b}, ` + coords;
+        }
+        const source = `
+      ivec${shape2.length} getOutputCoords() {
+        ivec2 resTexRC = ivec2(TexCoords.xy *
+                              vec2(${packedTexShape[0]}, ${packedTexShape[1]}));
+        int index = resTexRC.y * ${packedTexShape[0]} + resTexRC.x;
+
+        ${batches}
+
+        int b = index / ${texelsInBatch};
+        index -= b * ${texelsInBatch};
+
+        // reverse r and c order for packed texture
+        int r = imod(index, ${texelsInLogicalRow}) * 2;
+        int c = 2 * (index / ${texelsInLogicalRow});
+
+        return ivec${shape2.length}(${coords});
+      }
+    `;
+        return new GlslLibRoutine(source);
+      }
+      /**
+       * Unpacked 1D output coordinates.
+       */
+      getOutputUnpacked1DCoords(_shape, texShape) {
+        const source = `
+        int getOutputCoords() {
+          ivec2 resTexRC = ivec2(TexCoords.xy *
+                                vec2(${texShape[0]}, ${texShape[1]}));
+          return resTexRC.y * ${texShape[0]} + resTexRC.x;
+        }
+      `;
+        return new GlslLibRoutine(source);
+      }
+      /**
+       * Unpacked 2D output coordinates.
+       */
+      getOutputUnpacked2DCoords(shape2, texShape) {
+        const source = `
+        ivec2 getOutputCoords() {
+          ivec2 resTexRC = ivec2(TexCoords.xy *
+                                vec2(${texShape[0]}, ${texShape[1]}));
+          int index = resTexRC.y * ${texShape[0]} + resTexRC.x;
+          int r = index / ${shape2[1]};
+          int c = index - r * ${shape2[1]};
+          return ivec2(r, c);
+        }
+      `;
+        return new GlslLibRoutine(source);
+      }
+      /**
+       * Unpacked 3D output coordinates.
+       */
+      getOutputUnpacked3DCoords(shape2, texShape) {
+        let source = "";
+        const rank = shape2.length;
+        let strides = null;
+        if (rank < 2) {
+          strides = [];
+        }
+        strides = new Array(rank - 1);
+        strides[rank - 2] = shape2[rank - 1];
+        for (let i = rank - 3; i >= 0; --i) {
+          strides[i] = strides[i + 1] * shape2[i + 1];
+        }
+        const coordsToCompute = ["r", "c", "d"];
+        const coordsFromIndexSnippet = strides.map((stride, i) => {
+          const line1 = `int ${coordsToCompute[i]} = index / ${stride}`;
+          const line2 = i === strides.length - 1 ? `int ${coordsToCompute[i + 1]} = index - ${coordsToCompute[i]} * ${stride}` : `index -= ${coordsToCompute[i]} * ${stride}`;
+          return `${line1}; ${line2};`;
+        }).join("");
+        source = `
+        ivec3 getOutputCoords() {
+          ivec2 resTexRC = ivec2(TexCoords.xy *
+                                vec2(${texShape[0]}, ${texShape[1]}));
+          int index = resTexRC.y * ${texShape[0]} + resTexRC.x;
+          ${coordsFromIndexSnippet}
+          return ivec3(r, c, d);
+        }
+      `;
+        return new GlslLibRoutine(source);
+      }
+      /**
+       * Unpacked 4D output coordinates.
+       */
+      getOutputUnpacked4DCoords(shape2, texShape) {
+        let source = "";
+        const rank = shape2.length;
+        let strides = null;
+        if (rank < 2) {
+          strides = [];
+        }
+        strides = new Array(rank - 1);
+        strides[rank - 2] = shape2[rank - 1];
+        for (let i = rank - 3; i >= 0; --i) {
+          strides[i] = strides[i + 1] * shape2[i + 1];
+        }
+        const coordsToCompute = ["r", "c", "d", "d2"];
+        const coordsFromIndexSnippet = strides.map((stride, i) => {
+          const line1 = `int ${coordsToCompute[i]} = index / ${stride}`;
+          const line2 = i === strides.length - 1 ? `int ${coordsToCompute[i + 1]} = index - ${coordsToCompute[i]} * ${stride}` : `index -= ${coordsToCompute[i]} * ${stride}`;
+          return `${line1}; ${line2};`;
+        }).join("");
+        source = `
+      ivec4 getOutputCoords() {
+          ivec2 resTexRC = ivec2(TexCoords.xy *
+                                vec2(${texShape[0]}, ${texShape[1]}));
+          int index = resTexRC.y * ${texShape[0]} + resTexRC.x;
+          ${coordsFromIndexSnippet}
+          return ivec4(r, c, d, d2);
+        }
+      `;
+        return new GlslLibRoutine(source);
+      }
+      /**
+       * Unpacked 5D output coordinates.
+       */
+      getOutputUnpacked5DCoords(shape2, texShape) {
+        let source = "";
+        const rank = shape2.length;
+        let strides = null;
+        if (rank < 2) {
+          strides = [];
+        }
+        strides = new Array(rank - 1);
+        strides[rank - 2] = shape2[rank - 1];
+        for (let i = rank - 3; i >= 0; --i) {
+          strides[i] = strides[i + 1] * shape2[i + 1];
+        }
+        const coordsToCompute = ["r", "c", "d", "d2", "d3"];
+        const coordsFromIndexSnippet = strides.map((stride, i) => {
+          const line1 = `int ${coordsToCompute[i]} = index / ${stride}`;
+          const line2 = i === strides.length - 1 ? `int ${coordsToCompute[i + 1]} = index - ${coordsToCompute[i]} * ${stride}` : `index -= ${coordsToCompute[i]} * ${stride}`;
+          return `${line1}; ${line2};`;
+        }).join("");
+        source = `
+      ivec5 getOutputCoords() {
+          ivec2 resTexRC = ivec2(TexCoords.xy *
+                                vec2(${texShape[0]}, ${texShape[1]}));
+          int index = resTexRC.y * ${texShape[0]} + resTexRC.x;
+          ${coordsFromIndexSnippet}
+          return ivec5(r, c, d, d2, d3);
+        }
+      `;
+        return new GlslLibRoutine(source);
+      }
+      /**
+       * Unpacked 6D output coordinates.
+       */
+      getOutputUnpacked6DCoords(shape2, texShape) {
+        let source = "";
+        const rank = shape2.length;
+        let strides = null;
+        if (rank < 2) {
+          strides = [];
+        }
+        strides = new Array(rank - 1);
+        strides[rank - 2] = shape2[rank - 1];
+        for (let i = rank - 3; i >= 0; --i) {
+          strides[i] = strides[i + 1] * shape2[i + 1];
+        }
+        const coordsToCompute = ["r", "c", "d", "d2", "d3", "d4"];
+        const coordsFromIndexSnippet = strides.map((stride, i) => {
+          const line1 = `int ${coordsToCompute[i]} = index / ${stride}`;
+          const line2 = i === strides.length - 1 ? `int ${coordsToCompute[i + 1]} = index - ${coordsToCompute[i]} * ${stride}` : `index -= ${coordsToCompute[i]} * ${stride}`;
+          return `${line1}; ${line2};`;
+        }).join("");
+        source = `
+     ivec6 getOutputCoords() {
+         ivec2 resTexRC = ivec2(TexCoords.xy *
+                               vec2(${texShape[0]}, ${texShape[1]}));
+         int index = resTexRC.y * ${texShape[0]} + resTexRC.x;
+         ${coordsFromIndexSnippet}
+         return ivec6(r, c, d, d2, d3, d4);
+       }
+     `;
+        return new GlslLibRoutine(source);
+      }
+      /**
+       * Generates code for common UV coords computation utility functions.
+       */
+      getCommonUtilFuncs() {
+        const result = {};
+        let funcName = "uvFromFlat";
+        result[funcName] = new GlslLibRoutine(`
+    vec2 uvFromFlat(int texNumR, int texNumC, int index) {
+      int texC = index / texNumR;
+      int texR = index - texC * texNumR;
+      // TODO: swap texR, texC order in following function so row is corresponding to u and column is corresponding to
+      //       v.
+      return (vec2(texR, texC) + halfCR) / vec2(texNumR, texNumC);
+    }
+    `);
+        funcName = "packedUVfrom1D";
+        result[funcName] = new GlslLibRoutine(`
+      vec2 packedUVfrom1D(int texNumR, int texNumC, int index) {
+        int texelIndex = index / 2;
+        int texR = texelIndex / texNumC;
+        int texC = texelIndex - texR * texNumC;
+        return (vec2(texC, texR) + halfCR) / vec2(texNumC, texNumR);
+      }
+      `);
+        funcName = "packedUVfrom2D";
+        result[funcName] = new GlslLibRoutine(`
+      vec2 packedUVfrom2D(int texNumR, int texNumC, int texelsInLogicalRow, int row, int col) {
+        int texelIndex = (row / 2) * texelsInLogicalRow + (col / 2);
+        int texR = texelIndex / texNumC;
+        int texC = texelIndex - texR * texNumC;
+        return (vec2(texC, texR) + halfCR) / vec2(texNumC, texNumR);
+      }
+      `);
+        funcName = "packedUVfrom3D";
+        result[funcName] = new GlslLibRoutine(`
+      vec2 packedUVfrom3D(int texNumR, int texNumC,
+          int texelsInBatch, int texelsInLogicalRow, int b,
+          int row, int col) {
+        int index = b * texelsInBatch + (row / 2) * texelsInLogicalRow + (col / 2);
+        int texR = index / texNumC;
+        int texC = index - texR * texNumC;
+        return (vec2(texC, texR) + halfCR) / vec2(texNumC, texNumR);
+      }
+      `);
+        funcName = "sampleTexture";
+        const glsl = getGlsl(this.context.glContext.version);
+        result[funcName] = new GlslLibRoutine(`
+        float sampleTexture(sampler2D textureSampler, vec2 uv) {
+            return ${glsl.texture2D}(textureSampler, uv).r;
+        }`);
+        return result;
+      }
+      /**
+       * Constructing snippets for inputs
+       */
+      getInputsSamplingSnippets() {
+        const result = {};
+        const outputLayout = this.context.outputTextureLayout;
+        this.context.programInfo.inputNames.forEach((samplerName, i) => {
+          const inputLayout = this.context.inputTextureLayouts[i];
+          const funcName = generateShaderFuncNameFromInputSamplerName(samplerName);
+          if (inputLayout.isPacked) {
+            result[funcName] = this.getPackedSamplerFromInput(funcName, samplerName, inputLayout);
+          } else {
+            result[funcName] = this.getUnpackedSamplerFromInput(funcName, samplerName, inputLayout);
+          }
+          const outCoordFuncName = generateShaderFuncNameFromInputSamplerNameAtOutCoords(samplerName);
+          if (inputLayout.unpackedShape.length <= outputLayout.unpackedShape.length) {
+            if (inputLayout.isPacked) {
+              result[outCoordFuncName] = this.getPackedSamplerAtOutputCoords(
+                outCoordFuncName,
+                inputLayout,
+                outputLayout,
+                samplerName
+              );
+            } else {
+              result[outCoordFuncName] = this.getUnpackedSamplerAtOutputCoords(
+                outCoordFuncName,
+                inputLayout,
+                outputLayout,
+                samplerName
+              );
+            }
+          }
+        });
+        return result;
+      }
+      /**
+       * Constructing snippets for output coordinates of samplers
+       */
+      getPackedSamplerAtOutputCoords(funcName, inputLayout, outputLayout, name2) {
+        const inShape = inputLayout.unpackedShape;
+        const outShape = outputLayout.unpackedShape;
+        const texName = name2;
+        const texFuncSnippet = generateShaderFuncNameFromInputSamplerName(texName);
+        const inRank = inShape.length;
+        const outRank = outShape.length;
+        const broadcastDims = BroadcastUtil.getBroadcastDims(inShape, outShape);
+        const type = getCoordsDataType(outRank);
+        const rankDiff = outRank - inRank;
+        let coordsSnippet;
+        const fields = getGlChannels();
+        if (inRank === 0) {
+          coordsSnippet = "";
+        } else if (outRank < 2 && broadcastDims.length >= 1) {
+          coordsSnippet = "coords = 0;";
+        } else {
+          coordsSnippet = broadcastDims.map((d) => `coords.${fields[d + rankDiff]} = 0;`).join("\n");
+        }
+        let unpackedCoordsSnippet = "";
+        if (outRank < 2 && inRank > 0) {
+          unpackedCoordsSnippet = "coords";
+        } else {
+          unpackedCoordsSnippet = inShape.map((_s, i) => `coords.${fields[i + rankDiff]}`).join(", ");
+        }
+        let output = "return outputValue;";
+        const inSize = ShapeUtil.size(inShape);
+        const isInputScalar = inSize === 1;
+        const outSize = ShapeUtil.size(outShape);
+        const isOutputScalar = outSize === 1;
+        if (inRank === 1 && !isInputScalar && !isOutputScalar) {
+          output = `
+        return vec4(outputValue.xy, outputValue.xy);
+      `;
+        } else if (isInputScalar && !isOutputScalar) {
+          if (outRank === 1) {
+            output = `
+          return vec4(outputValue.x, outputValue.x, 0., 0.);
+        `;
+          } else {
+            output = `
+          return vec4(outputValue.x);
+        `;
+          }
+        } else if (broadcastDims.length) {
+          const rows = inRank - 2;
+          const cols = inRank - 1;
+          if (broadcastDims.indexOf(rows) > -1 && broadcastDims.indexOf(cols) > -1) {
+            output = "return vec4(outputValue.x);";
+          } else if (broadcastDims.indexOf(rows) > -1) {
+            output = "return vec4(outputValue.x, outputValue.y, outputValue.x, outputValue.y);";
+          } else if (broadcastDims.indexOf(cols) > -1) {
+            output = "return vec4(outputValue.xx, outputValue.zz);";
+          }
+        }
+        const swapLastDimsSnippet = `
+        int lastDim = coords.${fields[outRank - 1]};
+        coords.${fields[outRank - 1]} = coords.${fields[outRank - 2]};
+        coords.${fields[outRank - 2]} = lastDim;
+      `;
+        const source = `
+      vec4 ${funcName}() {
+        ${type} coords = getOutputCoords();
+        ${swapLastDimsSnippet}
+        ${coordsSnippet}
+        vec4 outputValue = ${texFuncSnippet}(${unpackedCoordsSnippet});
+        ${output}
+      }
+    `;
+        return new GlslLibRoutine(source, ["coordinates.getOutputCoords"]);
+      }
+      /**
+       * Constructing snippets for unpacked output coordinates of samplers
+       */
+      getUnpackedSamplerAtOutputCoords(funcName, inputLayout, outputLayout, name2) {
+        const outTexShape = [outputLayout.width, outputLayout.height];
+        const inTexShape = [inputLayout.width, inputLayout.height];
+        const inRank = inputLayout.unpackedShape.length;
+        const outRank = outputLayout.unpackedShape.length;
+        const inShape = inputLayout.unpackedShape;
+        const outShape = outputLayout.unpackedShape;
+        const texFuncSnippet = generateShaderFuncNameFromInputSamplerName(name2);
+        if (inRank === outRank && ArrayUtil.arraysEqual(inTexShape, outTexShape)) {
+          const source2 = `
+          float ${funcName}() {
+            return sampleTexture(${name2}, TexCoords);
+          }
+        `;
+          return new GlslLibRoutine(source2, ["coordinates.sampleTexture"]);
+        }
+        const type = getCoordsDataType(outRank);
+        const broadcastDims = BroadcastUtil.getBroadcastDims(inShape, outShape);
+        const rankDiff = outRank - inRank;
+        let coordsSnippet;
+        const fields = getGlChannels();
+        if (inRank === 0) {
+          coordsSnippet = "";
+        } else if (outRank < 2 && broadcastDims.length >= 1) {
+          coordsSnippet = "coords = 0;";
+        } else {
+          coordsSnippet = broadcastDims.map((d) => `coords.${fields[d + rankDiff]} = 0;`).join("\n");
+        }
+        let unpackedCoordsSnippet = "";
+        if (outRank < 2 && inRank > 0) {
+          unpackedCoordsSnippet = "coords";
+        } else {
+          unpackedCoordsSnippet = inputLayout.unpackedShape.map((_s, i) => `coords.${fields[i + rankDiff]}`).join(", ");
+        }
+        const source = `
+        float ${funcName}() {
+          ${type} coords = getOutputCoords();
+          ${coordsSnippet}
+          return ${texFuncSnippet}(${unpackedCoordsSnippet});
+        }
+      `;
+        return new GlslLibRoutine(source, ["coordinates.getOutputCoords"]);
+      }
+      /**
+       * Constructing snippets for packed operations.
+       */
+      getPackedSamplerFromInput(funcName, name2, inputLayout) {
+        switch (inputLayout.unpackedShape.length) {
+          case 0:
+            return this.getPackedSamplerScalar(funcName, name2);
+          case 1:
+            return this.getPackedSampler1D(funcName, name2, inputLayout);
+          case 2:
+            return this.getPackedSampler2D(funcName, name2, inputLayout);
+          case 3:
+            return this.getPackedSampler3D(funcName, name2, inputLayout);
+          default:
+            return this.getPackedSamplerND(funcName, name2, inputLayout);
+        }
+      }
+      /**
+       * Constructing snippets for unpacked operations.
+       */
+      getUnpackedSamplerFromInput(funcName, name2, inputLayout) {
+        const shape2 = inputLayout.unpackedShape;
+        switch (shape2.length) {
+          case 0:
+            return this.getUnpackedSamplerScalar(funcName, name2, inputLayout);
+          case 1:
+            return this.getUnpackedSampler1D(funcName, name2, inputLayout);
+          case 2:
+            return this.getUnpackedSampler2D(funcName, name2, inputLayout);
+          case 3:
+            return this.getUnpackedSampler3D(funcName, name2, inputLayout);
+          case 4:
+            return this.getUnpackedSampler4D(funcName, name2, inputLayout);
+          case 5:
+            return this.getUnpackedSampler5D(funcName, name2, inputLayout);
+          case 6:
+            return this.getUnpackedSampler6D(funcName, name2, inputLayout);
+          default:
+            throw new Error(`Unsupported dimension ${shape2.length}-D`);
+        }
+      }
+      /**
+       * Packed scalar snippet.
+       */
+      getPackedSamplerScalar(funcName, name2) {
+        const glsl = getGlsl(this.context.glContext.version);
+        const source = `
+          vec4 ${funcName}() {
+            return ${glsl.texture2D}(${name2}, halfCR);
+          }
+        `;
+        return new GlslLibRoutine(source);
+      }
+      /**
+       * Packed 1D snippet.
+       */
+      getPackedSampler1D(funcName, name2, inputLayout) {
+        const texShape = [inputLayout.width, inputLayout.height];
+        const packedTexShape = [texShape[1], texShape[0]];
+        const glsl = getGlsl(this.context.glContext.version);
+        const packedSampler = `vec4 ${funcName}(int index) {
+      vec2 uv = packedUVfrom1D(
+      ${packedTexShape[0]}, ${packedTexShape[1]}, index);
+      return ${glsl.texture2D}(${name2}, uv);
+    }`;
+        const source = packedSampler;
+        return new GlslLibRoutine(source, ["coordinates.packedUVfrom1D"]);
+      }
+      /**
+       * Packed 2D snippet.
+       */
+      getPackedSampler2D(funcName, name2, inputLayout) {
+        const shape2 = inputLayout.unpackedShape;
+        const texShape = [inputLayout.width, inputLayout.height];
+        const glsl = getGlsl(this.context.glContext.version);
+        const texNumR = texShape[0];
+        const texNumC = texShape[1];
+        if (texShape != null && ArrayUtil.arraysEqual(shape2, texShape)) {
+          const packedSampler2 = `vec4 ${funcName}(int row, int col) {
+        vec2 uv = (vec2(col, row) + halfCR) / vec2(${texNumC}.0, ${texNumR}.0);
+        return ${glsl.texture2D}(${name2}, uv);
+      }`;
+          return new GlslLibRoutine(packedSampler2);
+        }
+        const packedTexShape = texShape;
+        const valuesPerRow = Math.ceil(shape2[1] / 2);
+        const packedSampler = `vec4 ${funcName}(int row, int col) {
+      vec2 uv = packedUVfrom2D(${packedTexShape[1]}, ${packedTexShape[0]}, ${valuesPerRow}, row, col);
+      return ${glsl.texture2D}(${name2}, uv);
+    }`;
+        const source = packedSampler;
+        return new GlslLibRoutine(source, ["coordinates.packedUVfrom2D"]);
+      }
+      /**
+       * Packed 3D snippet.
+       */
+      getPackedSampler3D(funcName, name2, inputLayout) {
+        const shape2 = inputLayout.unpackedShape;
+        const texShape = [inputLayout.width, inputLayout.height];
+        const packedTexShape = [texShape[0], texShape[1]];
+        const glsl = getGlsl(this.context.glContext.version);
+        if (shape2[0] === 1) {
+          const squeezedShape = shape2.slice(1);
+          const keptDims = [1, 2];
+          const newInputShape = squeezeInputShape(shape2, squeezedShape);
+          const params = ["b", "row", "col"];
+          const newInputLayout = JSON.parse(JSON.stringify(inputLayout));
+          newInputLayout.unpackedShape = newInputShape;
+          const samplerRoutine = this.getPackedSamplerFromInput(funcName, name2, newInputLayout);
+          const packedSampler2 = `${samplerRoutine.routineBody}
+      vec4 ${funcName}(int b, int row, int col) {
+        return ${funcName}(${getSqueezedParams(params, keptDims)});
+      } `;
+          const source2 = packedSampler2;
+          return new GlslLibRoutine(source2, samplerRoutine.dependencies);
+        }
+        const texNumR = packedTexShape[0];
+        const texNumC = packedTexShape[1];
+        const valuesPerRow = Math.ceil(shape2[2] / 2);
+        const texelsInBatch = valuesPerRow * Math.ceil(shape2[1] / 2);
+        const packedSampler = `vec4 ${funcName}(int b, int row, int col) {
+      vec2 uv = packedUVfrom3D(
+        ${texNumC}, ${texNumR}, ${texelsInBatch}, ${valuesPerRow}, b, row, col);
+      return ${glsl.texture2D}(${name2}, uv);}`;
+        const source = packedSampler;
+        return new GlslLibRoutine(source, ["coordinates.packedUVfrom3D"]);
+      }
+      /*
+       * Packed ND snippet.
+       */
+      getPackedSamplerND(funcName, name2, inputLayout) {
+        const shape2 = inputLayout.unpackedShape;
+        const rank = shape2.length;
+        const texShape = [inputLayout.width, inputLayout.height];
+        const glsl = getGlsl(this.context.glContext.version);
+        const packedTexShape = [texShape[0], texShape[1]];
+        const texNumR = packedTexShape[1];
+        const texNumC = packedTexShape[0];
+        const valuesPerRow = Math.ceil(shape2[rank - 1] / 2);
+        let texelsInBatch = valuesPerRow * Math.ceil(shape2[rank - 2] / 2);
+        let params = "int b, int row, int col";
+        let index = `b * ${texelsInBatch} + (row / 2) * ${valuesPerRow} + (col / 2)`;
+        for (let b = 2; b < rank - 1; b++) {
+          params = `int b${b}, ` + params;
+          texelsInBatch *= shape2[rank - b - 1];
+          index = `b${b} * ${texelsInBatch} + ` + index;
+        }
+        const packedSampler = `vec4 ${funcName}(${params}) {
+      int index = ${index};
+      int texR = index / ${texNumC};
+      int texC = index - texR * ${texNumC};
+      vec2 uv = (vec2(texC, texR) + halfCR) / vec2(${texNumC}, ${texNumR});
+      return ${glsl.texture2D}(${name2}, uv);
+    }`;
+        const source = packedSampler;
+        return new GlslLibRoutine(source);
+      }
+      /**
+       * Unpacked scalar snippet.
+       */
+      getUnpackedSamplerScalar(funcName, name2, inputLayout) {
+        const [texNumR, texNumC] = [inputLayout.width, inputLayout.height];
+        if (texNumR === 1 && texNumC === 1) {
+          const source2 = `
+          float ${funcName}() {
+            return sampleTexture(${name2}, halfCR);
+          }
+        `;
+          return new GlslLibRoutine(source2, ["coordinates.sampleTexture"]);
+        }
+        const source = `
+        float ${funcName}() {
+          int offset_${name2} = coordsToOffset(TexCoords, ${texNumR}, ${texNumC});
+          vec2 uv = uvFromFlat(${texNumR}, ${texNumC}, offset_${name2});
+          return sampleTexture(${name2}, uv);
+        }
+      `;
+        return new GlslLibRoutine(source, [
+          "coordinates.uvFromFlat",
+          "coordinates.sampleTexture",
+          "coordinates.coordsToOffset"
+        ]);
+      }
+      /**
+       * Unpacked 1D snippet.
+       */
+      getUnpackedSampler1D(funcName, name2, inputLayout) {
+        const tNumR = inputLayout.width;
+        const tNumC = inputLayout.height;
+        if (tNumC === 1 && tNumR === 1) {
+          const source2 = `
+        float ${funcName}(int index) {
+          return sampleTexture(${name2}, halfCR);
+        }
+      `;
+          return new GlslLibRoutine(source2, ["coordinates.sampleTexture"]);
+        }
+        if (tNumC === 1) {
+          const source2 = `
+          float ${funcName}(int index) {
+            vec2 uv = vec2((float(index) + 0.5) / ${tNumR}.0, 0.5);
+            return sampleTexture(${name2}, uv);
+          }
+        `;
+          return new GlslLibRoutine(source2, ["coordinates.sampleTexture"]);
+        }
+        if (tNumR === 1) {
+          const source2 = `
+          float ${funcName}(int index) {
+            vec2 uv = vec2(0.5, (float(index) + 0.5) / ${tNumC}.0);
+            return sampleTexture(${name2}, uv);
+          }
+        `;
+          return new GlslLibRoutine(source2, ["coordinates.sampleTexture"]);
+        }
+        const source = `
+        float ${funcName}(int index) {
+          vec2 uv = uvFromFlat(${tNumR}, ${tNumC}, index);
+          return sampleTexture(${name2}, uv);
+        }
+      `;
+        return new GlslLibRoutine(source, ["coordinates.uvFromFlat", "coordinates.sampleTexture"]);
+      }
+      /**
+       * Unpacked 2D snippet.
+       */
+      getUnpackedSampler2D(funcName, name2, inputLayout) {
+        const shape2 = inputLayout.unpackedShape;
+        const texShape = [inputLayout.height, inputLayout.width];
+        if (texShape != null && ArrayUtil.arraysEqual(shape2, texShape)) {
+          const texNumR2 = texShape[1];
+          const texNumC2 = texShape[0];
+          const source2 = `
+          float ${funcName}(int row, int col) {
+            vec2 uv = (vec2(row, col) + halfCR) / vec2(${texNumR2}.0, ${texNumC2}.0);
+            return sampleTexture(${name2}, uv);
+          }
+        `;
+          return new GlslLibRoutine(source2, ["coordinates.sampleTexture"]);
+        }
+        const { newShape, keptDims } = squeezeShape(shape2);
+        const squeezedShape = newShape;
+        if (squeezedShape.length < shape2.length) {
+          const newInputShape = squeezeInputShape(shape2, squeezedShape);
+          const newInputLayout = JSON.parse(JSON.stringify(inputLayout));
+          newInputLayout.unpackedShape = newInputShape;
+          const params = ["col", "row"];
+          const source2 = `
+          ${this.getUnpackedSamplerFromInput(funcName, name2, newInputLayout).routineBody}
+          float ${funcName}(int row, int col) {
+            return ${funcName}(${getSqueezedParams(params, keptDims)});
+          }
+        `;
+          return new GlslLibRoutine(source2, ["coordinates.sampleTexture"]);
+        }
+        const texNumR = texShape[1];
+        const texNumC = texShape[0];
+        if (texNumC === 1) {
+          const source2 = `
+          float ${funcName}(int row, int col) {
+            int offset_${name2} = coordsToOffset(TexCoords, ${texNumR}, ${texNumC});
+            float index = dot(vec3(row, col, offset_${name2}), vec3(${shape2[1]}, 1, 1));
+            vec2 uv = vec2(0.5, (index + 0.5) / ${texNumR}.0);
+            return sampleTexture(${name2}, uv);
+          }
+        `;
+          return new GlslLibRoutine(source2, ["coordinates.sampleTexture", "coordinates.coordsToOffset"]);
+        }
+        if (texNumR === 1) {
+          const source2 = `
+          float ${funcName}(int row, int col) {
+            int offset_${name2} = coordsToOffset(TexCoords, ${texNumR}, ${texNumC});
+            float index = dot(vec3(row, col, offset_${name2}), vec3(${shape2[1]}, 1, 1));
+            vec2 uv = vec2((index + 0.5) / ${texNumC}.0, 0.5);
+            return sampleTexture(${name2}, uv);
+          }
+        `;
+          return new GlslLibRoutine(source2, ["coordinates.sampleTexture", "coordinates.coordsToOffset"]);
+        }
+        const source = `
+        float ${funcName}(int row, int col) {
+          int index = col * ${shape2[1]} + row;
+          vec2 uv = uvFromFlat(${texNumR}, ${texNumC}, index);
+          return sampleTexture(${name2}, uv);
+        }
+      `;
+        return new GlslLibRoutine(source, [
+          "coordinates.uvFromFlat",
+          "coordinates.sampleTexture",
+          "coordinates.coordsToOffset"
+        ]);
+      }
+      /**
+       * Unpacked 3D snippet.
+       */
+      getUnpackedSampler3D(funcName, name2, inputLayout) {
+        const shape2 = inputLayout.unpackedShape;
+        const stride0 = shape2[1] * shape2[2];
+        const stride1 = shape2[2];
+        const { newShape, keptDims } = squeezeShape(shape2);
+        const squeezedShape = newShape;
+        if (squeezedShape.length < shape2.length) {
+          const newInputShape = squeezeInputShape(shape2, squeezedShape);
+          const params = ["batch", "col", "row"];
+          const newInputLayout = JSON.parse(JSON.stringify(inputLayout));
+          newInputLayout.unpackedShape = newInputShape;
+          const routine = this.getUnpackedSamplerFromInput(funcName, name2, newInputLayout);
+          const revDims = keptDims.reverse();
+          const source2 = `
+          ${routine.routineBody}
+          float ${funcName}(int batch, int row, int col) {
+            return ${funcName}(${getSqueezedParams(params, revDims)});
+          }
+        `;
+          return new GlslLibRoutine(source2, routine.dependencies);
+        }
+        const texNumR = inputLayout.width;
+        const texNumC = inputLayout.height;
+        const source = `
+          float ${funcName}(int depth, int row, int col) {
+            // Explicitly use integer operations as dot() only works on floats.
+            int index = depth * ${stride0} + col * ${stride1} + row;
+            vec2 uv = uvFromFlat(${texNumR}, ${texNumC}, index);
+            return sampleTexture(${name2}, uv);
+          }
+      `;
+        return new GlslLibRoutine(source, [
+          "coordinates.uvFromFlat",
+          "coordinates.sampleTexture",
+          "coordinates.coordsToOffset"
+        ]);
+      }
+      /**
+       * Unpacked 4D snippet.
+       */
+      getUnpackedSampler4D(funcName, name2, inputLayout) {
+        const shape2 = inputLayout.unpackedShape;
+        const stride2 = shape2[3];
+        const stride1 = shape2[2] * stride2;
+        const stride0 = shape2[1] * stride1;
+        const texNumR = inputLayout.width;
+        const texNumC = inputLayout.height;
+        const source = `
+        float ${funcName}(int row, int col, int depth, int depth2) {
+          int index = row * ${stride0} + col * ${stride1} +
+              depth2 * ${stride2} + depth;
+          vec2 uv = uvFromFlat(${texNumR}, ${texNumC}, index);
+          return sampleTexture(${name2}, uv);
+        }
+      `;
+        return new GlslLibRoutine(source, ["coordinates.uvFromFlat", "coordinates.sampleTexture"]);
+      }
+      /**
+       * Unpacked 5D snippet.
+       */
+      getUnpackedSampler5D(funcName, name2, inputLayout) {
+        const shape2 = inputLayout.unpackedShape;
+        const stride3 = shape2[4];
+        const stride2 = shape2[3] * stride3;
+        const stride1 = shape2[2] * stride2;
+        const stride0 = shape2[1] * stride1;
+        const { newShape, keptDims } = squeezeShape(shape2);
+        if (newShape.length < shape2.length) {
+          const newInputShape = squeezeInputShape(shape2, newShape);
+          const params = ["row", "col", "depth", "depth2", "depth3"];
+          const newInputLayout = JSON.parse(JSON.stringify(inputLayout));
+          newInputLayout.unpackedShape = newInputShape;
+          const source2 = `
+          ${this.getUnpackedSamplerFromInput(funcName, name2, newInputLayout).routineBody}
+          float ${funcName}(int row, int col, int depth, int depth2, int depth3) {
+            return ${funcName}(${getSqueezedParams(params, keptDims)});
+          }
+        `;
+          return new GlslLibRoutine(source2, ["coordinates.sampleTexture", "coordinates.uvFromFlat"]);
+        }
+        const texNumR = inputLayout.width;
+        const texNumC = inputLayout.height;
+        const source = `
+        float ${funcName}(int row, int col, int depth, int depth2, int depth3) {
+          int index = row * ${stride0} + col * ${stride1} + depth * ${stride2} +
+          depth3 * ${stride3} + depth2;
+          vec2 uv = uvFromFlat(${texNumR}, ${texNumC}, index);
+          return sampleTexture(${name2}, uv);
+        }
+      `;
+        return new GlslLibRoutine(source, ["coordinates.sampleTexture", "coordinates.uvFromFlat"]);
+      }
+      /**
+       * Unpacked 6D snippet.
+       */
+      getUnpackedSampler6D(funcName, name2, inputLayout) {
+        const shape2 = inputLayout.unpackedShape;
+        const stride4 = shape2[5];
+        const stride3 = shape2[4] * stride4;
+        const stride2 = shape2[3] * stride3;
+        const stride1 = shape2[2] * stride2;
+        const stride0 = shape2[1] * stride1;
+        const { newShape, keptDims } = squeezeShape(shape2);
+        if (newShape.length < shape2.length) {
+          const newInputShape = squeezeInputShape(shape2, newShape);
+          const params = ["row", "col", "depth", "depth2", "depth3", "depth4"];
+          const newInputLayout = JSON.parse(JSON.stringify(inputLayout));
+          newInputLayout.unpackedShape = newInputShape;
+          const source2 = `
+            ${this.getUnpackedSamplerFromInput(funcName, name2, newInputLayout).routineBody}
+            float ${funcName}(int row, int col, int depth,
+              int depth2, int depth3, int depth4) {
+              return ${funcName}(${getSqueezedParams(params, keptDims)});
+            }
+          `;
+          return new GlslLibRoutine(source2, ["coordinates.sampleTexture", "coordinates.uvFromFlat"]);
+        }
+        const texNumR = inputLayout.width;
+        const texNumC = inputLayout.height;
+        const source = `
+          float ${funcName}(int row, int col, int depth,
+            int depth2, int depth3, int depth4) {
+            int index = row * ${stride0} + col * ${stride1} + depth * ${stride2} +
+            depth2 * ${stride3} + depth3 * ${stride4} + depth4;
+            vec2 uv = uvFromFlat(${texNumR}, ${texNumC}, index);
+            return sampleTexture(${name2}, uv);
+          }
+        `;
+        return new GlslLibRoutine(source, [
+          "coordinates.uvFromFlat",
+          "coordinates.sampleTexture",
+          "coordinates.coordsToOffset"
+        ]);
+      }
+      /**
+       * This is the main function to map from the given texture coordinates (s,t)
+       * to logical indices for the output
+       * There will only be one single variation of this
+       * Also see coordsToOffset and offsetToIndices for input-specific versions
+       */
+      toVec() {
+        const output = this.context.outputTextureLayout;
+        const rank = output.shape.length;
+        const strides = output.strides;
+        const xScale = output.width;
+        const yScale = output.height;
+        const stridesBlock = [];
+        for (let i = 0; i < rank - 1; ++i) {
+          stridesBlock.push(`
+        c[${i}] = offset / ${strides[i]};`);
+          stridesBlock.push(`
+        offset -= c[${i}] * ${strides[i]};`);
+        }
+        stridesBlock.push(`
+        c[${rank - 1}] = offset;`);
+        const body = `
+      void toVec(vec2 texCoords, out int c[${rank}]) {
+        int offset = coordsToOffset(texCoords, ${xScale}, ${yScale});
+        ${stridesBlock.join("")}
+      }
+      void toVec(int offset, out int c[${rank}]) {
+        ${stridesBlock.join("")}
+      }
+    `;
+        return { toVec: new GlslLibRoutine(body, ["coordinates.coordsToOffset"]) };
+      }
+      /**
+       * These are value getter functions generated for each input
+       * Each function is hardwired to the name and dimensions of the input
+       * An '_T' variation is also produced which accesses values as if the
+       * input was transposed
+       */
+      valueFrom() {
+        const result = {};
+        this.context.programInfo.inputNames.forEach((name2, i) => {
+          const layout = this.context.inputTextureLayouts[i];
+          const shape2 = layout.unpackedShape.length > 0 ? layout.unpackedShape : layout.shape;
+          const rank = shape2.length;
+          let funcName = `_${name2}`;
+          result[funcName] = new GlslLibRoutine(this.getValueFromSingle(name2, rank, layout.width, layout.height, false), [
+            `shapeUtils.indicesToOffset${funcName}`,
+            "coordinates.offsetToCoords",
+            "fragcolor.getColorAsFloat"
+          ]);
+          funcName = funcName + "_T";
+          result[funcName] = new GlslLibRoutine(this.getValueFromSingle(name2, rank, layout.width, layout.height, true), [
+            `shapeUtils.indicesToOffset${funcName}`,
+            "coordinates.offsetToCoords",
+            "fragcolor.getColorAsFloat"
+          ]);
+        });
+        return result;
+      }
+      /**
+       * Produces one value getter function for the name and rank given
+       * If a transpose is set proper offsetToCoords mapping will be used
+       * @param name name of the function
+       * @param rank rank of the input
+       * @param transpose whether or not should generate a transpose variation
+       */
+      getValueFromSingle(varName, rank, width, height, transpose2) {
+        let name2 = `_${varName}`;
+        if (transpose2) {
+          name2 = name2 + "_T";
+        }
+        const glsl = getGlsl(this.context.glContext.version);
+        return `
+        float ${name2}(int m[${rank}]) {
+          int offset = indicesToOffset${name2}(m);
+          vec2 coords = offsetToCoords(offset, ${width}, ${height});
+          float value = getColorAsFloat(${glsl.texture2D}(${varName}, coords));
+          return value;
+        }
+        `;
+      }
+      /**
+       * Produces a packed value getter function for the name and rank given
+       * If a transpose is set proper offsetToCoords mapping will be used
+       * @param name name of the function
+       * @param rank rank of the input
+       * @param transpose whether or not should generate a transpose variation
+       */
+      getPackedValueFrom(varName, rank, width, height, transpose2) {
+        let name2 = `_${varName}_Pack`;
+        if (transpose2) {
+          name2 = name2 + "_T";
+        }
+        const glsl = getGlsl(this.context.glContext.version);
+        return `
+        vec4 ${name2}(int m[${rank}]) {
+          int offset = indicesToOffset_${varName}(m);
+          vec2 coords = offsetToCoords(offset, ${width}, ${height});
+          return ${glsl.texture2D}(${varName}, coords);
+        }
+        `;
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/glsl-encoding-lib.ts
+var EncodingGlslLib;
+var init_glsl_encoding_lib = __esm({
+  "web/lib/onnxjs/backends/webgl/glsl-encoding-lib.ts"() {
+    "use strict";
+    init_glsl_definitions();
+    EncodingGlslLib = class _EncodingGlslLib extends GlslLib {
+      constructor(context) {
+        super(context);
+      }
+      getFunctions() {
+        return { ...this.encodeFloat32(), ...this.decodeFloat32() };
+      }
+      getCustomTypes() {
+        return {};
+      }
+      encodeFloat32() {
+        return {
+          encode: new GlslLibRoutine(`highp vec4 encode(highp float f) {
+        return vec4(f, 0.0, 0.0, 0.0);
+      }
+        `)
+        };
+      }
+      decodeFloat32() {
+        return {
+          decode: new GlslLibRoutine(`highp float decode(highp vec4 rgba) {
+        return rgba.r;
+      }
+        `)
+        };
+      }
+      /**
+       * returns the routine to encode encode a 32bit float to a vec4 (of unsigned bytes)
+       * @credit: https://stackoverflow.com/questions/7059962/how-do-i-convert-a-vec4-rgba-value-to-a-float
+       */
+      encodeUint8() {
+        const endianness = _EncodingGlslLib.isLittleEndian() ? "rgba.rgba=rgba.abgr;" : "";
+        return {
+          encode: new GlslLibRoutine(`
+      highp vec4 encode(highp float f) {
+        highp float F = abs(f);
+        highp float Sign = step(0.0,-f);
+        highp float Exponent = floor(log2(F));
+        highp float Mantissa = (exp2(- Exponent) * F);
+        Exponent = floor(log2(F) + 127.0) + floor(log2(Mantissa));
+        highp vec4 rgba;
+        rgba[0] = 128.0 * Sign  + floor(Exponent*exp2(-1.0));
+        rgba[1] = 128.0 * mod(Exponent,2.0) + mod(floor(Mantissa*128.0),128.0);
+        rgba[2] = floor(mod(floor(Mantissa*exp2(23.0 -8.0)),exp2(8.0)));
+        rgba[3] = floor(exp2(23.0)*mod(Mantissa,exp2(-15.0)));
+        ${endianness}
+        rgba = rgba / 255.0; // values need to be normalized to [0,1]
+        return rgba;
+    }
+        `)
+        };
+      }
+      /**
+       * returns the routine to encode a vec4 of unsigned bytes to float32
+       * @credit: https://stackoverflow.com/questions/7059962/how-do-i-convert-a-vec4-rgba-value-to-a-float
+       */
+      decodeUint8() {
+        const endianness = _EncodingGlslLib.isLittleEndian() ? "rgba.rgba=rgba.abgr;" : "";
+        return {
+          decode: new GlslLibRoutine(`
+        highp float decode(highp vec4 rgba) {
+          rgba = rgba * 255.0; // values need to be de-normalized from [0,1] to [0,255]
+          ${endianness}
+          highp float Sign = 1.0 - step(128.0,rgba[0])*2.0;
+          highp float Exponent = 2.0 * mod(rgba[0],128.0) + step(128.0,rgba[1]) - 127.0;
+          highp float Mantissa = mod(rgba[1],128.0)*65536.0 + rgba[2]*256.0 +rgba[3] + float(0x800000);
+          highp float Result =  Sign * exp2(Exponent) * (Mantissa * exp2(-23.0 ));
+          return Result;
+      }
+        `)
+        };
+      }
+      /**
+       * Determines if the machine is little endian or not
+       * @credit: https://gist.github.com/TooTallNate/4750953
+       */
+      static isLittleEndian() {
+        const b = new ArrayBuffer(4);
+        const a = new Uint32Array(b);
+        const c = new Uint8Array(b);
+        a[0] = 3735928559;
+        if (c[0] === 239) {
+          return true;
+        }
+        if (c[0] === 222) {
+          return false;
+        }
+        throw new Error("unknown endianness");
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/glsl-fragcolor-lib.ts
+var FragColorGlslLib;
+var init_glsl_fragcolor_lib = __esm({
+  "web/lib/onnxjs/backends/webgl/glsl-fragcolor-lib.ts"() {
+    "use strict";
+    init_glsl_definitions();
+    init_glsl_source();
+    FragColorGlslLib = class extends GlslLib {
+      constructor(context) {
+        super(context);
+      }
+      getFunctions() {
+        return { ...this.setFragColor(), ...this.getColorAsFloat() };
+      }
+      getCustomTypes() {
+        return {};
+      }
+      setFragColor() {
+        const glsl = getGlsl(this.context.glContext.version);
+        return {
+          setFragColor: new GlslLibRoutine(
+            `
+        void setFragColor(float value) {
+            ${glsl.output} = encode(value);
+        }
+        `,
+            ["encoding.encode"]
+          )
+        };
+      }
+      getColorAsFloat() {
+        return {
+          getColorAsFloat: new GlslLibRoutine(
+            `
+        float getColorAsFloat(vec4 color) {
+            return decode(color);
+        }
+        `,
+            ["encoding.decode"]
+          )
+        };
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/glsl-shape-utils-lib.ts
+var ShapeUtilsGlslLib;
+var init_glsl_shape_utils_lib = __esm({
+  "web/lib/onnxjs/backends/webgl/glsl-shape-utils-lib.ts"() {
+    "use strict";
+    init_glsl_definitions();
+    ShapeUtilsGlslLib = class _ShapeUtilsGlslLib extends GlslLib {
+      constructor(context) {
+        super(context);
+      }
+      getFunctions() {
+        return {
+          ...this.bcastIndex(),
+          ...this.bcastMatmulIndex(),
+          ...this.offsetToIndices(),
+          ...this.indicesToOffset(),
+          ...this.incrementIndices()
+        };
+      }
+      getCustomTypes() {
+        return {};
+      }
+      bcastIndex() {
+        const outputRank = this.context.outputTextureLayout.shape.length;
+        const result = {};
+        this.context.programInfo.inputNames.forEach((name2, i) => {
+          const shape2 = this.context.inputTextureLayouts[i].unpackedShape;
+          if (shape2.length <= outputRank) {
+            const rank = shape2.length;
+            const dimOffset = outputRank - rank;
+            const funcName = `bcastIndices_${name2}`;
+            let block = "";
+            for (let i2 = 0; i2 < rank; ++i2) {
+              block += `
+          realIndices[${i2}] = int( mod(float(bcastedIndices[${dimOffset + i2}]), ${shape2[i2]}.0) );
+          `;
+            }
+            const body = `
+        void ${funcName} (int bcastedIndices[${outputRank}], out int realIndices[${rank}]) {
+          ${block}
+        }
+        `;
+            result[funcName] = new GlslLibRoutine(body);
+          }
+        });
+        return result;
+      }
+      bcastMatmulIndex() {
+        const outputRank = this.context.outputTextureLayout.shape.length;
+        const result = {};
+        this.context.programInfo.inputNames.forEach((name2, i) => {
+          const shape2 = this.context.inputTextureLayouts[i].shape;
+          if (!(shape2.length < 2 || shape2.length > outputRank)) {
+            const rank = shape2.length;
+            const dimOffset = outputRank - rank;
+            const funcName = `bcastMatmulIndices_${name2}`;
+            let block = "";
+            for (let i2 = 0; i2 < rank - 2; ++i2) {
+              block += `
+          realIndices[${i2}] = int( mod(float(bcastedIndices[${dimOffset + i2}]), ${shape2[i2]}.0) );
+          `;
+            }
+            const body = `
+        void ${funcName}(int bcastedIndices[${outputRank}], out int realIndices[${rank}]) {
+          ${block}
+          realIndices[${rank - 1}] = bcastedIndices[${outputRank - 1}];
+          realIndices[${rank - 2}] = bcastedIndices[${outputRank - 2}];
+        }
+        `;
+            result[funcName] = new GlslLibRoutine(body);
+          }
+        });
+        return result;
+      }
+      indicesToOffset() {
+        const result = {};
+        this.context.programInfo.inputNames.forEach((name2, i) => {
+          const shape2 = this.context.inputTextureLayouts[i].shape;
+          const strides = this.context.inputTextureLayouts[i].strides;
+          const rank = shape2.length;
+          let funcName = `indicesToOffset_${name2}`;
+          result[funcName] = new GlslLibRoutine(_ShapeUtilsGlslLib.indexToOffsetSingle(funcName, rank, strides));
+          funcName = `indicesToOffset_${name2}_T`;
+          result[funcName] = new GlslLibRoutine(
+            _ShapeUtilsGlslLib.indexToOffsetSingle(funcName, rank, strides.slice().reverse())
+          );
+        });
+        return result;
+      }
+      static indexToOffsetSingle(name2, rank, strides) {
+        let block = "";
+        for (let i = rank - 1; i >= 0; --i) {
+          block += `
+        offset += indices[${i}] * ${strides[i]};
+        `;
+        }
+        return `
+      int ${name2}(int indices[${rank}]) {
+        int offset = 0;
+        ${block}
+        return offset;
+      }
+      `;
+      }
+      offsetToIndices() {
+        const result = {};
+        this.context.programInfo.inputNames.forEach((name2, i) => {
+          const shape2 = this.context.inputTextureLayouts[i].shape;
+          const strides = this.context.inputTextureLayouts[i].strides;
+          const rank = shape2.length;
+          let funcName = `offsetToIndices_${name2}`;
+          result[funcName] = new GlslLibRoutine(_ShapeUtilsGlslLib.offsetToIndicesSingle(funcName, rank, strides));
+          funcName = `offsetToIndices_${name2}_T`;
+          result[funcName] = new GlslLibRoutine(
+            _ShapeUtilsGlslLib.offsetToIndicesSingle(funcName, rank, strides.slice().reverse())
+          );
+        });
+        return result;
+      }
+      static offsetToIndicesSingle(name2, rank, strides) {
+        const stridesBlock = [];
+        for (let i = 0; i < rank - 1; ++i) {
+          stridesBlock.push(`
+      indices[${i}] = offset / ${strides[i]};`);
+          stridesBlock.push(`
+        offset -= indices[${i}] * ${strides[i]};`);
+        }
+        stridesBlock.push(`
+      indices[${rank - 1}] = offset;`);
+        return `
+      void ${name2}(int offset, out int indices[${rank}]) {
+        ${stridesBlock.join("")}
+      }
+      `;
+      }
+      incrementIndices() {
+        const result = {};
+        this.context.programInfo.inputNames.forEach((name2, i) => {
+          const shape2 = this.context.inputTextureLayouts[i].shape;
+          const rank = shape2.length;
+          const funcName = `incrementIndices_${name2}`;
+          let shapeInit = "";
+          for (let i2 = 0; i2 < rank; ++i2) {
+            shapeInit += `
+        shape[${i2}] = ${shape2[i2]};`;
+          }
+          const body = `
+        void ${funcName}(int axis, out int indices[${rank}]) {
+          int shape[${rank}];
+          ${shapeInit};
+          for(int i = ${rank} -1 ; i >= 0; --i) {
+            if(i > axis) continue;
+            indices[i] += 1;
+            if(indices[i] < shape[i]) {
+              break;
+            }
+            indices[i] = 0;
+          }
+        }
+        `;
+          result[funcName] = new GlslLibRoutine(body);
+        });
+        return result;
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/glsl-vec-lib.ts
+var VecGlslLib;
+var init_glsl_vec_lib = __esm({
+  "web/lib/onnxjs/backends/webgl/glsl-vec-lib.ts"() {
+    "use strict";
+    init_glsl_definitions();
+    VecGlslLib = class extends GlslLib {
+      constructor(context) {
+        super(context);
+      }
+      getCustomTypes() {
+        return {};
+      }
+      getFunctions() {
+        return { ...this.binaryVecFunctions(), ...this.copyVec(), ...this.setVecItem(), ...this.getVecItem() };
+      }
+      binaryVecFunctions() {
+        const outputLayout = this.context.outputTextureLayout;
+        const rank = outputLayout.shape.length;
+        const nameOp = { add: "+=", sub: "-=", mul: "*=", div: "/=" };
+        const result = {};
+        for (const name2 in nameOp) {
+          const fname = `${name2}Vec`;
+          let assignmentBlock = "";
+          for (let i = 0; i < rank; ++i) {
+            assignmentBlock += `
+          dest[${i}] ${nameOp[name2]} src[${i}];
+          `;
+          }
+          const body = `
+        void ${fname}(int src[${rank}], out int dest[${rank}]) {
+          ${assignmentBlock}
+        }
+        `;
+          result[fname] = new GlslLibRoutine(body);
+        }
+        return result;
+      }
+      copyVec() {
+        const outputLayout = this.context.outputTextureLayout;
+        const rank = outputLayout.shape.length;
+        let assignmentBlock = "";
+        for (let i = 0; i < rank; ++i) {
+          assignmentBlock += `
+        dest[${i}] = src[${i}];
+        `;
+        }
+        const body = `
+      void copyVec(int src[${rank}], out int dest[${rank}]) {
+        ${assignmentBlock}
+      }
+      `;
+        return { copyVec: new GlslLibRoutine(body) };
+      }
+      setVecItem() {
+        const outputLayout = this.context.outputTextureLayout;
+        const rank = outputLayout.shape.length;
+        let block = `
+        if(index < 0)
+            index =${rank} + index;
+        if (index == 0)
+            m[0] = value;
+        `;
+        for (let i = 1; i < rank - 1; ++i) {
+          block += `
+        else if (index == ${i})
+            m[${i}] = value;
+            `;
+        }
+        block += `
+        else
+            m[${rank - 1}] = value;
+        `;
+        const body = `
+      void setVecItem(out int m[${rank}], int index, int value) {
+        ${block}
+      }
+        `;
+        return { setVecItem: new GlslLibRoutine(body) };
+      }
+      getVecItem() {
+        const outputLayout = this.context.outputTextureLayout;
+        const rank = outputLayout.shape.length;
+        let block = `
+        if(index < 0)
+            index = ${rank} + index;
+        if (index == 0)
+            return m[0];
+      `;
+        for (let i = 1; i < rank - 1; ++i) {
+          block += `
+        else if (index == ${i})
+            return m[${i}];
+      `;
+        }
+        block += `
+        else
+            return m[${rank - 1}];
+        `;
+        const body = `
+      int getVecItem(int m[${rank}], int index) {
+        ${block}
+      }
+    `;
+        return { getVecItem: new GlslLibRoutine(body) };
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/glsl-registered-libs.ts
+var glslRegistry;
+var init_glsl_registered_libs = __esm({
+  "web/lib/onnxjs/backends/webgl/glsl-registered-libs.ts"() {
+    "use strict";
+    init_glsl_coordinate_lib();
+    init_glsl_encoding_lib();
+    init_glsl_fragcolor_lib();
+    init_glsl_shape_utils_lib();
+    init_glsl_vec_lib();
+    glslRegistry = {
+      encoding: EncodingGlslLib,
+      fragcolor: FragColorGlslLib,
+      vec: VecGlslLib,
+      shapeUtils: ShapeUtilsGlslLib,
+      coordinates: CoordsGlslLib
+      //  'arrays': ArrayGlslSLib
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/glsl-preprocessor.ts
+var GlslPreprocessor;
+var init_glsl_preprocessor = __esm({
+  "web/lib/onnxjs/backends/webgl/glsl-preprocessor.ts"() {
+    "use strict";
+    init_glsl_definitions();
+    init_glsl_function_inliner();
+    init_glsl_registered_libs();
+    init_glsl_source();
+    GlslPreprocessor = class {
+      constructor(glContext, programInfo, inputTextureLayouts, outputTextureLayout) {
+        this.libs = {};
+        this.glslLibRoutineDependencyGraph = {};
+        this.context = new GlslContext(glContext, programInfo, inputTextureLayouts, outputTextureLayout);
+        Object.keys(glslRegistry).forEach((name2) => {
+          const lib = new glslRegistry[name2](this.context);
+          this.libs[name2] = lib;
+        });
+        const map = this.glslLibRoutineDependencyGraph;
+        for (const libName in this.libs) {
+          const lib = this.libs[libName];
+          const routinesInLib = lib.getFunctions();
+          for (const routine in routinesInLib) {
+            const key = libName + "." + routine;
+            let currentNode;
+            if (map[key]) {
+              currentNode = map[key];
+              currentNode.routineBody = routinesInLib[routine].routineBody;
+            } else {
+              currentNode = new GlslLibRoutineNode(key, routinesInLib[routine].routineBody);
+              map[key] = currentNode;
+            }
+            const dependencies = routinesInLib[routine].dependencies;
+            if (dependencies) {
+              for (let i = 0; i < dependencies.length; ++i) {
+                if (!map[dependencies[i]]) {
+                  const node = new GlslLibRoutineNode(dependencies[i]);
+                  map[dependencies[i]] = node;
+                  currentNode.addDependency(node);
+                } else {
+                  currentNode.addDependency(map[dependencies[i]]);
+                }
+              }
+            }
+          }
+        }
+      }
+      preprocess() {
+        const programInfo = this.context.programInfo;
+        let source = programInfo.shaderSource;
+        if (!this.context.programInfo.hasMain) {
+          source = `${source}
+      ${getDefaultFragShaderMain(this.context.glContext.version, this.context.outputTextureLayout.shape.length)}`;
+        }
+        source = replaceInlines(source);
+        return `${getFragShaderPreamble(this.context.glContext.version)}
+    ${this.getUniforms(programInfo.inputNames, programInfo.variables)}
+    ${this.getImports(source)}
+    ${source}`;
+      }
+      getImports(script) {
+        const routinesIncluded = this.selectGlslLibRoutinesToBeIncluded(script);
+        if (routinesIncluded.length === 0) {
+          return "";
+        }
+        let routines = "";
+        for (let i = 0; i < routinesIncluded.length; ++i) {
+          if (routinesIncluded[i].routineBody) {
+            routines += routinesIncluded[i].routineBody + "\n";
+          } else {
+            throw new Error(`Missing body for the Glsl Library routine: ${routinesIncluded[i].name}`);
+          }
+        }
+        return routines;
+      }
+      selectGlslLibRoutinesToBeIncluded(script) {
+        const nodes = [];
+        Object.keys(this.glslLibRoutineDependencyGraph).forEach((classAndRoutine) => {
+          const routine = classAndRoutine.split(".")[1];
+          if (script.indexOf(routine) !== -1) {
+            nodes.push(this.glslLibRoutineDependencyGraph[classAndRoutine]);
+          }
+        });
+        return TopologicalSortGlslRoutines.returnOrderedNodes(nodes);
+      }
+      getUniforms(samplers, variables) {
+        const uniformLines = [];
+        if (samplers) {
+          for (const sampler of samplers) {
+            uniformLines.push(`uniform sampler2D ${sampler};`);
+          }
+        }
+        if (variables) {
+          for (const variable of variables) {
+            uniformLines.push(
+              `uniform ${variable.type} ${variable.name}${variable.arrayLength ? `[${variable.arrayLength}]` : ""};`
+            );
+          }
+        }
+        return uniformLines.join("\n");
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/program-manager.ts
+var ProgramManager;
+var init_program_manager = __esm({
+  "web/lib/onnxjs/backends/webgl/program-manager.ts"() {
+    "use strict";
+    init_esm();
+    init_instrument();
+    init_glsl_preprocessor();
+    init_glsl_source();
+    ProgramManager = class {
+      constructor(profiler, glContext, textureLayoutStrategy) {
+        this.profiler = profiler;
+        this.glContext = glContext;
+        this.textureLayoutStrategy = textureLayoutStrategy;
+        this.repo = /* @__PURE__ */ new Map();
+        this.attributesBound = false;
+      }
+      getArtifact(key) {
+        return this.repo.get(key);
+      }
+      setArtifact(key, artifact) {
+        this.repo.set(key, artifact);
+      }
+      run(buildArtifact, inputs, output) {
+        this.profiler.event(
+          "op",
+          `ProgramManager.run ${buildArtifact.programInfo.name ?? "unknown kernel"}`,
+          () => {
+            const gl = this.glContext.gl;
+            const program = buildArtifact.program;
+            gl.useProgram(program);
+            try {
+              this.bindOutput(output);
+              if (!this.attributesBound) {
+                this.bindAttributes(buildArtifact.attribLocations);
+              }
+              this.bindUniforms(buildArtifact.uniformLocations, buildArtifact.programInfo.variables ?? [], inputs);
+            } catch (err) {
+              Logger.error("ProgramManager", buildArtifact.programInfo.shaderSource);
+              throw err;
+            }
+            this.profiler.event("backend", "GlContext.draw()", () => {
+              this.glContext.draw();
+            });
+          },
+          this.glContext
+        );
+      }
+      dispose() {
+        if (this.vertexShader) {
+          this.glContext.deleteShader(this.vertexShader);
+        }
+        this.repo.forEach((a) => this.glContext.deleteProgram(a.program));
+      }
+      build(programInfo, inputTextureLayouts, outputTextureLayout) {
+        return this.profiler.event("backend", "ProgramManager.build", () => {
+          const preprocessor = new GlslPreprocessor(this.glContext, programInfo, inputTextureLayouts, outputTextureLayout);
+          const fragScript = preprocessor.preprocess();
+          const program = this.compile(fragScript);
+          const artifact = {
+            programInfo,
+            program,
+            uniformLocations: this.getUniformLocations(
+              program,
+              preprocessor.context.programInfo.inputNames,
+              preprocessor.context.programInfo.variables
+            ),
+            attribLocations: this.getAttribLocations(program)
+          };
+          return artifact;
+        });
+      }
+      compile(fragShaderScript) {
+        if (!this.vertexShader) {
+          Logger.verbose("ProrgramManager", "Compiling and caching Vertex shader for the first time");
+          const vertexShaderScript = getVertexShaderSource(this.glContext.version);
+          this.vertexShader = this.glContext.compileShader(vertexShaderScript, this.glContext.gl.VERTEX_SHADER);
+        }
+        if (env2.debug) {
+          Logger.verbose(
+            "ProrgramManager",
+            `FragShader:
+${fragShaderScript}
+`
+          );
+        }
+        const fragShader = this.glContext.compileShader(fragShaderScript, this.glContext.gl.FRAGMENT_SHADER);
+        const program = this.glContext.createProgram(this.vertexShader, fragShader);
+        this.glContext.deleteShader(fragShader);
+        return program;
+      }
+      bindOutput(td) {
+        const width = td.width;
+        const height = td.height;
+        Logger.verbose(
+          "ProrgramManager",
+          `Binding output texture to Framebuffer: w/h=${width}/${height}, shape=${td.shape}, type=${td.tensor.type}`
+        );
+        this.glContext.attachFramebuffer(td.texture, width, height);
+      }
+      bindAttributes(attribLocations) {
+        const positionHandle = attribLocations.position;
+        const textureCoordHandle = attribLocations.textureCoord;
+        this.glContext.setVertexAttributes(positionHandle, textureCoordHandle);
+        this.attributesBound = true;
+      }
+      bindUniforms(uniformLocations, variables, textures) {
+        const gl = this.glContext.gl;
+        let texturePosition = 0;
+        for (const { name: name2, type, location, arrayLength } of uniformLocations) {
+          const value = variables.find((v) => v.name === name2)?.data;
+          if (type !== "sampler2D" && !value) {
+            throw new Error(`variable '${name2}' does not have data defined in program info`);
+          }
+          switch (type) {
+            case "sampler2D":
+              this.bindTexture(textures[texturePosition], location, texturePosition);
+              texturePosition++;
+              break;
+            case "float":
+              if (arrayLength) {
+                gl.uniform1fv(location, value);
+              } else {
+                gl.uniform1f(location, value);
+              }
+              break;
+            case "int":
+              if (arrayLength) {
+                gl.uniform1iv(location, value);
+              } else {
+                gl.uniform1i(location, value);
+              }
+              break;
+            default:
+              throw new Error(`Uniform not implemented: ${type}`);
+          }
+        }
+      }
+      bindTexture(td, uniformHandle, position) {
+        this.glContext.bindTextureToUniform(td.texture, position, uniformHandle);
+      }
+      getAttribLocations(program) {
+        return {
+          position: this.getAttribLocation(program, "position"),
+          textureCoord: this.getAttribLocation(program, "textureCoord")
+        };
+      }
+      getUniformLocations(program, samplers, variables) {
+        const uniformLocations = [];
+        if (samplers) {
+          for (const sampler of samplers) {
+            uniformLocations.push({
+              name: sampler,
+              type: "sampler2D",
+              location: this.getUniformLocation(program, sampler)
+            });
+          }
+        }
+        if (variables) {
+          for (const variable of variables) {
+            uniformLocations.push({ ...variable, location: this.getUniformLocation(program, variable.name) });
+          }
+        }
+        return uniformLocations;
+      }
+      getUniformLocation(program, name2) {
+        const gl = this.glContext.gl;
+        const reference = gl.getUniformLocation(program, name2);
+        if (reference === null) {
+          throw new Error(`Uniform ${name2} not found.`);
+        }
+        return reference;
+      }
+      getAttribLocation(program, name2) {
+        const gl = this.glContext.gl;
+        const attributeLocation = gl.getAttribLocation(program, name2);
+        return attributeLocation;
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/texture-manager.ts
+var TextureManager;
+var init_texture_manager = __esm({
+  "web/lib/onnxjs/backends/webgl/texture-manager.ts"() {
+    "use strict";
+    init_instrument();
+    init_texture_data_encoder();
+    TextureManager = class {
+      constructor(glContext, layoutStrategy, profiler, config) {
+        this.glContext = glContext;
+        this.layoutStrategy = layoutStrategy;
+        this.profiler = profiler;
+        this.config = config;
+        this.pendingRead = /* @__PURE__ */ new Map();
+        if (config.reuseTextures) {
+          this.inUseTextures = /* @__PURE__ */ new Map();
+          this.idleTextures = /* @__PURE__ */ new Map();
+          this.textureLookup = /* @__PURE__ */ new Map();
+        }
+      }
+      createTextureFromLayout(dataType, layout, data, usage) {
+        const textureDataType = this.toEncoderType(dataType);
+        const encoder = this.glContext.getEncoder(textureDataType, layout.channels || 1, usage);
+        if (layout.isPacked && usage === 1 /* UploadOnly */) {
+          throw new Error("not implemented");
+        }
+        const width = layout.width;
+        const height = layout.height;
+        let key;
+        let inUseTextures;
+        if (this.config.reuseTextures) {
+          key = `${width}x${height}_${encoder.format}_${encoder.internalFormat}_${encoder.textureType}`;
+          inUseTextures = this.inUseTextures.get(key);
+          if (!inUseTextures) {
+            inUseTextures = [];
+            this.inUseTextures.set(key, inUseTextures);
+          }
+          const idleTextures = this.idleTextures.get(key);
+          if (idleTextures && idleTextures.length > 0) {
+            const texture2 = idleTextures.pop();
+            inUseTextures.push(texture2);
+            if (usage === 1 /* UploadOnly */) {
+              this.glContext.updateTexture(texture2, width, height, encoder, this.toTextureData(dataType, data));
+            }
+            return texture2;
+          }
+        }
+        Logger.verbose("TextureManager", `Creating new texture of size ${layout.width}x${layout.height}`);
+        const texture = this.glContext.allocateTexture(width, height, encoder, this.toTextureData(dataType, data));
+        if (this.config.reuseTextures) {
+          inUseTextures.push(texture);
+          this.textureLookup.set(texture, key);
+        }
+        return texture;
+      }
+      readTexture(td, dataType, channels) {
+        if (!channels) {
+          channels = 1;
+        }
+        return this.profiler.event("backend", "TextureManager.readTexture", () => {
+          const dataSize = td.shape.reduce((a, b) => a * b) * channels;
+          const data = this.glContext.readTexture(
+            td.texture,
+            td.width,
+            td.height,
+            dataSize,
+            this.toEncoderType(dataType),
+            channels
+          );
+          return this.toTensorData(dataType, data);
+        });
+      }
+      async readTextureAsync(td, dataType, channels) {
+        const dataId = td.tensor.dataId;
+        if (!channels) {
+          channels = 1;
+        }
+        if (this.pendingRead.has(dataId)) {
+          const subscribers = this.pendingRead.get(dataId);
+          return new Promise((resolve) => subscribers?.push(resolve));
+        }
+        return this.profiler.event("backend", "TextureManager.readTextureAsync", async () => {
+          this.pendingRead.set(dataId, []);
+          const dataSize = td.shape.reduce((a, b) => a * b) * channels;
+          await this.glContext.createAndWaitForFence();
+          const data = this.glContext.readTexture(
+            td.texture,
+            td.width,
+            td.height,
+            dataSize,
+            this.toEncoderType(dataType),
+            channels
+          );
+          const tensorData = this.toTensorData(dataType, data);
+          const subscribers = this.pendingRead.get(dataId);
+          this.pendingRead.delete(dataId);
+          subscribers?.forEach((resolve) => resolve(tensorData));
+          return tensorData;
+        });
+      }
+      readUint8TextureAsFloat(td) {
+        return this.profiler.event("backend", "TextureManager.readUint8TextureAsFloat", () => {
+          const dataSize = td.shape.reduce((a, b) => a * b);
+          const data = this.glContext.readTexture(td.texture, td.width, td.height, dataSize * 4, "byte", 4);
+          return new Float32Array(data.buffer, data.byteOffset, dataSize);
+        });
+      }
+      releaseTexture(textureData, deleteTexture) {
+        let key;
+        if (this.config.reuseTextures) {
+          key = this.textureLookup.get(textureData.texture);
+          if (key) {
+            if (deleteTexture) {
+              this.textureLookup.delete(key);
+            }
+            const inUseTextures = this.inUseTextures.get(key);
+            if (inUseTextures) {
+              const index = inUseTextures.indexOf(textureData.texture);
+              if (index !== -1) {
+                inUseTextures.splice(index, 1);
+                let idleTextures = this.idleTextures.get(key);
+                if (!idleTextures) {
+                  idleTextures = [];
+                  this.idleTextures.set(key, idleTextures);
+                }
+                idleTextures.push(textureData.texture);
+              }
+            }
+          }
+        }
+        if (!key || deleteTexture) {
+          Logger.verbose("TextureManager", `Deleting texture of size ${textureData.width}x${textureData.height}`);
+          this.glContext.deleteTexture(textureData.texture);
+        }
+      }
+      toTensorData(dataType, data) {
+        switch (dataType) {
+          case "int16":
+            return data instanceof Int16Array ? data : Int16Array.from(data);
+          case "int32":
+            return data instanceof Int32Array ? data : Int32Array.from(data);
+          case "int8":
+            return data instanceof Int8Array ? data : Int8Array.from(data);
+          case "uint16":
+            return data instanceof Uint16Array ? data : Uint16Array.from(data);
+          case "uint32":
+            return data instanceof Uint32Array ? data : Uint32Array.from(data);
+          case "uint8":
+          case "bool":
+            return data instanceof Uint8Array ? data : Uint8Array.from(data);
+          case "float32":
+            return data instanceof Float32Array ? data : Float32Array.from(data);
+          case "float64":
+            return data instanceof Float64Array ? data : Float64Array.from(data);
+          default:
+            throw new Error(`TensorData type ${dataType} is not supported`);
+        }
+      }
+      toTextureData(_dataType, data) {
+        if (!data) {
+          return void 0;
+        }
+        return data instanceof Float32Array ? data : new Float32Array(data);
+      }
+      toEncoderType(_dataType) {
+        return "float";
+      }
+      clearActiveTextures() {
+        this.glContext.clearActiveTextures();
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/session-handler.ts
+var WebGLSessionHandler;
+var init_session_handler = __esm({
+  "web/lib/onnxjs/backends/webgl/session-handler.ts"() {
+    "use strict";
+    init_instrument();
+    init_opset();
+    init_inference_handler();
+    init_op_resolve_rules();
+    init_program_manager();
+    init_texture_layout_strategy();
+    init_texture_manager();
+    WebGLSessionHandler = class {
+      constructor(backend2, context) {
+        this.backend = backend2;
+        this.context = context;
+        this.layoutStrategy = new PreferLogicalStrategy(backend2.glContext.maxTextureSize);
+        this.programManager = new ProgramManager(this.context.profiler, backend2.glContext, this.layoutStrategy);
+        this.textureManager = new TextureManager(backend2.glContext, this.layoutStrategy, this.context.profiler, {
+          reuseTextures: backend2.textureCacheMode === "full"
+        });
+        this.packedTextureDataCache = /* @__PURE__ */ new Map();
+        this.unpackedTextureDataCache = /* @__PURE__ */ new Map();
+        this.pack = backend2.pack;
+        this.pack2unpackMap = /* @__PURE__ */ new Map();
+        this.unpack2packMap = /* @__PURE__ */ new Map();
+      }
+      createInferenceHandler() {
+        return new WebGLInferenceHandler(this);
+      }
+      onGraphInitialized(graph) {
+        const initializers = graph.getValues().filter((v) => v.from === -1 && v.tensor).map((v) => v.tensor.dataId);
+        this.initializers = new Set(initializers);
+      }
+      isInitializer(tensorId) {
+        return this.initializers ? this.initializers.has(tensorId) : false;
+      }
+      addInitializer(tensorId) {
+        this.initializers.add(tensorId);
+      }
+      getTextureData(tensorId, isPacked) {
+        if (isPacked) {
+          return this.packedTextureDataCache.get(tensorId);
+        } else {
+          return this.unpackedTextureDataCache.get(tensorId);
+        }
+      }
+      setTextureData(tensorId, textureData, isPacked = false) {
+        Logger.verbose("WebGLSessionHandler", "Storing Texture data in cache");
+        if (isPacked) {
+          this.packedTextureDataCache.set(tensorId, textureData);
+        } else {
+          this.unpackedTextureDataCache.set(tensorId, textureData);
+        }
+      }
+      dispose() {
+        this.programManager.dispose();
+        this.textureManager.clearActiveTextures();
+        this.packedTextureDataCache.forEach((td) => this.textureManager.releaseTexture(td, true));
+        this.packedTextureDataCache = /* @__PURE__ */ new Map();
+        this.unpackedTextureDataCache.forEach((td) => this.textureManager.releaseTexture(td, true));
+        this.unpackedTextureDataCache = /* @__PURE__ */ new Map();
+      }
+      resolve(node, opsets, graph) {
+        const op = resolveOperator(node, opsets, WEBGL_OP_RESOLVE_RULES);
+        return { impl: op.opImpl, context: op.opInit ? op.opInit(node, graph) : node };
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/webgl-context.ts
+function linearSearchLastTrue(arr) {
+  let i = 0;
+  for (; i < arr.length; ++i) {
+    const isDone = arr[i]();
+    if (!isDone) {
+      break;
+    }
+  }
+  return i - 1;
+}
+var WebGLContext;
+var init_webgl_context = __esm({
+  "web/lib/onnxjs/backends/webgl/webgl-context.ts"() {
+    "use strict";
+    init_esm();
+    init_texture_data_encoder();
+    init_texture_data_encoder();
+    init_utils();
+    WebGLContext = class {
+      constructor(gl, version3) {
+        this.frameBufferBound = false;
+        this.itemsToPoll = [];
+        this.gl = gl;
+        this.version = version3;
+        this.getExtensions();
+        this.vertexbuffer = this.createVertexbuffer();
+        this.framebuffer = this.createFramebuffer();
+        this.queryVitalParameters();
+      }
+      allocateTexture(width, height, encoder, data) {
+        const gl = this.gl;
+        const texture = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D, texture);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+        const buffer = data ? encoder.encode(data, width * height) : null;
+        gl.texImage2D(
+          gl.TEXTURE_2D,
+          0,
+          // Level of detail.
+          encoder.internalFormat,
+          width,
+          height,
+          0,
+          // Always 0 in OpenGL ES.
+          encoder.format,
+          encoder.textureType,
+          buffer
+        );
+        this.checkError();
+        return texture;
+      }
+      updateTexture(texture, width, height, encoder, data) {
+        const gl = this.gl;
+        gl.bindTexture(gl.TEXTURE_2D, texture);
+        const buffer = encoder.encode(data, width * height);
+        gl.texSubImage2D(
+          gl.TEXTURE_2D,
+          0,
+          // level
+          0,
+          // xoffset
+          0,
+          // yoffset
+          width,
+          height,
+          encoder.format,
+          encoder.textureType,
+          buffer
+        );
+        this.checkError();
+      }
+      attachFramebuffer(texture, width, height) {
+        const gl = this.gl;
+        gl.bindTexture(gl.TEXTURE_2D, texture);
+        gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);
+        gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);
+        this.checkError();
+        gl.viewport(0, 0, width, height);
+        gl.scissor(0, 0, width, height);
+      }
+      readTexture(texture, width, height, dataSize, dataType, channels) {
+        const gl = this.gl;
+        if (!channels) {
+          channels = 1;
+        }
+        if (!this.frameBufferBound) {
+          this.attachFramebuffer(texture, width, height);
+        }
+        const encoder = this.getEncoder(dataType, channels);
+        const buffer = encoder.allocate(width * height);
+        gl.bindTexture(gl.TEXTURE_2D, texture);
+        gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);
+        gl.readPixels(0, 0, width, height, gl.RGBA, encoder.textureType, buffer);
+        this.checkError();
+        return encoder.decode(buffer, dataSize);
+      }
+      isFramebufferReady() {
+        return true;
+      }
+      getActiveTexture() {
+        const gl = this.gl;
+        const n = gl.getParameter(this.gl.ACTIVE_TEXTURE);
+        return `TEXTURE${n - gl.TEXTURE0}`;
+      }
+      getTextureBinding() {
+        return this.gl.getParameter(this.gl.TEXTURE_BINDING_2D);
+      }
+      getFramebufferBinding() {
+        return this.gl.getParameter(this.gl.FRAMEBUFFER_BINDING);
+      }
+      setVertexAttributes(positionHandle, textureCoordHandle) {
+        const gl = this.gl;
+        gl.vertexAttribPointer(positionHandle, 3, gl.FLOAT, false, 20, 0);
+        gl.enableVertexAttribArray(positionHandle);
+        if (textureCoordHandle !== -1) {
+          gl.vertexAttribPointer(textureCoordHandle, 2, gl.FLOAT, false, 20, 12);
+          gl.enableVertexAttribArray(textureCoordHandle);
+        }
+        this.checkError();
+      }
+      createProgram(vertexShader, fragShader) {
+        const gl = this.gl;
+        const program = gl.createProgram();
+        gl.attachShader(program, vertexShader);
+        gl.attachShader(program, fragShader);
+        gl.linkProgram(program);
+        return program;
+      }
+      compileShader(shaderSource, shaderType) {
+        const gl = this.gl;
+        const shader = gl.createShader(shaderType);
+        if (!shader) {
+          throw new Error(`createShader() returned null with type ${shaderType}`);
+        }
+        gl.shaderSource(shader, shaderSource);
+        gl.compileShader(shader);
+        if (gl.getShaderParameter(shader, gl.COMPILE_STATUS) === false) {
+          throw new Error(`Failed to compile shader: ${gl.getShaderInfoLog(shader)}
+Shader source:
+${shaderSource}`);
+        }
+        return shader;
+      }
+      deleteShader(shader) {
+        this.gl.deleteShader(shader);
+      }
+      bindTextureToUniform(texture, position, uniformHandle) {
+        const gl = this.gl;
+        gl.activeTexture(gl.TEXTURE0 + position);
+        this.checkError();
+        gl.bindTexture(gl.TEXTURE_2D, texture);
+        this.checkError();
+        gl.uniform1i(uniformHandle, position);
+        this.checkError();
+      }
+      draw() {
+        this.gl.drawArrays(this.gl.TRIANGLE_STRIP, 0, 4);
+        this.checkError();
+      }
+      checkError() {
+        if (env2.debug) {
+          const gl = this.gl;
+          const error = gl.getError();
+          let label = "";
+          switch (error) {
+            case gl.NO_ERROR:
+              return;
+            case gl.INVALID_ENUM:
+              label = "INVALID_ENUM";
+              break;
+            case gl.INVALID_VALUE:
+              label = "INVALID_VALUE";
+              break;
+            case gl.INVALID_OPERATION:
+              label = "INVALID_OPERATION";
+              break;
+            case gl.INVALID_FRAMEBUFFER_OPERATION:
+              label = "INVALID_FRAMEBUFFER_OPERATION";
+              break;
+            case gl.OUT_OF_MEMORY:
+              label = "OUT_OF_MEMORY";
+              break;
+            case gl.CONTEXT_LOST_WEBGL:
+              label = "CONTEXT_LOST_WEBGL";
+              break;
+            default:
+              label = `Unknown WebGL Error: ${error.toString(16)}`;
+          }
+          throw new Error(label);
+        }
+      }
+      deleteTexture(texture) {
+        this.gl.deleteTexture(texture);
+      }
+      deleteProgram(program) {
+        this.gl.deleteProgram(program);
+      }
+      getEncoder(dataType, channels, usage = 0 /* Default */) {
+        if (this.version === 2) {
+          return new RedFloat32DataEncoder(this.gl, channels);
+        }
+        switch (dataType) {
+          case "float":
+            if (usage === 1 /* UploadOnly */ || this.isRenderFloat32Supported) {
+              return new RGBAFloatDataEncoder(this.gl, channels);
+            } else {
+              return new RGBAFloatDataEncoder(
+                this.gl,
+                channels,
+                this.textureHalfFloatExtension.HALF_FLOAT_OES
+              );
+            }
+          case "int":
+            throw new Error("not implemented");
+          case "byte":
+            return new Uint8DataEncoder(this.gl, channels);
+          default:
+            throw new Error(`Invalid dataType: ${dataType}`);
+        }
+      }
+      clearActiveTextures() {
+        const gl = this.gl;
+        for (let unit = 0; unit < this.maxTextureImageUnits; ++unit) {
+          gl.activeTexture(gl.TEXTURE0 + unit);
+          gl.bindTexture(gl.TEXTURE_2D, null);
+        }
+      }
+      dispose() {
+        if (this.disposed) {
+          return;
+        }
+        const gl = this.gl;
+        gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+        gl.deleteFramebuffer(this.framebuffer);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        gl.deleteBuffer(this.vertexbuffer);
+        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
+        gl.finish();
+        this.disposed = true;
+      }
+      createDefaultGeometry() {
+        return new Float32Array([
+          -1,
+          1,
+          0,
+          0,
+          1,
+          // upper left
+          -1,
+          -1,
+          0,
+          0,
+          0,
+          // lower left
+          1,
+          1,
+          0,
+          1,
+          1,
+          // upper right
+          1,
+          -1,
+          0,
+          1,
+          0
+          // lower right
+        ]);
+      }
+      createVertexbuffer() {
+        const gl = this.gl;
+        const buffer = gl.createBuffer();
+        if (!buffer) {
+          throw new Error("createBuffer() returned null");
+        }
+        const geometry = this.createDefaultGeometry();
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        gl.bufferData(gl.ARRAY_BUFFER, geometry, gl.STATIC_DRAW);
+        this.checkError();
+        return buffer;
+      }
+      createFramebuffer() {
+        const fb = this.gl.createFramebuffer();
+        if (!fb) {
+          throw new Error("createFramebuffer returned null");
+        }
+        return fb;
+      }
+      queryVitalParameters() {
+        const gl = this.gl;
+        this.isFloatTextureAttachableToFrameBuffer = this.checkFloatTextureAttachableToFrameBuffer();
+        this.isRenderFloat32Supported = this.checkRenderFloat32();
+        this.isFloat32DownloadSupported = this.checkFloat32Download();
+        if (this.version === 1 && !this.textureHalfFloatExtension && !this.isRenderFloat32Supported) {
+          throw new Error("both float32 and float16 TextureType are not supported");
+        }
+        this.isBlendSupported = !this.isRenderFloat32Supported || this.checkFloat32Blend();
+        this.maxTextureSize = gl.getParameter(gl.MAX_TEXTURE_SIZE);
+        this.maxTextureImageUnits = gl.getParameter(gl.MAX_TEXTURE_IMAGE_UNITS);
+        if (this.version === 2) {
+        }
+      }
+      getExtensions() {
+        if (this.version === 2) {
+          this.colorBufferFloatExtension = this.gl.getExtension("EXT_color_buffer_float");
+          this.disjointTimerQueryWebgl2Extension = this.gl.getExtension("EXT_disjoint_timer_query_webgl2");
+        } else {
+          this.textureFloatExtension = this.gl.getExtension("OES_texture_float");
+          this.textureHalfFloatExtension = this.gl.getExtension("OES_texture_half_float");
+        }
+      }
+      checkFloatTextureAttachableToFrameBuffer() {
+        const gl = this.gl;
+        const texture = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D, texture);
+        const internalFormat = this.version === 2 ? gl.RGBA32F : gl.RGBA;
+        gl.texImage2D(gl.TEXTURE_2D, 0, internalFormat, 1, 1, 0, gl.RGBA, gl.FLOAT, null);
+        const frameBuffer = gl.createFramebuffer();
+        gl.bindFramebuffer(gl.FRAMEBUFFER, frameBuffer);
+        gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);
+        const isComplete = gl.checkFramebufferStatus(gl.FRAMEBUFFER) === gl.FRAMEBUFFER_COMPLETE;
+        gl.bindTexture(gl.TEXTURE_2D, null);
+        gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+        gl.deleteTexture(texture);
+        gl.deleteFramebuffer(frameBuffer);
+        return isComplete;
+      }
+      checkRenderFloat32() {
+        if (this.version === 2) {
+          if (!this.colorBufferFloatExtension) {
+            return false;
+          }
+        } else {
+          if (!this.textureFloatExtension) {
+            return false;
+          }
+        }
+        return this.isFloatTextureAttachableToFrameBuffer;
+      }
+      checkFloat32Download() {
+        if (this.version === 2) {
+          if (!this.colorBufferFloatExtension) {
+            return false;
+          }
+        } else {
+          if (!this.textureFloatExtension) {
+            return false;
+          }
+          if (!this.gl.getExtension("WEBGL_color_buffer_float")) {
+            return false;
+          }
+        }
+        return this.isFloatTextureAttachableToFrameBuffer;
+      }
+      /**
+       * Check whether GL_BLEND is supported
+       */
+      checkFloat32Blend() {
+        const gl = this.gl;
+        let texture;
+        let frameBuffer;
+        let vertexShader;
+        let fragmentShader;
+        let program;
+        try {
+          texture = gl.createTexture();
+          frameBuffer = gl.createFramebuffer();
+          gl.bindTexture(gl.TEXTURE_2D, texture);
+          const internalFormat = this.version === 2 ? gl.RGBA32F : gl.RGBA;
+          gl.texImage2D(gl.TEXTURE_2D, 0, internalFormat, 1, 1, 0, gl.RGBA, gl.FLOAT, null);
+          gl.bindFramebuffer(gl.FRAMEBUFFER, frameBuffer);
+          gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);
+          gl.enable(gl.BLEND);
+          vertexShader = gl.createShader(gl.VERTEX_SHADER);
+          if (!vertexShader) {
+            return false;
+          }
+          gl.shaderSource(vertexShader, "void main(){}");
+          gl.compileShader(vertexShader);
+          fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);
+          if (!fragmentShader) {
+            return false;
+          }
+          gl.shaderSource(fragmentShader, "precision highp float;void main(){gl_FragColor=vec4(0.5);}");
+          gl.compileShader(fragmentShader);
+          program = gl.createProgram();
+          if (!program) {
+            return false;
+          }
+          gl.attachShader(program, vertexShader);
+          gl.attachShader(program, fragmentShader);
+          gl.linkProgram(program);
+          gl.useProgram(program);
+          gl.drawArrays(gl.POINTS, 0, 1);
+          return gl.getError() === gl.NO_ERROR;
+        } finally {
+          gl.disable(gl.BLEND);
+          if (program) {
+            gl.deleteProgram(program);
+          }
+          if (vertexShader) {
+            gl.deleteShader(vertexShader);
+          }
+          if (fragmentShader) {
+            gl.deleteShader(fragmentShader);
+          }
+          if (frameBuffer) {
+            gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+            gl.deleteFramebuffer(frameBuffer);
+          }
+          if (texture) {
+            gl.bindTexture(gl.TEXTURE_2D, null);
+            gl.deleteTexture(texture);
+          }
+        }
+      }
+      beginTimer() {
+        if (this.version === 2 && this.disjointTimerQueryWebgl2Extension) {
+          const gl2 = this.gl;
+          const ext = this.disjointTimerQueryWebgl2Extension;
+          const query = gl2.createQuery();
+          gl2.beginQuery(ext.TIME_ELAPSED_EXT, query);
+          return query;
+        } else {
+          throw new Error("WebGL1 profiling currently not supported.");
+        }
+      }
+      endTimer() {
+        if (this.version === 2 && this.disjointTimerQueryWebgl2Extension) {
+          const gl2 = this.gl;
+          const ext = this.disjointTimerQueryWebgl2Extension;
+          gl2.endQuery(ext.TIME_ELAPSED_EXT);
+          return;
+        } else {
+          throw new Error("WebGL1 profiling currently not supported");
+        }
+      }
+      isTimerResultAvailable(query) {
+        let available = false, disjoint = false;
+        if (this.version === 2 && this.disjointTimerQueryWebgl2Extension) {
+          const gl2 = this.gl;
+          const ext = this.disjointTimerQueryWebgl2Extension;
+          available = gl2.getQueryParameter(query, gl2.QUERY_RESULT_AVAILABLE);
+          disjoint = gl2.getParameter(ext.GPU_DISJOINT_EXT);
+        } else {
+          throw new Error("WebGL1 profiling currently not supported");
+        }
+        return available && !disjoint;
+      }
+      getTimerResult(query) {
+        let timeElapsed = 0;
+        if (this.version === 2) {
+          const gl2 = this.gl;
+          timeElapsed = gl2.getQueryParameter(query, gl2.QUERY_RESULT);
+          gl2.deleteQuery(query);
+        } else {
+          throw new Error("WebGL1 profiling currently not supported");
+        }
+        return timeElapsed / 1e6;
+      }
+      async waitForQueryAndGetTime(query) {
+        await repeatedTry(() => this.isTimerResultAvailable(query));
+        return this.getTimerResult(query);
+      }
+      async createAndWaitForFence() {
+        const fenceContext = this.createFence(this.gl);
+        return this.pollFence(fenceContext);
+      }
+      createFence(gl) {
+        let isFencePassed;
+        const gl2 = gl;
+        const query = gl2.fenceSync(gl2.SYNC_GPU_COMMANDS_COMPLETE, 0);
+        gl.flush();
+        if (query === null) {
+          isFencePassed = () => true;
+        } else {
+          isFencePassed = () => {
+            const status = gl2.clientWaitSync(query, 0, 0);
+            return status === gl2.ALREADY_SIGNALED || status === gl2.CONDITION_SATISFIED;
+          };
+        }
+        return { query, isFencePassed };
+      }
+      async pollFence(fenceContext) {
+        return new Promise((resolve) => {
+          void this.addItemToPoll(
+            () => fenceContext.isFencePassed(),
+            () => resolve()
+          );
+        });
+      }
+      pollItems() {
+        const index = linearSearchLastTrue(this.itemsToPoll.map((x) => x.isDoneFn));
+        for (let i = 0; i <= index; ++i) {
+          const { resolveFn } = this.itemsToPoll[i];
+          resolveFn();
+        }
+        this.itemsToPoll = this.itemsToPoll.slice(index + 1);
+      }
+      async addItemToPoll(isDoneFn, resolveFn) {
+        this.itemsToPoll.push({ isDoneFn, resolveFn });
+        if (this.itemsToPoll.length > 1) {
+          return;
+        }
+        await repeatedTry(() => {
+          this.pollItems();
+          return this.itemsToPoll.length === 0;
+        });
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/backends/webgl/webgl-context-factory.ts
+function createWebGLContext(contextId) {
+  let context;
+  if ((!contextId || contextId === "webgl2") && "webgl2" in cache) {
+    context = cache.webgl2;
+  } else if ((!contextId || contextId === "webgl") && "webgl" in cache) {
+    context = cache.webgl;
+  }
+  if (!context) {
+    try {
+      const offscreenCanvas = createOffscreenCanvas();
+      context = createNewWebGLContext(offscreenCanvas, contextId);
+    } catch {
+      const canvas = createCanvas();
+      context = createNewWebGLContext(canvas, contextId);
+    }
+  }
+  contextId = contextId || context.version === 1 ? "webgl" : "webgl2";
+  const gl = context.gl;
+  cache[contextId] = context;
+  if (gl.isContextLost()) {
+    delete cache[contextId];
+    return createWebGLContext(contextId);
+  }
+  gl.disable(gl.DEPTH_TEST);
+  gl.disable(gl.STENCIL_TEST);
+  gl.disable(gl.BLEND);
+  gl.disable(gl.DITHER);
+  gl.disable(gl.POLYGON_OFFSET_FILL);
+  gl.disable(gl.SAMPLE_COVERAGE);
+  gl.enable(gl.SCISSOR_TEST);
+  gl.enable(gl.CULL_FACE);
+  gl.cullFace(gl.BACK);
+  return context;
+}
+function createNewWebGLContext(canvas, contextId) {
+  const contextAttributes = {
+    alpha: false,
+    depth: false,
+    antialias: false,
+    stencil: false,
+    preserveDrawingBuffer: false,
+    premultipliedAlpha: false,
+    failIfMajorPerformanceCaveat: false
+  };
+  let gl;
+  const ca = contextAttributes;
+  if (!contextId || contextId === "webgl2") {
+    gl = canvas.getContext("webgl2", ca);
+    if (gl) {
+      try {
+        return new WebGLContext(gl, 2);
+      } catch (err) {
+        Logger.warning("GlContextFactory", `failed to create WebGLContext using contextId 'webgl2'. Error: ${err}`);
+      }
+    }
+  }
+  if (!contextId || contextId === "webgl") {
+    gl = canvas.getContext("webgl", ca) || canvas.getContext("experimental-webgl", ca);
+    if (gl) {
+      try {
+        return new WebGLContext(gl, 1);
+      } catch (err) {
+        Logger.warning(
+          "GlContextFactory",
+          `failed to create WebGLContext using contextId 'webgl' or 'experimental-webgl'. Error: ${err}`
+        );
+      }
+    }
+  }
+  throw new Error("WebGL is not supported");
+}
+function createCanvas() {
+  if (typeof document === "undefined") {
+    throw new TypeError("failed to create canvas: document is not supported");
+  }
+  const canvas = document.createElement("canvas");
+  canvas.width = 1;
+  canvas.height = 1;
+  return canvas;
+}
+function createOffscreenCanvas() {
+  if (typeof OffscreenCanvas === "undefined") {
+    throw new TypeError("failed to create offscreen canvas: OffscreenCanvas is not supported");
+  }
+  return new OffscreenCanvas(1, 1);
+}
+var cache;
+var init_webgl_context_factory = __esm({
+  "web/lib/onnxjs/backends/webgl/webgl-context-factory.ts"() {
+    "use strict";
+    init_instrument();
+    init_webgl_context();
+    cache = {};
+  }
+});
+
+// web/lib/onnxjs/backends/backend-webgl.ts
+var WebGLBackend;
+var init_backend_webgl = __esm({
+  "web/lib/onnxjs/backends/backend-webgl.ts"() {
+    "use strict";
+    init_esm();
+    init_instrument();
+    init_session_handler();
+    init_webgl_context_factory();
+    WebGLBackend = class {
+      get contextId() {
+        return env2.webgl.contextId;
+      }
+      set contextId(value) {
+        env2.webgl.contextId = value;
+      }
+      get matmulMaxBatchSize() {
+        return env2.webgl.matmulMaxBatchSize;
+      }
+      set matmulMaxBatchSize(value) {
+        env2.webgl.matmulMaxBatchSize = value;
+      }
+      get textureCacheMode() {
+        return env2.webgl.textureCacheMode;
+      }
+      set textureCacheMode(value) {
+        env2.webgl.textureCacheMode = value;
+      }
+      get pack() {
+        return env2.webgl.pack;
+      }
+      set pack(value) {
+        env2.webgl.pack = value;
+      }
+      get async() {
+        return env2.webgl.async;
+      }
+      set async(value) {
+        env2.webgl.async = value;
+      }
+      initialize() {
+        try {
+          this.glContext = createWebGLContext(this.contextId);
+          if (typeof this.matmulMaxBatchSize !== "number") {
+            this.matmulMaxBatchSize = 16;
+          }
+          if (typeof this.textureCacheMode !== "string") {
+            this.textureCacheMode = "full";
+          }
+          if (typeof this.pack !== "boolean") {
+            this.pack = false;
+          }
+          if (typeof this.async !== "boolean") {
+            this.async = false;
+          }
+          Logger.setWithEnv(env2);
+          if (!env2.webgl.context) {
+            Object.defineProperty(env2.webgl, "context", { value: this.glContext.gl });
+          }
+          Logger.verbose(
+            "WebGLBackend",
+            `Created WebGLContext: ${typeof this.glContext} with matmulMaxBatchSize: ${this.matmulMaxBatchSize}; textureCacheMode: ${this.textureCacheMode}; pack: ${this.pack}; async: ${this.async}.`
+          );
+          return true;
+        } catch (e) {
+          Logger.warning("WebGLBackend", `Unable to initialize WebGLBackend. ${e}`);
+          return false;
+        }
+      }
+      createSessionHandler(context) {
+        return new WebGLSessionHandler(this, context);
+      }
+      dispose() {
+        this.glContext.dispose();
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/backend.ts
+async function resolveBackend(hint) {
+  if (!hint) {
+    return resolveBackend(["webgl"]);
+  } else {
+    const hints = typeof hint === "string" ? [hint] : hint;
+    for (const backendHint of hints) {
+      const cache2 = backendsCache.get(backendHint);
+      if (cache2) {
+        return cache2;
+      }
+      const backend2 = await tryLoadBackend(backendHint);
+      if (backend2) {
+        return backend2;
+      }
+    }
+  }
+  throw new Error("no available backend to use");
+}
+async function tryLoadBackend(backendHint) {
+  const backendObj = backend;
+  if (typeof backendObj[backendHint] !== "undefined" && isBackend(backendObj[backendHint])) {
+    const backend2 = backendObj[backendHint];
+    let init = backend2.initialize();
+    if (typeof init === "object" && "then" in init) {
+      init = await init;
+    }
+    if (init) {
+      backendsCache.set(backendHint, backend2);
+      return backend2;
+    }
+  }
+  return void 0;
+}
+function isBackend(obj) {
+  const o = obj;
+  if ("initialize" in o && typeof o.initialize === "function" && // initialize()
+  "createSessionHandler" in o && typeof o.createSessionHandler === "function" && // createSessionHandler()
+  "dispose" in o && typeof o.dispose === "function") {
+    return true;
+  }
+  return false;
+}
+var backendsCache, backend;
+var init_backend2 = __esm({
+  "web/lib/onnxjs/backend.ts"() {
+    "use strict";
+    init_backend_webgl();
+    backendsCache = /* @__PURE__ */ new Map();
+    backend = {
+      webgl: new WebGLBackend()
+    };
+  }
+});
+
+// web/lib/onnxjs/execution-plan.ts
+var KernelOp, ExecutionPlan;
+var init_execution_plan = __esm({
+  "web/lib/onnxjs/execution-plan.ts"() {
+    "use strict";
+    init_instrument();
+    KernelOp = class {
+      constructor(op, node) {
+        this.op = op;
+        this.node = node;
+      }
+    };
+    ExecutionPlan = class {
+      constructor(graph, ops, profiler) {
+        this.graph = graph;
+        this.profiler = profiler;
+        this.initialize(ops);
+      }
+      initialize(ops) {
+        this.profiler.event("session", "ExecutionPlan.initialize", () => {
+          const graphNodes = this.graph.getNodes();
+          if (graphNodes.length !== ops.length) {
+            throw new Error("The size of nodes and OPs do not match.");
+          }
+          this._ops = ops.map((op, i) => new KernelOp(op, graphNodes[i]));
+          this.reset();
+          this._starter = [];
+          this._ops.forEach((op, i) => {
+            let resolved = true;
+            for (const input of op.node.inputs) {
+              if (!this._values[input] && // not an initialized input
+              this.graph.getInputIndices().indexOf(input) === -1) {
+                resolved = false;
+                break;
+              }
+            }
+            if (resolved) {
+              this._starter.push(i);
+            }
+          });
+        });
+      }
+      reset() {
+        this._values = this.graph.getValues().map((i) => i.tensor);
+      }
+      async execute(sessionHandler, modelInputs) {
+        return this.profiler.event("session", "ExecutionPlan.execute", async () => {
+          this.reset();
+          const inferenceHandler = sessionHandler.createInferenceHandler();
+          const graphInputs = this.graph.getInputIndices();
+          if (modelInputs.length !== graphInputs.length) {
+            throw new Error(
+              `number of input tensors don't match the number of inputs to the model: actual: ${modelInputs.length} expected: ${graphInputs.length}`
+            );
+          }
+          modelInputs.forEach((input, i) => {
+            const index = graphInputs[i];
+            this._values[index] = input;
+          });
+          const sequence = this._starter.slice(0);
+          const graphValues = this.graph.getValues();
+          const graphNodes = this.graph.getNodes();
+          let rear = 0;
+          while (rear < sequence.length) {
+            const thisOpIndex = sequence[rear++];
+            const thisOp = this._ops[thisOpIndex];
+            const inputList = thisOp.node.inputs.map((i) => this._values[i]);
+            if (inputList.indexOf(void 0) !== -1) {
+              throw new Error(`unresolved input detected: op: ${thisOp.node}`);
+            }
+            const inputTensors = inputList;
+            Logger.verbose(
+              "ExecPlan",
+              `Running op:${thisOp.node.name} (${inputTensors.map((t, i) => `'${thisOp.node.inputs[i]}': ${t.type}[${t.dims.join(",")}]`).join(", ")})`
+            );
+            const outputList = await this.profiler.event(
+              "node",
+              thisOp.node.name,
+              async () => thisOp.op.impl(inferenceHandler, inputTensors, thisOp.op.context)
+            );
+            if (outputList.length !== thisOp.node.outputs.length) {
+              throw new Error("the size of output does not match model definition.");
+            }
+            outputList.forEach((output2, i) => {
+              const j = thisOp.node.outputs[i];
+              if (this._values[j]) {
+                throw new Error(`output [${j}] already has value: op:${thisOp.node.name}`);
+              }
+              this._values[j] = output2;
+            });
+            const downstreamNodes = /* @__PURE__ */ new Set();
+            outputList.forEach((_output, i) => {
+              const j = thisOp.node.outputs[i];
+              for (const currentDownstreamNodeIndex of graphValues[j].to) {
+                const currentDownstreamNode = graphNodes[currentDownstreamNodeIndex];
+                let resolved = true;
+                for (const k of currentDownstreamNode.inputs) {
+                  if (!this._values[k]) {
+                    resolved = false;
+                    break;
+                  }
+                }
+                if (resolved) {
+                  downstreamNodes.add(currentDownstreamNodeIndex);
+                }
+              }
+            });
+            sequence.push(...downstreamNodes);
+          }
+          const output = [];
+          for (let i = 0; i < this.graph.getOutputIndices().length; i++) {
+            const outputIndex = this.graph.getOutputIndices()[i];
+            const outputTensor = this._values[outputIndex];
+            if (outputTensor === void 0) {
+              throw new Error(`required output [${outputIndex}] does not have value`);
+            }
+            if (outputIndex === 0) {
+              await outputTensor.getData();
+            } else {
+              void outputTensor.data;
+            }
+            output.push(outputTensor);
+          }
+          Logger.verbose("ExecPlan", "disposing of inferenceHandler");
+          inferenceHandler.dispose();
+          return output;
+        });
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/attribute.ts
+var import_onnx3, Attribute2;
+var init_attribute = __esm({
+  "web/lib/onnxjs/attribute.ts"() {
+    "use strict";
+    init_ort_generated();
+    import_onnx3 = __toESM(require_onnx());
+    init_tensor2();
+    init_util();
+    Attribute2 = class _Attribute {
+      constructor(attributes) {
+        this._attributes = /* @__PURE__ */ new Map();
+        if (attributes !== null && attributes !== void 0) {
+          for (const attr of attributes) {
+            if (attr instanceof import_onnx3.onnx.AttributeProto) {
+              this._attributes.set(attr.name, [_Attribute.getValue(attr), _Attribute.getType(attr)]);
+            } else if (attr instanceof import_attribute.Attribute) {
+              this._attributes.set(attr.name(), [_Attribute.getValue(attr), _Attribute.getType(attr)]);
+            }
+          }
+          if (this._attributes.size < attributes.length) {
+            throw new Error("duplicated attribute names");
+          }
+        }
+      }
+      set(key, type, value) {
+        this._attributes.set(key, [value, type]);
+      }
+      delete(key) {
+        this._attributes.delete(key);
+      }
+      getFloat(key, defaultValue) {
+        return this.get(key, "float", defaultValue);
+      }
+      getInt(key, defaultValue) {
+        return this.get(key, "int", defaultValue);
+      }
+      getString(key, defaultValue) {
+        return this.get(key, "string", defaultValue);
+      }
+      getTensor(key, defaultValue) {
+        return this.get(key, "tensor", defaultValue);
+      }
+      getFloats(key, defaultValue) {
+        return this.get(key, "floats", defaultValue);
+      }
+      getInts(key, defaultValue) {
+        return this.get(key, "ints", defaultValue);
+      }
+      getStrings(key, defaultValue) {
+        return this.get(key, "strings", defaultValue);
+      }
+      getTensors(key, defaultValue) {
+        return this.get(key, "tensors", defaultValue);
+      }
+      get(key, type, defaultValue) {
+        const valueAndType = this._attributes.get(key);
+        if (valueAndType === void 0) {
+          if (defaultValue !== void 0) {
+            return defaultValue;
+          }
+          throw new Error(`required attribute not found: ${key}`);
+        }
+        if (valueAndType[1] !== type) {
+          throw new Error(`type mismatch: expected ${type} but got ${valueAndType[1]}`);
+        }
+        return valueAndType[0];
+      }
+      static getType(attr) {
+        const type = attr instanceof import_onnx3.onnx.AttributeProto ? attr.type : attr.type();
+        switch (type) {
+          case import_onnx3.onnx.AttributeProto.AttributeType.FLOAT:
+            return "float";
+          case import_onnx3.onnx.AttributeProto.AttributeType.INT:
+            return "int";
+          case import_onnx3.onnx.AttributeProto.AttributeType.STRING:
+            return "string";
+          case import_onnx3.onnx.AttributeProto.AttributeType.TENSOR:
+            return "tensor";
+          case import_onnx3.onnx.AttributeProto.AttributeType.FLOATS:
+            return "floats";
+          case import_onnx3.onnx.AttributeProto.AttributeType.INTS:
+            return "ints";
+          case import_onnx3.onnx.AttributeProto.AttributeType.STRINGS:
+            return "strings";
+          case import_onnx3.onnx.AttributeProto.AttributeType.TENSORS:
+            return "tensors";
+          default:
+            throw new Error(`attribute type is not supported yet: ${import_onnx3.onnx.AttributeProto.AttributeType[type]}`);
+        }
+      }
+      static getValue(attr) {
+        const attrType = attr instanceof import_onnx3.onnx.AttributeProto ? attr.type : attr.type();
+        if (attrType === import_onnx3.onnx.AttributeProto.AttributeType.GRAPH || attrType === import_onnx3.onnx.AttributeProto.AttributeType.GRAPHS) {
+          throw new Error("graph attribute is not supported yet");
+        }
+        const value = this.getValueNoCheck(attr);
+        if (attrType === import_onnx3.onnx.AttributeProto.AttributeType.INT && LongUtil.isLong(value)) {
+          return LongUtil.longToNumber(value);
+        }
+        if (attrType === import_onnx3.onnx.AttributeProto.AttributeType.INTS) {
+          const arr = value;
+          const numberValue = new Array(arr.length);
+          for (let i = 0; i < arr.length; i++) {
+            const maybeLong = arr[i];
+            numberValue[i] = LongUtil.longToNumber(maybeLong);
+          }
+          return numberValue;
+        }
+        if (attrType === import_onnx3.onnx.AttributeProto.AttributeType.TENSOR) {
+          return attr instanceof import_onnx3.onnx.AttributeProto ? Tensor4.fromProto(value) : Tensor4.fromOrtTensor(value);
+        }
+        if (attrType === import_onnx3.onnx.AttributeProto.AttributeType.TENSORS) {
+          if (attr instanceof import_onnx3.onnx.AttributeProto) {
+            const tensorProtos = value;
+            return tensorProtos.map((value2) => Tensor4.fromProto(value2));
+          } else if (attr instanceof import_attribute.Attribute) {
+            const tensorProtos = value;
+            return tensorProtos.map((value2) => Tensor4.fromOrtTensor(value2));
+          }
+        }
+        if (attrType === import_onnx3.onnx.AttributeProto.AttributeType.STRING) {
+          if (attr instanceof import_onnx3.onnx.AttributeProto) {
+            const utf8String = value;
+            return decodeUtf8String(utf8String);
+          }
+        }
+        if (attrType === import_onnx3.onnx.AttributeProto.AttributeType.STRINGS) {
+          if (attr instanceof import_onnx3.onnx.AttributeProto) {
+            const utf8Strings = value;
+            return utf8Strings.map(decodeUtf8String);
+          }
+        }
+        return value;
+      }
+      static getValueNoCheck(attr) {
+        return attr instanceof import_onnx3.onnx.AttributeProto ? this.getValueNoCheckFromOnnxFormat(attr) : this.getValueNoCheckFromOrtFormat(attr);
+      }
+      static getValueNoCheckFromOnnxFormat(attr) {
+        switch (attr.type) {
+          case import_onnx3.onnx.AttributeProto.AttributeType.FLOAT:
+            return attr.f;
+          case import_onnx3.onnx.AttributeProto.AttributeType.INT:
+            return attr.i;
+          case import_onnx3.onnx.AttributeProto.AttributeType.STRING:
+            return attr.s;
+          case import_onnx3.onnx.AttributeProto.AttributeType.TENSOR:
+            return attr.t;
+          case import_onnx3.onnx.AttributeProto.AttributeType.GRAPH:
+            return attr.g;
+          case import_onnx3.onnx.AttributeProto.AttributeType.FLOATS:
+            return attr.floats;
+          case import_onnx3.onnx.AttributeProto.AttributeType.INTS:
+            return attr.ints;
+          case import_onnx3.onnx.AttributeProto.AttributeType.STRINGS:
+            return attr.strings;
+          case import_onnx3.onnx.AttributeProto.AttributeType.TENSORS:
+            return attr.tensors;
+          case import_onnx3.onnx.AttributeProto.AttributeType.GRAPHS:
+            return attr.graphs;
+          default:
+            throw new Error(`unsupported attribute type: ${import_onnx3.onnx.AttributeProto.AttributeType[attr.type]}`);
+        }
+      }
+      static getValueNoCheckFromOrtFormat(attr) {
+        switch (attr.type()) {
+          case import_attribute_type.AttributeType.FLOAT:
+            return attr.f();
+          case import_attribute_type.AttributeType.INT:
+            return attr.i();
+          case import_attribute_type.AttributeType.STRING:
+            return attr.s();
+          case import_attribute_type.AttributeType.TENSOR:
+            return attr.t();
+          case import_attribute_type.AttributeType.GRAPH:
+            return attr.g();
+          case import_attribute_type.AttributeType.FLOATS:
+            return attr.floatsArray();
+          case import_attribute_type.AttributeType.INTS: {
+            const ints = [];
+            for (let i = 0; i < attr.intsLength(); i++) {
+              ints.push(attr.ints(i));
+            }
+            return ints;
+          }
+          case import_attribute_type.AttributeType.STRINGS: {
+            const strings = [];
+            for (let i = 0; i < attr.stringsLength(); i++) {
+              strings.push(attr.strings(i));
+            }
+            return strings;
+          }
+          case import_attribute_type.AttributeType.TENSORS: {
+            const tensors = [];
+            for (let i = 0; i < attr.tensorsLength(); i++) {
+              tensors.push(attr.tensors(i));
+            }
+            return tensors;
+          }
+          // case ortFbs.AttributeType.GRAPHS:
+          // TODO: Subgraph not supported yet.
+          // const graphs = [];
+          // for (let i = 0; i < attr.graphsLength(); i++) {
+          //   graphs.push(attr.graphs(i)!);
+          // }
+          // return graphs;
+          default:
+            throw new Error(`unsupported attribute type: ${import_attribute_type.AttributeType[attr.type()]}`);
+        }
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/graph.ts
+var import_onnx4, Graph2, Value, Node2, GraphImpl;
+var init_graph = __esm({
+  "web/lib/onnxjs/graph.ts"() {
+    "use strict";
+    init_attribute();
+    init_ort_generated();
+    import_onnx4 = __toESM(require_onnx());
+    init_tensor2();
+    init_util();
+    Graph2 = {
+      /**
+       * construct a graph from a graph protobuf type
+       */
+      from: (graphProto, initializer) => new GraphImpl(graphProto, initializer)
+    };
+    Value = class {
+      constructor(valueInfo) {
+        this._from = void 0;
+        this._to = [];
+        this.tensor = void 0;
+        this.type = void 0;
+        if (valueInfo) {
+          this.type = ProtoUtil.tensorValueTypeFromProto(valueInfo.type.tensorType);
+        }
+      }
+      // -1 represent from initializer
+      get from() {
+        return this._from;
+      }
+      get to() {
+        return this._to;
+      }
+    };
+    Node2 = class {
+      constructor(_nodeProto, name2) {
+        if (_nodeProto instanceof import_onnx4.onnx.NodeProto) {
+          this.name = _nodeProto.name;
+          this.opType = _nodeProto.opType;
+          this.attributes = new Attribute2(_nodeProto.attribute);
+        } else if (_nodeProto instanceof import_node.Node) {
+          this.name = name2 ?? _nodeProto.name();
+          this.opType = _nodeProto.opType();
+          this.attributes = new Attribute2(ProtoUtil.tensorAttributesFromORTFormat(_nodeProto));
+        }
+        this.inputs = [];
+        this.outputs = [];
+        this.executeNode = true;
+      }
+    };
+    GraphImpl = class {
+      constructor(graph, graphInitializer) {
+        if (!graph) {
+          throw new TypeError("graph is empty");
+        }
+        this.buildGraph(graph);
+        this.transformGraph(graphInitializer);
+        this.checkIsAcyclic();
+      }
+      getInputIndices() {
+        return this._allInputIndices;
+      }
+      getInputNames() {
+        return this._allInputNames;
+      }
+      getOutputIndices() {
+        return this._allOutputIndices;
+      }
+      getOutputNames() {
+        return this._allOutputNames;
+      }
+      getValues() {
+        return this._allData;
+      }
+      getNodes() {
+        return this._nodes;
+      }
+      buildGraph(graph) {
+        if (graph instanceof import_onnx4.onnx.GraphProto) {
+          this.buildGraphFromOnnxFormat(graph);
+        } else if (graph instanceof import_graph.Graph) {
+          this.buildGraphFromOrtFormat(graph);
+        } else {
+          throw new TypeError("Graph type is not supported.");
+        }
+      }
+      buildGraphFromOnnxFormat(graph) {
+        const dataIndices = /* @__PURE__ */ new Map();
+        this._allData = [];
+        this._allInputIndices = [];
+        this._allInputNames = [];
+        this._allOutputIndices = [];
+        this._allOutputNames = [];
+        this._nodes = [];
+        const nodesIndices = /* @__PURE__ */ new Map();
+        if (!graph.input) {
+          throw new Error("missing information in graph: input");
+        }
+        const inputValueNames = [];
+        for (const i of graph.input) {
+          if (dataIndices.has(i.name)) {
+            throw new Error(`duplicated input name: ${i.name}`);
+          }
+          const currentIndex = this._allData.push(new Value(i)) - 1;
+          dataIndices.set(i.name, currentIndex);
+          inputValueNames.push(i.name);
+        }
+        if (!graph.initializer) {
+          throw new Error("missing information in graph: initializer");
+        }
+        for (const i of graph.initializer) {
+          let index = dataIndices.get(i.name);
+          if (index === void 0) {
+            const value = new Value();
+            value.type = {
+              shape: { dims: ProtoUtil.tensorDimsFromProto(i.dims) },
+              tensorType: ProtoUtil.tensorDataTypeFromProto(i.dataType)
+            };
+            index = this._allData.push(value) - 1;
+            dataIndices.set(i.name, index);
+          }
+          this._allData[index]._from = -1;
+          this._allData[index].tensor = Tensor4.fromProto(i);
+        }
+        for (let i = 0; i < this._allData.length; i++) {
+          if (!this._allData[i].tensor) {
+            this._allInputIndices.push(i);
+            this._allInputNames.push(inputValueNames[i]);
+          }
+        }
+        if (!graph.output) {
+          throw new Error("missing information in graph: output");
+        }
+        for (const i of graph.output) {
+          if (dataIndices.has(i.name)) {
+            throw new Error(`duplicated output name: ${i.name}`);
+          }
+          const currentIndex = this._allData.push(new Value(i)) - 1;
+          dataIndices.set(i.name, currentIndex);
+          this._allOutputIndices.push(currentIndex);
+          this._allOutputNames.push(i.name);
+        }
+        if (!graph.node) {
+          throw new Error("missing information in graph: node");
+        }
+        for (const nodeProto of graph.node) {
+          if (!nodeProto.name) {
+            for (let pick = 0; ; pick++) {
+              const name2 = `unnamed_${nodeProto.opType}_${pick}`;
+              if (!nodesIndices.has(name2)) {
+                nodeProto.name = name2;
+                break;
+              }
+            }
+          }
+          if (nodesIndices.has(nodeProto.name)) {
+            throw new Error(`duplicated node name: ${nodeProto.name}`);
+          }
+          const currentIndex = this._nodes.push(new Node2(nodeProto)) - 1;
+          nodesIndices.set(nodeProto.name, currentIndex);
+        }
+        for (let i = 0; i < this._nodes.length; i++) {
+          const node = this._nodes[i];
+          const nodeProto = graph.node[i];
+          if (!nodeProto.output) {
+            throw new Error(`missing output for node: ${nodeProto.name}`);
+          }
+          for (const output of nodeProto.output) {
+            let dataIndex = dataIndices.get(output);
+            if (typeof dataIndex === "undefined") {
+              dataIndex = this._allData.push(new Value()) - 1;
+              dataIndices.set(output, dataIndex);
+            }
+            node.outputs.push(dataIndex);
+            if (this._allData[dataIndex]._from !== void 0) {
+              throw new Error(`multiple nodes output to one data value: ${dataIndex}`);
+            }
+            this._allData[dataIndex]._from = i;
+            if (nodeProto.opType === "Constant") {
+              if (!nodeProto.attribute || nodeProto.attribute.length !== 1 || !nodeProto.attribute[0].t) {
+                throw new Error("missing attributes or missing tensor value in attributes for this Constant operator");
+              }
+              if (!nodeProto.output || nodeProto.output.length !== 1) {
+                throw new Error("missing output or incorrect number of outputs for this Constant operator");
+              }
+              node.outputs.pop();
+              node.executeNode = false;
+              this._allData[dataIndex]._from = -1;
+              this._allData[dataIndex].tensor = Tensor4.fromProto(nodeProto.attribute[0].t);
+            }
+          }
+        }
+        for (let i = 0; i < this._nodes.length; i++) {
+          const node = this._nodes[i];
+          const nodeProto = graph.node[i];
+          if (!nodeProto.input) {
+            throw new Error(`missing input for node: ${nodeProto.name}`);
+          }
+          for (const input of nodeProto.input) {
+            const dataIndex = dataIndices.get(input);
+            if (typeof dataIndex === "undefined") {
+              if (input === "" && (nodeProto.input.length === 3 || nodeProto.input.length === 4) && nodeProto.opType === "Resize") {
+                continue;
+              }
+              throw new Error(`unrecognized input '${input}' for node: ${nodeProto.name}`);
+            }
+            node.inputs.push(dataIndex);
+            this._allData[dataIndex]._to.push(i);
+          }
+        }
+        return true;
+      }
+      buildGraphFromOrtFormat(graph) {
+        const dataIndices = /* @__PURE__ */ new Map();
+        this._allData = [];
+        this._allInputIndices = [];
+        this._allInputNames = [];
+        this._allOutputIndices = [];
+        this._allOutputNames = [];
+        this._nodes = [];
+        const nodesIndices = /* @__PURE__ */ new Map();
+        const inputValueNames = [];
+        for (let i = 0; i < graph.inputsLength(); i++) {
+          const inputName = graph.inputs(i);
+          if (dataIndices.has(inputName)) {
+            throw new Error(`duplicated input name: ${inputName}`);
+          }
+          for (let j = 0; j < graph.nodeArgsLength(); j++) {
+            if (graph.nodeArgs(j)?.name() === inputName) {
+              const value = new Value();
+              const valueType = graph.nodeArgs(j)?.type()?.valueType();
+              if (valueType !== import_type_info_value.TypeInfoValue.tensor_type) {
+                throw new Error("Unexpected value type for the nodeArg.");
+              }
+              const valueInfo = graph.nodeArgs(j).type().value(new import_tensor_type_and_shape.TensorTypeAndShape());
+              const type = ProtoUtil.tensorDataTypeFromProto(valueInfo.elemType());
+              const shape2 = valueInfo.shape();
+              const dims = [];
+              for (let k = 0; k < shape2.dimLength(); k++) {
+                dims.push(LongUtil.longToNumber(shape2.dim(k).value().dimValue()));
+              }
+              value.type = { shape: { dims }, tensorType: type };
+              const currentIndex = this._allData.push(value) - 1;
+              dataIndices.set(inputName, currentIndex);
+              inputValueNames.push(inputName);
+            }
+          }
+        }
+        for (let i = 0; i < graph.initializersLength(); i++) {
+          const initializer = graph.initializers(i);
+          let index = dataIndices.get(initializer.name());
+          if (index === void 0) {
+            const value = new Value();
+            const dims = ProtoUtil.tensorDimsFromORTFormat(initializer);
+            const type = ProtoUtil.tensorDataTypeFromProto(initializer.dataType());
+            value.type = { shape: { dims }, tensorType: type };
+            index = this._allData.push(value) - 1;
+            dataIndices.set(initializer.name(), index);
+          }
+          this._allData[index]._from = -1;
+          this._allData[index].tensor = Tensor4.fromOrtTensor(initializer);
+        }
+        for (let i = 0; i < this._allData.length; i++) {
+          if (!this._allData[i].tensor) {
+            this._allInputIndices.push(i);
+            this._allInputNames.push(inputValueNames[i]);
+          }
+        }
+        for (let i = 0; i < graph.outputsLength(); i++) {
+          const outputName = graph.outputs(i);
+          if (dataIndices.has(outputName)) {
+            throw new Error(`duplicated output name: ${outputName}`);
+          }
+          const currentIndex = this._allData.push(new Value()) - 1;
+          dataIndices.set(outputName, currentIndex);
+          this._allOutputIndices.push(currentIndex);
+          this._allOutputNames.push(outputName);
+        }
+        if (!graph.nodes) {
+          throw new Error("missing information in graph: node");
+        }
+        for (let i = 0; i < graph.nodesLength(); i++) {
+          const nodeProto = graph.nodes(i);
+          let name2 = nodeProto.name();
+          if (!name2) {
+            for (let pick = 0; ; pick++) {
+              name2 = `unnamed_${nodeProto.opType()}_${pick}`;
+              if (!nodesIndices.has(name2)) {
+                break;
+              }
+            }
+          }
+          if (nodesIndices.has(name2)) {
+            throw new Error(`duplicated node name: ${name2}`);
+          }
+          const currentIndex = this._nodes.push(new Node2(nodeProto, name2)) - 1;
+          nodesIndices.set(name2, currentIndex);
+        }
+        for (let i = 0; i < this._nodes.length; i++) {
+          const node = this._nodes[i];
+          const nodeProto = graph.nodes(i);
+          if (nodeProto == null) {
+            throw new Error(`No node exists at index ${i}`);
+          }
+          if (nodeProto?.outputsLength() === 0) {
+            throw new Error(`missing output for node: ${nodeProto.name}`);
+          }
+          for (let j = 0; j < nodeProto?.outputsLength(); j++) {
+            const output = nodeProto?.outputs(j);
+            let dataIndex = dataIndices.get(output);
+            if (typeof dataIndex === "undefined") {
+              dataIndex = this._allData.push(new Value()) - 1;
+              dataIndices.set(output, dataIndex);
+            }
+            node.outputs.push(dataIndex);
+            if (this._allData[dataIndex]._from !== void 0) {
+              throw new Error(`multiple nodes output to one data value: ${dataIndex}`);
+            }
+            this._allData[dataIndex]._from = i;
+            if (nodeProto.opType() === "Constant") {
+              if (nodeProto.attributesLength() !== 1 || !nodeProto.attributes(0).t()) {
+                throw new Error("missing attributes or missing tensor value in attributes for this Constant operator");
+              }
+              if (nodeProto.outputsLength() !== 1) {
+                throw new Error("missing output or incorrect number of outputs for this Constant operator");
+              }
+              node.outputs.pop();
+              node.executeNode = false;
+              this._allData[dataIndex]._from = -1;
+              this._allData[dataIndex].tensor = Tensor4.fromOrtTensor(nodeProto.attributes(0).t());
+            }
+          }
+        }
+        for (let i = 0; i < this._nodes.length; i++) {
+          const node = this._nodes[i];
+          const nodeProto = graph.nodes(i);
+          if (nodeProto.inputsLength() === 0) {
+            throw new Error(`missing input for node: ${nodeProto.name}`);
+          }
+          for (let j = 0; j < nodeProto.inputsLength(); j++) {
+            const input = nodeProto.inputs(j);
+            const dataIndex = dataIndices.get(input);
+            if (typeof dataIndex === "undefined") {
+              throw new Error(`unrecognized input '${input}' for node: ${nodeProto.name()}`);
+            }
+            node.inputs.push(dataIndex);
+            this._allData[dataIndex]._to.push(i);
+          }
+        }
+      }
+      checkIsAcyclic() {
+        const starters = /* @__PURE__ */ new Set();
+        this._allInputIndices.forEach((i) => {
+          const data = this._allData[i];
+          data._to.forEach((j) => {
+            starters.add(j);
+          });
+        });
+        const nodesStack = Array.from(starters);
+        const nodesState = new Array(this._nodes.length).fill("white");
+        while (nodesStack.length > 0) {
+          const nodeIndex = nodesStack.pop();
+          if (nodesState[nodeIndex] === "gray") {
+            nodesState[nodeIndex] = "black";
+          } else {
+            nodesStack.push(nodeIndex);
+            nodesState[nodeIndex] = "gray";
+            this._nodes[nodeIndex].outputs.forEach((outgoingEdgeIndex) => {
+              const data = this._allData[outgoingEdgeIndex];
+              if (typeof data.tensor !== "undefined") {
+                throw new Error("node outputs should not be initialized");
+              }
+              if (data._from !== nodeIndex) {
+                throw new Error("from property of the Value object doesn't match index of Node being processed");
+              }
+              data._to.forEach((downstreamNodeIndex) => {
+                if (nodesState[downstreamNodeIndex] === "gray") {
+                  throw new Error("model graph is cyclic");
+                } else if (nodesState[downstreamNodeIndex] === "white") {
+                  nodesStack.push(downstreamNodeIndex);
+                }
+              });
+            });
+          }
+        }
+      }
+      transformGraph(graphInitializer) {
+        this.removeAllIdentityNodes();
+        this.removeAllDropoutNodes();
+        this.fuseConvActivationNodes();
+        if (graphInitializer) {
+          graphInitializer.transformGraph(this);
+        }
+        this.finalizeGraph();
+      }
+      /**
+       * finalize the graph.
+       *
+       * this function should be called after all the transformation completed.
+       * this function removes all unnecessary nodes and values from the graph
+       */
+      finalizeGraph() {
+        let offset = 0;
+        const newIndices = new Array(this._nodes.length, 0);
+        let nodePossition = 0;
+        for (let i = 0; i < this._nodes.length; i++) {
+          newIndices[i] = nodePossition;
+          if (this._nodes[i].executeNode) {
+            if (nodePossition !== i) {
+              this._nodes[nodePossition] = this._nodes[i];
+            }
+            nodePossition++;
+          } else {
+            this._nodes[i].outputs.forEach((ind) => {
+              this._allData[ind]._from = -2;
+            });
+          }
+        }
+        this._nodes.splice(nodePossition, this._nodes.length - nodePossition);
+        for (let i = 0; i < this._allData.length; i++) {
+          const currentData = this._allData[i];
+          if (currentData._from !== void 0 && currentData._from !== -1 && currentData._from !== -2) {
+            currentData._from = newIndices[currentData._from];
+          }
+          for (let j = 0; j < currentData._to.length; j++) {
+            if (currentData._to[j] >= 0) {
+              currentData._to[j] = newIndices[currentData._to[j]];
+            } else {
+              throw new Error("Trying to update a removed node");
+            }
+          }
+        }
+        offset = 0;
+        for (let i = 0; i < this._allData.length; i++) {
+          if (this._allData[i].from === -2 && this._allOutputIndices.indexOf(i + offset) === -1) {
+            offset++;
+            this._allData.splice(i, 1);
+            i--;
+            continue;
+          }
+          if (offset > 0) {
+            let ind = -1;
+            if (this._allData[i].from !== void 0 && this._allData[i].from !== -1) {
+              ind = this._nodes[this._allData[i].from].outputs.indexOf(i + offset);
+              if (ind !== -1) {
+                this._nodes[this._allData[i].from].outputs[ind] = i;
+              }
+            } else {
+              ind = this._allInputIndices.indexOf(i + offset);
+              if (ind !== -1) {
+                this._allInputIndices[ind] = i;
+              }
+            }
+            this._allData[i].to.forEach((node) => {
+              ind = this._nodes[node].inputs.indexOf(i + offset);
+              if (ind !== -1) {
+                this._nodes[node].inputs[ind] = i;
+              }
+            });
+            if (this._allData[i].to.length === 0) {
+              ind = this._allOutputIndices.indexOf(i + offset);
+              if (ind !== -1) {
+                this._allOutputIndices[ind] = i;
+              }
+            }
+          }
+        }
+      }
+      /**
+       * Delete the specified node. Assume the node has one incoming input and the first output connected to other nodes.
+       * An input validation must be done before calling this function.
+       * @param nodeIndex The index of node to be deleted
+       */
+      deleteNode(nodeIndex) {
+        const node = this._nodes[nodeIndex];
+        if (node.outputs.length > 1) {
+          for (let i = 1; i < node.outputs.length; i++) {
+            if (this._allData[node.outputs[i]].to.length > 0) {
+              throw new Error("Node deletion with more than one output connected to other nodes is not supported. ");
+            }
+          }
+        }
+        node.executeNode = false;
+        const inputValueIndex = node.inputs[0];
+        const outputValueIndex = node.outputs[0];
+        const nodesConsumingOutput = this._allData[outputValueIndex].to;
+        for (let i = 0; i < node.inputs.length; i++) {
+          const delIndex = this._allData[node.inputs[i]].to.indexOf(nodeIndex);
+          if (delIndex === -1) {
+            throw new Error("The Value object doesn't have the current Node in it's 'to' property ");
+          }
+          this._allData[node.inputs[i]].to.splice(delIndex, 1);
+        }
+        this._allData[outputValueIndex]._to = [];
+        const index = this._allOutputIndices.indexOf(outputValueIndex);
+        if (index !== -1) {
+          this._allOutputIndices[index] = inputValueIndex;
+        }
+        if (nodesConsumingOutput && nodesConsumingOutput.length > 0) {
+          for (const nodeIndex2 of nodesConsumingOutput) {
+            const replaceIndex = this._nodes[nodeIndex2].inputs.indexOf(outputValueIndex);
+            if (replaceIndex === -1) {
+              throw new Error("The Node object doesn't have the output Value in it's 'inputs' property ");
+            }
+            this._nodes[nodeIndex2].inputs[replaceIndex] = inputValueIndex;
+            this._allData[inputValueIndex].to.push(nodeIndex2);
+          }
+        }
+      }
+      removeAllDropoutNodes() {
+        let nodeIndex = 0;
+        for (const node of this._nodes) {
+          if (node.opType === "Dropout") {
+            if (node.inputs.length !== 1) {
+              throw new Error("Dropout nodes should only contain one input. ");
+            }
+            if (node.outputs.length !== 1 && node.outputs.length !== 2) {
+              throw new Error("Dropout nodes should contain either 1 or 2 output(s)");
+            }
+            if (node.outputs.length === 2 && this._allData[node.outputs[1]]._to.length !== 0) {
+              throw new Error("Dropout nodes's second output should not be referenced by other nodes");
+            }
+            this.deleteNode(nodeIndex);
+          }
+          nodeIndex++;
+        }
+      }
+      removeAllIdentityNodes() {
+        let nodeIndex = 0;
+        for (const node of this._nodes) {
+          if (node.opType === "Identity") {
+            this.deleteNode(nodeIndex);
+          }
+          nodeIndex++;
+        }
+      }
+      isActivation(n) {
+        switch (n.opType) {
+          // TODO: add other activation methods
+          case "Relu":
+          case "Sigmoid":
+          case "Clip":
+            return true;
+          default:
+            return false;
+        }
+      }
+      fuseConvActivationNodes() {
+        for (const node of this._nodes) {
+          if (node.opType === "Conv") {
+            const next = this._allData[node.outputs[0]]._to;
+            if (next.length === 1 && this.isActivation(this._nodes[next[0]])) {
+              const child = this._nodes[next[0]];
+              if (child.opType === "Clip") {
+                if (child.inputs.length === 1) {
+                  try {
+                    node.attributes.set("activation_params", "floats", [
+                      child.attributes.getFloat("min"),
+                      child.attributes.getFloat("max")
+                    ]);
+                  } catch {
+                    node.attributes.set("activation_params", "floats", [MIN_CLIP, MAX_CLIP]);
+                  }
+                } else if (child.inputs.length >= 3 && this._allData[child.inputs[1]].tensor !== void 0 && this._allData[child.inputs[2]].tensor !== void 0) {
+                  node.attributes.set("activation_params", "floats", [
+                    this._allData[child.inputs[1]].tensor.floatData[0],
+                    this._allData[child.inputs[2]].tensor.floatData[0]
+                  ]);
+                } else {
+                  continue;
+                }
+              }
+              node.attributes.set("activation", "string", child.opType);
+              this.deleteNode(next[0]);
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/model.ts
+var flatbuffers, import_onnx5, Model2;
+var init_model = __esm({
+  "web/lib/onnxjs/model.ts"() {
+    "use strict";
+    flatbuffers = __toESM(require_flatbuffers());
+    init_graph();
+    init_ort_generated();
+    import_onnx5 = __toESM(require_onnx());
+    init_util();
+    Model2 = class {
+      // empty model
+      constructor() {
+      }
+      load(buf, graphInitializer, isOrtFormat) {
+        let onnxError;
+        if (!isOrtFormat) {
+          try {
+            this.loadFromOnnxFormat(buf, graphInitializer);
+            return;
+          } catch (e) {
+            if (isOrtFormat !== void 0) {
+              throw e;
+            }
+            onnxError = e;
+          }
+        }
+        try {
+          this.loadFromOrtFormat(buf, graphInitializer);
+        } catch (e) {
+          if (isOrtFormat !== void 0) {
+            throw e;
+          }
+          throw new Error(`Failed to load model as ONNX format: ${onnxError}
+as ORT format: ${e}`);
+        }
+      }
+      loadFromOnnxFormat(buf, graphInitializer) {
+        const modelProto = import_onnx5.onnx.ModelProto.decode(buf);
+        const irVersion = LongUtil.longToNumber(modelProto.irVersion);
+        if (irVersion < 3) {
+          throw new Error("only support ONNX model with IR_VERSION>=3");
+        }
+        this._opsets = modelProto.opsetImport.map((i) => ({
+          domain: i.domain,
+          version: LongUtil.longToNumber(i.version)
+        }));
+        this._graph = Graph2.from(modelProto.graph, graphInitializer);
+      }
+      loadFromOrtFormat(buf, graphInitializer) {
+        const fb = new flatbuffers.ByteBuffer(buf);
+        const ortModel = import_inference_session.InferenceSession.getRootAsInferenceSession(fb).model();
+        const irVersion = LongUtil.longToNumber(ortModel.irVersion());
+        if (irVersion < 3) {
+          throw new Error("only support ONNX model with IR_VERSION>=3");
+        }
+        this._opsets = [];
+        for (let i = 0; i < ortModel.opsetImportLength(); i++) {
+          const opsetId = ortModel.opsetImport(i);
+          this._opsets.push({ domain: opsetId?.domain(), version: LongUtil.longToNumber(opsetId.version()) });
+        }
+        this._graph = Graph2.from(ortModel.graph(), graphInitializer);
+      }
+      get graph() {
+        return this._graph;
+      }
+      get opsets() {
+        return this._opsets;
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/session.ts
+var Session;
+var init_session = __esm({
+  "web/lib/onnxjs/session.ts"() {
+    "use strict";
+    init_backend2();
+    init_execution_plan();
+    init_instrument();
+    init_model();
+    Session = class {
+      constructor(config = {}) {
+        this._initialized = false;
+        this.backendHint = config.backendHint;
+        this.profiler = Profiler.create(config.profiler);
+        this.context = { profiler: this.profiler, graphInputTypes: [], graphInputDims: [] };
+      }
+      get inputNames() {
+        return this._model.graph.getInputNames();
+      }
+      get outputNames() {
+        return this._model.graph.getOutputNames();
+      }
+      startProfiling() {
+        this.profiler.start();
+      }
+      endProfiling() {
+        this.profiler.stop();
+      }
+      async loadModel(arg, byteOffset, length) {
+        await this.profiler.event("session", "Session.loadModel", async () => {
+          const backend2 = await resolveBackend(this.backendHint);
+          this.sessionHandler = backend2.createSessionHandler(this.context);
+          this._model = new Model2();
+          if (typeof arg === "string") {
+            const isOrtFormat = arg.endsWith(".ort");
+            if (false) {
+              const { readFile } = null;
+              const buf = await readFile(arg);
+              this.initialize(buf, isOrtFormat);
+            } else {
+              const response = await fetch(arg);
+              const buf = await response.arrayBuffer();
+              this.initialize(new Uint8Array(buf), isOrtFormat);
+            }
+          } else if (!ArrayBuffer.isView(arg)) {
+            const arr = new Uint8Array(arg, byteOffset || 0, length || arg.byteLength);
+            this.initialize(arr);
+          } else {
+            this.initialize(arg);
+          }
+        });
+      }
+      initialize(modelProtoBlob, isOrtFormat) {
+        if (this._initialized) {
+          throw new Error("already initialized");
+        }
+        this.profiler.event("session", "Session.initialize", () => {
+          const graphInitializer = this.sessionHandler.transformGraph ? this.sessionHandler : void 0;
+          this._model.load(modelProtoBlob, graphInitializer, isOrtFormat);
+          if (this.sessionHandler.onGraphInitialized) {
+            this.sessionHandler.onGraphInitialized(this._model.graph);
+          }
+          this.initializeOps(this._model.graph);
+          this._executionPlan = new ExecutionPlan(this._model.graph, this._ops, this.profiler);
+        });
+        this._initialized = true;
+      }
+      async run(inputs) {
+        if (!this._initialized) {
+          throw new Error("session not initialized yet");
+        }
+        return this.profiler.event("session", "Session.run", async () => {
+          const inputTensors = this.normalizeAndValidateInputs(inputs);
+          const outputTensors = await this._executionPlan.execute(this.sessionHandler, inputTensors);
+          return this.createOutput(outputTensors);
+        });
+      }
+      normalizeAndValidateInputs(inputs) {
+        const modelInputNames = this._model.graph.getInputNames();
+        if (Array.isArray(inputs)) {
+          if (inputs.length !== modelInputNames.length) {
+            throw new Error(`incorrect input array length: expected ${modelInputNames.length} but got ${inputs.length}`);
+          }
+        } else {
+          if (inputs.size !== modelInputNames.length) {
+            throw new Error(`incorrect input map size: expected ${modelInputNames.length} but got ${inputs.size}`);
+          }
+          const sortedInputs = new Array(inputs.size);
+          let sortedInputsIndex = 0;
+          for (let i = 0; i < modelInputNames.length; ++i) {
+            const tensor = inputs.get(modelInputNames[i]);
+            if (!tensor) {
+              throw new Error(`missing input tensor for: '${name}'`);
+            }
+            sortedInputs[sortedInputsIndex++] = tensor;
+          }
+          inputs = sortedInputs;
+        }
+        if (!this.context.graphInputTypes || this.context.graphInputTypes.length === 0 || !this.context.graphInputDims || this.context.graphInputDims.length === 0) {
+          const modelInputIndices = this._model.graph.getInputIndices();
+          const modelValues = this._model.graph.getValues();
+          const graphInputDims = new Array(modelInputIndices.length);
+          for (let i = 0; i < modelInputIndices.length; ++i) {
+            const graphInput = modelValues[modelInputIndices[i]];
+            graphInputDims[i] = graphInput.type.shape.dims;
+            this.context.graphInputTypes.push(graphInput.type.tensorType);
+            this.context.graphInputDims.push(inputs[i].dims);
+          }
+          this.validateInputTensorDims(graphInputDims, inputs, true);
+        } else {
+          this.validateInputTensorDims(this.context.graphInputDims, inputs, false);
+        }
+        this.validateInputTensorTypes(this.context.graphInputTypes, inputs);
+        return inputs;
+      }
+      validateInputTensorTypes(graphInputTypes, givenInputs) {
+        for (let i = 0; i < givenInputs.length; i++) {
+          const expectedType = graphInputTypes[i];
+          const actualType = givenInputs[i].type;
+          if (expectedType !== actualType) {
+            throw new Error(`input tensor[${i}] check failed: expected type '${expectedType}' but got ${actualType}`);
+          }
+        }
+      }
+      validateInputTensorDims(graphInputDims, givenInputs, noneDimSupported) {
+        for (let i = 0; i < givenInputs.length; i++) {
+          const expectedDims = graphInputDims[i];
+          const actualDims = givenInputs[i].dims;
+          if (!this.compareTensorDims(expectedDims, actualDims, noneDimSupported)) {
+            throw new Error(
+              `input tensor[${i}] check failed: expected shape '[${expectedDims.join(",")}]' but got [${actualDims.join(
+                ","
+              )}]`
+            );
+          }
+        }
+      }
+      compareTensorDims(expectedDims, actualDims, noneDimSupported) {
+        if (expectedDims.length !== actualDims.length) {
+          return false;
+        }
+        for (let i = 0; i < expectedDims.length; ++i) {
+          if (expectedDims[i] !== actualDims[i] && (!noneDimSupported || expectedDims[i] !== 0)) {
+            return false;
+          }
+        }
+        return true;
+      }
+      createOutput(outputTensors) {
+        const modelOutputNames = this._model.graph.getOutputNames();
+        if (outputTensors.length !== modelOutputNames.length) {
+          throw new Error("expected number of outputs do not match number of generated outputs");
+        }
+        const output = /* @__PURE__ */ new Map();
+        for (let i = 0; i < modelOutputNames.length; ++i) {
+          output.set(modelOutputNames[i], outputTensors[i]);
+        }
+        return output;
+      }
+      initializeOps(graph) {
+        const nodes = graph.getNodes();
+        this._ops = new Array(nodes.length);
+        for (let i = 0; i < nodes.length; i++) {
+          this._ops[i] = this.sessionHandler.resolve(nodes[i], this._model.opsets, graph);
+        }
+      }
+    };
+  }
+});
+
+// web/lib/onnxjs/session-handler-inference.ts
+var OnnxjsSessionHandler;
+var init_session_handler_inference = __esm({
+  "web/lib/onnxjs/session-handler-inference.ts"() {
+    "use strict";
+    init_esm();
+    init_tensor2();
+    OnnxjsSessionHandler = class {
+      constructor(session) {
+        this.session = session;
+        this.inputNames = this.session.inputNames;
+        this.outputNames = this.session.outputNames;
+      }
+      get inputMetadata() {
+        throw new Error("Getting model metadata is not supported in webgl backend.");
+      }
+      get outputMetadata() {
+        throw new Error("Getting model metadata is not supported in webgl backend.");
+      }
+      async dispose() {
+      }
+      async run(feeds, _fetches, _options) {
+        const inputMap = /* @__PURE__ */ new Map();
+        for (const name2 in feeds) {
+          if (Object.hasOwnProperty.call(feeds, name2)) {
+            const feed = feeds[name2];
+            inputMap.set(
+              name2,
+              new Tensor4(
+                feed.dims,
+                feed.type,
+                void 0,
+                void 0,
+                feed.data
+              )
+            );
+          }
+        }
+        const outputMap = await this.session.run(inputMap);
+        const output = {};
+        outputMap.forEach((tensor, name2) => {
+          output[name2] = new Tensor2(tensor.type, tensor.data, tensor.dims);
+        });
+        return output;
+      }
+      startProfiling() {
+        this.session.startProfiling();
+      }
+      endProfiling() {
+        this.session.endProfiling();
+      }
+    };
+  }
+});
+
+// web/lib/backend-onnxjs.ts
+var backend_onnxjs_exports = {};
+__export(backend_onnxjs_exports, {
+  onnxjsBackend: () => onnxjsBackend
+});
+var OnnxjsBackend, onnxjsBackend;
+var init_backend_onnxjs = __esm({
+  "web/lib/backend-onnxjs.ts"() {
+    "use strict";
+    init_session();
+    init_session_handler_inference();
+    OnnxjsBackend = class {
+      // eslint-disable-next-line @typescript-eslint/no-empty-function
+      async init() {
+      }
+      async createInferenceSessionHandler(pathOrBuffer, options) {
+        const session = new Session(options);
+        if (typeof pathOrBuffer === "string") {
+          await session.loadModel(pathOrBuffer);
+        } else {
+          await session.loadModel(pathOrBuffer);
+        }
+        return new OnnxjsSessionHandler(session);
+      }
+    };
+    onnxjsBackend = new OnnxjsBackend();
+  }
+});
+
+// web/lib/index.ts
+init_esm();
+init_esm();
+init_esm();
+
+// web/lib/version.ts
+var version2 = "1.30.0";
+
+// web/lib/index.ts
+var index_default = esm_exports;
+if (true) {
+  const onnxjsBackend2 = (init_backend_onnxjs(), __toCommonJS(backend_onnxjs_exports)).onnxjsBackend;
+  registerBackend("webgl", onnxjsBackend2, -10);
+}
+if (false) {
+  throw new Error(
+    "The current build is specified to enable both JSEP and WebGPU EP. This is not a valid configuration. JSEP and WebGPU EPs cannot be enabled at the same time."
+  );
+}
+if (false) {
+  throw new Error(
+    "The current build is specified to enable WebNN EP without JSEP or WebGPU EP. This is not a valid configuration. WebNN EP requires either JSEP or WebGPU EP to be enabled."
+  );
+}
+if (false) {
+  const wasmBackend = null.wasmBackend;
+  if (false) {
+    registerBackend("webgpu", wasmBackend, 5);
+  }
+  if (false) {
+    registerBackend("webnn", wasmBackend, 5);
+  }
+  registerBackend("cpu", wasmBackend, 10);
+  registerBackend("wasm", wasmBackend, 10);
+}
+Object.defineProperty(env2.versions, "web", { value: version2, enumerable: true });
+export {
+  InferenceSession2 as InferenceSession,
+  TRACE,
+  TRACE_EVENT_BEGIN,
+  TRACE_EVENT_END,
+  TRACE_FUNC_BEGIN,
+  TRACE_FUNC_END,
+  Tensor2 as Tensor,
+  index_default as default,
+  env2 as env,
+  registerBackend
+};
+/*! Bundled license information:
+
+long/index.js:
+long/umd/index.js:
+  (**
+   * @license
+   * Copyright 2009 The Closure Library Authors
+   * Copyright 2020 Daniel Wirtz / The long.js Authors.
+   *
+   * Licensed under the Apache License, Version 2.0 (the "License");
+   * you may not use this file except in compliance with the License.
+   * You may obtain a copy of the License at
+   *
+   *     http://www.apache.org/licenses/LICENSE-2.0
+   *
+   * Unless required by applicable law or agreed to in writing, software
+   * distributed under the License is distributed on an "AS IS" BASIS,
+   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   * See the License for the specific language governing permissions and
+   * limitations under the License.
+   *
+   * SPDX-License-Identifier: Apache-2.0
+   *)
+*/
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../common/lib/backend-impl.ts", "../../common/lib/backend.ts", "../../common/lib/version.ts", "../../common/lib/env-impl.ts", "../../common/lib/env.ts", "../../common/lib/tensor-conversion-impl.ts", "../../common/lib/tensor-factory-impl.ts", "../../common/lib/tensor-impl-type-mapping.ts", "../../common/lib/tensor-utils-impl.ts", "../../common/lib/tensor-impl.ts", "../../common/lib/tensor.ts", "../../common/lib/trace.ts", "../../common/lib/inference-session-impl.ts", "../../common/lib/inference-session.ts", "../../common/lib/tensor-conversion.ts", "../../common/lib/tensor-factory.ts", "../../common/lib/onnx-model.ts", "../../common/lib/onnx-value.ts", "../../common/lib/index.ts", "../lib/onnxjs/instrument.ts", "../lib/onnxjs/opset.ts", "../node_modules/guid-typescript/dist/guid.js", "../node_modules/long/index.js", "../lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/arg-type.ts", "../node_modules/flatbuffers/js/constants.js", "../node_modules/flatbuffers/js/utils.js", "../node_modules/flatbuffers/js/encoding.js", "../node_modules/flatbuffers/js/byte-buffer.js", "../node_modules/flatbuffers/js/builder.js", "../node_modules/flatbuffers/js/flatbuffers.js", "../lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/arg-type-and-index.ts", "../lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/attribute-type.ts", "../lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/node-type.ts", "../lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/node.ts", "../lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/edge-end.ts", "../lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/node-edge.ts", "../lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/nodes-to-optimize-indices.ts", "../lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/runtime-optimization-record.ts", "../lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/runtime-optimization-record-container-entry.ts", "../lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/runtime-optimizations.ts", "../lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/tensor-data-type.ts", "../lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/tensor.ts", "../lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/sparse-tensor.ts", "../lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/map-type.ts", "../lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/sequence-type.ts", "../lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/dimension-value-type.ts", "../lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/dimension-value.ts", "../lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/dimension.ts", "../lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/shape.ts", "../lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/tensor-type-and-shape.ts", "../lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/type-info-value.ts", "../lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/type-info.ts", "../lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/value-info.ts", "../lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/graph.ts", "../lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/attribute.ts", "../lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/deprecated-kernel-create-infos.ts", "../lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/deprecated-node-index-and-kernel-def-hash.ts", "../lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/deprecated-sub-graph-session-state.ts", "../lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/deprecated-session-state.ts", "../lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/kernel-type-str-args-entry.ts", "../lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/op-id-kernel-type-str-args-entry.ts", "../lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/kernel-type-str-resolver.ts", "../lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/operator-set-id.ts", "../lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/string-string-entry.ts", "../lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/model.ts", "../lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs/inference-session.ts", "../lib/onnxjs/ort-schema/flatbuffers/onnxruntime/fbs.ts", "../lib/onnxjs/ort-schema/flatbuffers/ort-generated.ts", "../node_modules/@protobufjs/aspromise/index.js", "../node_modules/@protobufjs/base64/index.js", "../node_modules/@protobufjs/eventemitter/index.js", "../node_modules/@protobufjs/float/index.js", "../node_modules/@protobufjs/inquire/index.js", "../node_modules/@protobufjs/utf8/index.js", "../node_modules/@protobufjs/pool/index.js", "../node_modules/protobufjs/src/util/longbits.js", "../node_modules/long/umd/index.js", "../node_modules/protobufjs/src/util/minimal.js", "../node_modules/protobufjs/src/writer.js", "../node_modules/protobufjs/src/writer_buffer.js", "../node_modules/protobufjs/src/reader.js", "../node_modules/protobufjs/src/reader_buffer.js", "../node_modules/protobufjs/src/rpc/service.js", "../node_modules/protobufjs/src/rpc.js", "../node_modules/protobufjs/src/roots.js", "../node_modules/protobufjs/src/index-minimal.js", "../node_modules/protobufjs/minimal.js", "../lib/onnxjs/ort-schema/protobuf/onnx.js", "../lib/onnxjs/util.ts", "../lib/onnxjs/tensor.ts", "../lib/onnxjs/backends/webgl/glsl-source.ts", "../lib/onnxjs/backends/webgl/types.ts", "../lib/onnxjs/backends/webgl/utils.ts", "../lib/onnxjs/backends/webgl/ops/packing-utils.ts", "../lib/onnxjs/backends/webgl/ops/pack.ts", "../lib/onnxjs/backends/webgl/ops/reshape-packed.ts", "../lib/onnxjs/backends/webgl/ops/uint8-encode.ts", "../lib/onnxjs/backends/webgl/ops/unpack.ts", "../lib/onnxjs/backends/webgl/texture-data-encoder.ts", "../lib/onnxjs/backends/webgl/texture-layout.ts", "../lib/onnxjs/backends/webgl/inference-handler.ts", "../lib/onnxjs/attribute-with-cache-key.ts", "../lib/onnxjs/backends/webgl/ops/batch-normalization.ts", "../lib/onnxjs/backends/webgl/glsl-definitions.ts", "../lib/onnxjs/backends/webgl/ops/binary-op.ts", "../lib/onnxjs/backends/webgl/ops/cast.ts", "../lib/onnxjs/backends/webgl/ops/concat-packed.ts", "../lib/onnxjs/backends/webgl/ops/concat.ts", "../lib/onnxjs/backends/webgl/ops/unary-op.ts", "../lib/onnxjs/backends/webgl/ops/fuse-utils.ts", "../lib/onnxjs/backends/webgl/ops/conv-grouped.ts", "../lib/onnxjs/backends/webgl/ops/im2col-pack.ts", "../lib/onnxjs/backends/webgl/ops/matmul.ts", "../lib/onnxjs/backends/webgl/ops/matmul-pack.ts", "../lib/onnxjs/backends/webgl/ops/conv-pack.ts", "../lib/onnxjs/backends/webgl/ops/im2col.ts", "../lib/onnxjs/backends/webgl/ops/dot-product.ts", "../lib/onnxjs/backends/webgl/ops/conv.ts", "../lib/onnxjs/backends/webgl/ops/conv-transpose.ts", "../lib/onnxjs/backends/webgl/ops/transpose.ts", "../lib/onnxjs/backends/webgl/ops/depth-to-space.ts", "../lib/onnxjs/backends/webgl/ops/flatten.ts", "../lib/onnxjs/operators.ts", "../lib/onnxjs/backends/webgl/ops/gather.ts", "../lib/onnxjs/backends/webgl/ops/gemm.ts", "../lib/onnxjs/backends/webgl/ops/image-scaler.ts", "../lib/onnxjs/backends/webgl/ops/instance-normalization.ts", "../lib/onnxjs/backends/webgl/ops/lrn.ts", "../lib/onnxjs/backends/webgl/ops/pad.ts", "../lib/onnxjs/backends/webgl/ops/pool.ts", "../lib/onnxjs/backends/webgl/ops/reduce.ts", "../lib/onnxjs/backends/webgl/ops/reshape.ts", "../lib/onnxjs/backends/webgl/ops/upsample.ts", "../lib/onnxjs/backends/webgl/ops/resize-packed.ts", "../lib/onnxjs/backends/webgl/ops/shape.ts", "../lib/onnxjs/backends/webgl/ops/slice.ts", "../lib/onnxjs/backends/webgl/ops/softmax.ts", "../lib/onnxjs/backends/webgl/ops/split.ts", "../lib/onnxjs/backends/webgl/ops/squeeze.ts", "../lib/onnxjs/backends/webgl/ops/sum.ts", "../lib/onnxjs/backends/webgl/ops/tile.ts", "../lib/onnxjs/backends/webgl/ops/unsqueeze.ts", "../lib/onnxjs/backends/webgl/op-resolve-rules.ts", "../lib/onnxjs/backends/webgl/glsl-function-inliner.ts", "../lib/onnxjs/backends/webgl/texture-layout-strategy.ts", "../lib/onnxjs/backends/webgl/glsl-coordinate-lib.ts", "../lib/onnxjs/backends/webgl/glsl-encoding-lib.ts", "../lib/onnxjs/backends/webgl/glsl-fragcolor-lib.ts", "../lib/onnxjs/backends/webgl/glsl-shape-utils-lib.ts", "../lib/onnxjs/backends/webgl/glsl-vec-lib.ts", "../lib/onnxjs/backends/webgl/glsl-registered-libs.ts", "../lib/onnxjs/backends/webgl/glsl-preprocessor.ts", "../lib/onnxjs/backends/webgl/program-manager.ts", "../lib/onnxjs/backends/webgl/texture-manager.ts", "../lib/onnxjs/backends/webgl/session-handler.ts", "../lib/onnxjs/backends/webgl/webgl-context.ts", "../lib/onnxjs/backends/webgl/webgl-context-factory.ts", "../lib/onnxjs/backends/backend-webgl.ts", "../lib/onnxjs/backend.ts", "../lib/onnxjs/execution-plan.ts", "../lib/onnxjs/attribute.ts", "../lib/onnxjs/graph.ts", "../lib/onnxjs/model.ts", "../lib/onnxjs/session.ts", "../lib/onnxjs/session-handler-inference.ts", "../lib/backend-onnxjs.ts", "../lib/index.ts", "../lib/version.ts"],
  "sourcesContent": ["// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Backend } from './backend.js';\nimport { InferenceSession } from './inference-session.js';\n\ninterface BackendInfo {\n  backend: Backend;\n  priority: number;\n\n  initPromise?: Promise<void>;\n  initialized?: boolean;\n  aborted?: boolean;\n  error?: string;\n}\n\nconst backends: Map<string, BackendInfo> = new Map();\nconst backendsSortedByPriority: string[] = [];\n\n/**\n * Register a backend.\n *\n * @param name - the name as a key to lookup as an execution provider.\n * @param backend - the backend object.\n * @param priority - an integer indicating the priority of the backend. Higher number means higher priority. if priority\n * < 0, it will be considered as a 'beta' version and will not be used as a fallback backend by default.\n *\n * @ignore\n */\nexport const registerBackend = (name: string, backend: Backend, priority: number): void => {\n  if (backend && typeof backend.init === 'function' && typeof backend.createInferenceSessionHandler === 'function') {\n    const currentBackend = backends.get(name);\n    if (currentBackend === undefined) {\n      backends.set(name, { backend, priority });\n    } else if (currentBackend.priority > priority) {\n      // same name is already registered with a higher priority. skip registeration.\n      return;\n    } else if (currentBackend.priority === priority) {\n      if (currentBackend.backend !== backend) {\n        throw new Error(`cannot register backend \"${name}\" using priority ${priority}`);\n      }\n    }\n\n    if (priority >= 0) {\n      const i = backendsSortedByPriority.indexOf(name);\n      if (i !== -1) {\n        backendsSortedByPriority.splice(i, 1);\n      }\n\n      for (let i = 0; i < backendsSortedByPriority.length; i++) {\n        if (backends.get(backendsSortedByPriority[i])!.priority <= priority) {\n          backendsSortedByPriority.splice(i, 0, name);\n          return;\n        }\n      }\n      backendsSortedByPriority.push(name);\n    }\n    return;\n  }\n\n  throw new TypeError('not a valid backend');\n};\n\n/**\n * Try to resolve and initialize a backend.\n *\n * @param backendName - the name of the backend.\n * @returns the backend instance if resolved and initialized successfully, or an error message if failed.\n */\nconst tryResolveAndInitializeBackend = async (backendName: string): Promise<Backend | string> => {\n  const backendInfo = backends.get(backendName);\n  if (!backendInfo) {\n    return 'backend not found.';\n  }\n\n  if (backendInfo.initialized) {\n    return backendInfo.backend;\n  } else if (backendInfo.aborted) {\n    return backendInfo.error!;\n  } else {\n    const isInitializing = !!backendInfo.initPromise;\n    try {\n      if (!isInitializing) {\n        backendInfo.initPromise = backendInfo.backend.init(backendName);\n      }\n      await backendInfo.initPromise;\n      backendInfo.initialized = true;\n      return backendInfo.backend;\n    } catch (e) {\n      if (!isInitializing) {\n        backendInfo.error = `${e}`;\n        backendInfo.aborted = true;\n      }\n      return backendInfo.error!;\n    } finally {\n      delete backendInfo.initPromise;\n    }\n  }\n};\n\n/**\n * Resolve execution providers from the specific session options.\n *\n * @param options - the session options object.\n * @returns a promise that resolves to a tuple of an initialized backend instance and a session options object with\n * filtered EP list.\n *\n * @ignore\n */\nexport const resolveBackendAndExecutionProviders = async (\n  options: InferenceSession.SessionOptions,\n): Promise<[backend: Backend, options: InferenceSession.SessionOptions]> => {\n  // extract backend hints from session options\n  const eps = options.executionProviders || [];\n  const backendHints = eps.map((i) => (typeof i === 'string' ? i : i.name));\n  const backendNames = backendHints.length === 0 ? backendsSortedByPriority : backendHints;\n\n  // try to resolve and initialize all requested backends\n  let backend: Backend | undefined;\n  const errors = [];\n  const availableBackendNames = new Set<string>();\n  for (const backendName of backendNames) {\n    const resolveResult = await tryResolveAndInitializeBackend(backendName);\n    if (typeof resolveResult === 'string') {\n      errors.push({ name: backendName, err: resolveResult });\n    } else {\n      if (!backend) {\n        backend = resolveResult;\n      }\n      if (backend === resolveResult) {\n        availableBackendNames.add(backendName);\n      }\n    }\n  }\n\n  // if no backend is available, throw error.\n  if (!backend) {\n    throw new Error(`no available backend found. ERR: ${errors.map((e) => `[${e.name}] ${e.err}`).join(', ')}`);\n  }\n\n  // for each explicitly requested backend, if it's not available, output warning message.\n  for (const { name, err } of errors) {\n    if (backendHints.includes(name)) {\n      // eslint-disable-next-line no-console\n      console.warn(\n        `removing requested execution provider \"${name}\" from session options because it is not available: ${err}`,\n      );\n    }\n  }\n\n  const filteredEps = eps.filter((i) => availableBackendNames.has(typeof i === 'string' ? i : i.name));\n\n  return [\n    backend,\n    new Proxy(options, {\n      get: (target, prop) => {\n        if (prop === 'executionProviders') {\n          return filteredEps;\n        }\n        return Reflect.get(target, prop);\n      },\n    }),\n  ];\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { InferenceSession } from './inference-session.js';\nimport { OnnxValue } from './onnx-value.js';\n\n/**\n * @ignore\n */\nexport declare namespace SessionHandler {\n  type FeedsType = { [name: string]: OnnxValue };\n  type FetchesType = { [name: string]: OnnxValue | null };\n  type ReturnType = { [name: string]: OnnxValue };\n}\n\n/**\n * Represents shared SessionHandler functionality\n *\n * @ignore\n */\ninterface SessionHandler {\n  dispose(): Promise<void>;\n\n  readonly inputNames: readonly string[];\n  readonly outputNames: readonly string[];\n\n  readonly inputMetadata: readonly InferenceSession.ValueMetadata[];\n  readonly outputMetadata: readonly InferenceSession.ValueMetadata[];\n}\n\n/**\n * Represent a handler instance of an inference session.\n *\n * @ignore\n */\nexport interface InferenceSessionHandler extends SessionHandler {\n  startProfiling(): void;\n  endProfiling(): void;\n\n  run(\n    feeds: SessionHandler.FeedsType,\n    fetches: SessionHandler.FetchesType,\n    options: InferenceSession.RunOptions,\n  ): Promise<SessionHandler.ReturnType>;\n}\n\n/**\n * Represent a backend that provides implementation of model inferencing.\n *\n * @ignore\n */\nexport interface Backend {\n  /**\n   * Initialize the backend asynchronously. Should throw when failed.\n   */\n  init(backendName: string): Promise<void>;\n\n  createInferenceSessionHandler(\n    uriOrBuffer: string | Uint8Array,\n    options?: InferenceSession.SessionOptions,\n  ): Promise<InferenceSessionHandler>;\n}\n\nexport { registerBackend } from './backend-impl.js';\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n// This file is generated by /js/scripts/update-version.ts\n// Do not modify file content manually.\n\nexport const version = '1.30.0';\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Env } from './env.js';\nimport { version } from './version.js';\n\ntype LogLevelType = Env['logLevel'];\n\nlet logLevelValue: Required<LogLevelType> = 'warning';\n\nexport const env: Env = {\n  wasm: {},\n  webgl: {} as Env.WebGLFlags,\n  webgpu: {} as Env.WebGpuFlags,\n  versions: { common: version },\n\n  set logLevel(value: LogLevelType) {\n    if (value === undefined) {\n      return;\n    }\n    if (typeof value !== 'string' || ['verbose', 'info', 'warning', 'error', 'fatal'].indexOf(value) === -1) {\n      throw new Error(`Unsupported logging level: ${value}`);\n    }\n    logLevelValue = value;\n  },\n  get logLevel(): Required<LogLevelType> {\n    return logLevelValue;\n  },\n};\n\n// set property 'logLevel' so that they can be correctly transferred to worker by `postMessage()`.\nObject.defineProperty(env, 'logLevel', { enumerable: true });\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { env as envImpl } from './env-impl.js';\nimport { TryGetGlobalType } from './type-helper.js';\n\nexport declare namespace Env {\n  export type WasmPathPrefix = string;\n  export interface WasmFilePaths {\n    /**\n     * Specify the override path for the main .wasm file.\n     *\n     * This path should be an absolute path.\n     *\n     * If not modified, the filename of the .wasm file is:\n     * - `ort-wasm-simd-threaded.wasm` for default build\n     * - `ort-wasm-simd-threaded.jsep.wasm` for JSEP build (with WebGPU and WebNN)\n     * - `ort-wasm-simd-threaded.asyncify.wasm` for WebGPU build with Asyncify (with WebNN)\n     * - `ort-wasm-simd-threaded.jspi.wasm` for WebGPU build with JSPI support (with WebNN)\n     */\n    wasm?: URL | string;\n    /**\n     * Specify the override path for the main .mjs file.\n     *\n     * This path should be an absolute path.\n     *\n     * If not modified, the filename of the .mjs file is:\n     * - `ort-wasm-simd-threaded.mjs` for default build\n     * - `ort-wasm-simd-threaded.jsep.mjs` for JSEP build (with WebGPU and WebNN)\n     * - `ort-wasm-simd-threaded.asyncify.mjs` for WebGPU build with Asyncify (with WebNN)\n     * - `ort-wasm-simd-threaded.jspi.mjs` for WebGPU build with JSPI support (with WebNN)\n     */\n    mjs?: URL | string;\n  }\n  export type WasmPrefixOrFilePaths = WasmPathPrefix | WasmFilePaths;\n  export interface WebAssemblyFlags {\n    /**\n     * set or get number of thread(s). If omitted or set to 0, number of thread(s) will be determined by system. If set\n     * to 1, no worker thread will be spawned.\n     *\n     * This setting is available only when WebAssembly multithread feature is available in current context.\n     *\n     * @defaultValue `0`\n     */\n    numThreads?: number;\n\n    /**\n     * set a value indicating whether to enable SIMD.\n     *\n     * ONNX Runtime will perform feature detection based on the value of this property. Specifically, when the value is\n     * set to:\n     * - `undefined`, `true` or `\"fixed\"`: will check availability of Fixed-width SIMD.\n     * - `\"relaxed\"`: will check availability of Relaxed SIMD.\n     * - `false`: will not perform SIMD feature checking.\n     *\n     * Setting this property does not make ONNX Runtime to switch to the corresponding runtime automatically. User need\n     * to set `wasmPaths` or `wasmBinary` property to load the corresponding runtime.\n     *\n     * This setting is available only when WebAssembly SIMD feature is available in current context.\n     *\n     * @defaultValue `true`\n     */\n    simd?: boolean | 'fixed' | 'relaxed';\n\n    /**\n     * set or get a boolean value indicating whether to enable trace.\n     *\n     * @defaultValue `false`\n     *\n     * @deprecated Use `env.trace` instead. If `env.trace` is set, this property will be ignored.\n     */\n    trace?: boolean;\n\n    /**\n     * Set or get a number specifying the timeout for initialization of WebAssembly backend, in milliseconds. A zero\n     * value indicates no timeout is set.\n     *\n     * @defaultValue `0`\n     */\n    initTimeout?: number;\n\n    /**\n     * Set a custom URL prefix to the .wasm/.mjs files, or an object of overrides for both .wasm/.mjs file. The override\n     * path should be an absolute path.\n     */\n    wasmPaths?: WasmPrefixOrFilePaths;\n\n    /**\n     * Set a custom buffer which contains the WebAssembly binary. If this property is set, the `wasmPaths` property will\n     * be ignored.\n     */\n    wasmBinary?: ArrayBufferLike | Uint8Array;\n\n    /**\n     * Set or get a boolean value indicating whether to proxy the execution of main thread to a worker thread.\n     *\n     * @defaultValue `false`\n     */\n    proxy?: boolean;\n  }\n\n  export interface WebGLFlags {\n    /**\n     * Set or get the WebGL Context ID (webgl or webgl2).\n     *\n     * @defaultValue `'webgl2'`\n     */\n    contextId?: 'webgl' | 'webgl2';\n    /**\n     * Get the WebGL rendering context.\n     */\n    readonly context: WebGLRenderingContext;\n    /**\n     * Set or get the maximum batch size for matmul. 0 means to disable batching.\n     *\n     * @deprecated\n     */\n    matmulMaxBatchSize?: number;\n    /**\n     * Set or get the texture cache mode.\n     *\n     * @defaultValue `'full'`\n     */\n    textureCacheMode?: 'initializerOnly' | 'full';\n    /**\n     * Set or get the packed texture mode\n     *\n     * @defaultValue `false`\n     */\n    pack?: boolean;\n    /**\n     * Set or get whether enable async download.\n     *\n     * @defaultValue `false`\n     */\n    async?: boolean;\n  }\n\n  export interface WebGpuProfilingDataV1TensorMetadata {\n    dims: readonly number[];\n    dataType: string;\n  }\n  export interface WebGpuProfilingDataV1 {\n    version: 1;\n    inputsMetadata: readonly WebGpuProfilingDataV1TensorMetadata[];\n    outputsMetadata: readonly WebGpuProfilingDataV1TensorMetadata[];\n    kernelId: number;\n    kernelType: string;\n    kernelName: string;\n    programName: string;\n    startTime: number;\n    endTime: number;\n  }\n\n  export type WebGpuProfilingData = WebGpuProfilingDataV1;\n\n  export interface WebGpuFlags {\n    /**\n     * Set or get the profiling mode.\n     *\n     * @deprecated Use `env.webgpu.profiling.mode` instead. If `env.webgpu.profiling.mode` is set, this property will be\n     * ignored.\n     */\n    profilingMode?: 'off' | 'default';\n    /**\n     * Set or get the profiling configuration.\n     */\n    profiling: {\n      /**\n       * Set or get the profiling mode.\n       *\n       * @defaultValue `'off'`\n       */\n      mode?: 'off' | 'default';\n\n      /**\n       * Set or get a callback function when a profiling data is received. If not set, the profiling data will be\n       * printed to console.\n       */\n      ondata?: (data: WebGpuProfilingData) => void;\n    };\n    /**\n     * Set or get the power preference.\n     *\n     * Setting this property only has effect before the first WebGPU inference session is created. The value will be\n     * used as options for `navigator.gpu.requestAdapter()`.\n     *\n     * See {@link https://gpuweb.github.io/gpuweb/#dictdef-gpurequestadapteroptions} for more details.\n     *\n     * @defaultValue `undefined`\n     *\n     * @deprecated Create your own GPUAdapter, use it to create a GPUDevice instance and set {@link device} property if\n     * you want to use a specific power preference.\n     */\n    powerPreference?: 'low-power' | 'high-performance';\n    /**\n     * Set or get the force fallback adapter flag.\n     *\n     * Setting this property only has effect before the first WebGPU inference session is created. The value will be\n     * used as options for `navigator.gpu.requestAdapter()`.\n     *\n     * See {@link https://gpuweb.github.io/gpuweb/#dictdef-gpurequestadapteroptions} for more details.\n     *\n     * @defaultValue `undefined`\n     *\n     * @deprecated Create your own GPUAdapter, use it to create a GPUDevice instance and set {@link device} property if\n     * you want to use a specific fallback option.\n     */\n    forceFallbackAdapter?: boolean;\n    /**\n     * Set or get the adapter for WebGPU.\n     *\n     * Setting this property only has effect before the first WebGPU inference session is created. The value will be\n     * used as the GPU adapter for the underlying WebGPU backend to create GPU device.\n     *\n     * If this property is not set, it will be available to get after the first WebGPU inference session is created. The\n     * value will be the GPU adapter that created by the underlying WebGPU backend.\n     *\n     * When use with TypeScript, the type of this property is `GPUAdapter` defined in \"@webgpu/types\".\n     *\n     * @deprecated It is no longer recommended to use this property. The latest WebGPU spec adds `GPUDevice.adapterInfo`\n     * (https://www.w3.org/TR/webgpu/#dom-gpudevice-adapterinfo), which allows to get the adapter information from the\n     * device. When it's available, there is no need to set/get the {@link adapter} property.\n     */\n    adapter: TryGetGlobalType<'GPUAdapter'>;\n    /**\n     * Set or get the GPU device for WebGPU.\n     *\n     * There are 3 valid scenarios of accessing this property:\n     * - Set a value before the first WebGPU inference session is created. The value will be used by the WebGPU backend\n     * to perform calculations. If the value is not a `GPUDevice` object, an error will be thrown.\n     * - Get the value before the first WebGPU inference session is created. This will try to create a new GPUDevice\n     * instance. Returns a `Promise` that resolves to a `GPUDevice` object.\n     * - Get the value after the first WebGPU inference session is created. Returns a resolved `Promise` to the\n     * `GPUDevice` object used by the WebGPU backend.\n     */\n    get device(): Promise<TryGetGlobalType<'GPUDevice'>>;\n    set device(value: TryGetGlobalType<'GPUDevice'>);\n    /**\n     * Set or get whether validate input content.\n     *\n     * @defaultValue `false`\n     */\n    validateInputContent?: boolean;\n  }\n}\n\nexport interface Env {\n  /**\n   * set the severity level for logging.\n   *\n   * @defaultValue `'warning'`\n   */\n  logLevel?: 'verbose' | 'info' | 'warning' | 'error' | 'fatal';\n\n  /**\n   * Indicate whether run in debug mode.\n   *\n   * @defaultValue `false`\n   */\n  debug?: boolean;\n\n  /**\n   * set or get a boolean value indicating whether to enable trace.\n   *\n   * @defaultValue `false`\n   */\n  trace?: boolean;\n\n  /**\n   * Get version of the current package.\n   */\n  readonly versions: {\n    readonly common: string;\n    readonly web?: string;\n    readonly node?: string;\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    readonly 'react-native'?: string;\n  };\n\n  /**\n   * Represent a set of flags for WebAssembly\n   */\n  readonly wasm: Env.WebAssemblyFlags;\n\n  /**\n   * Represent a set of flags for WebGL\n   */\n  readonly webgl: Env.WebGLFlags;\n\n  /**\n   * Represent a set of flags for WebGPU\n   */\n  readonly webgpu: Env.WebGpuFlags;\n\n  [name: string]: unknown;\n}\n\n/**\n * Represent a set of flags as a global singleton.\n */\nexport const env: Env = envImpl;\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { TensorToDataUrlOptions, TensorToImageDataOptions } from './tensor-conversion.js';\nimport { Tensor } from './tensor.js';\n\n/**\n * implementation of Tensor.toDataURL()\n */\nexport const tensorToDataURL = (tensor: Tensor, options?: TensorToDataUrlOptions): string => {\n  const canvas = typeof document !== 'undefined' ? document.createElement('canvas') : new OffscreenCanvas(1, 1);\n  canvas.width = tensor.dims[3];\n  canvas.height = tensor.dims[2];\n  const pixels2DContext = canvas.getContext('2d') as\n    | CanvasRenderingContext2D\n    | OffscreenCanvasRenderingContext2D\n    | null;\n\n  if (pixels2DContext != null) {\n    // Default values for height and width & format\n    let width: number;\n    let height: number;\n    if (options?.tensorLayout !== undefined && options.tensorLayout === 'NHWC') {\n      width = tensor.dims[2];\n      height = tensor.dims[3];\n    } else {\n      // Default layout is NCWH\n      width = tensor.dims[3];\n      height = tensor.dims[2];\n    }\n\n    const inputformat = options?.format !== undefined ? options.format : 'RGB';\n\n    const norm = options?.norm;\n    let normMean: [number, number, number, number];\n    let normBias: [number, number, number, number];\n    if (norm === undefined || norm.mean === undefined) {\n      normMean = [255, 255, 255, 255];\n    } else {\n      if (typeof norm.mean === 'number') {\n        normMean = [norm.mean, norm.mean, norm.mean, norm.mean];\n      } else {\n        normMean = [norm.mean[0], norm.mean[1], norm.mean[2], 0];\n        if (norm.mean[3] !== undefined) {\n          normMean[3] = norm.mean[3];\n        }\n      }\n    }\n    if (norm === undefined || norm.bias === undefined) {\n      normBias = [0, 0, 0, 0];\n    } else {\n      if (typeof norm.bias === 'number') {\n        normBias = [norm.bias, norm.bias, norm.bias, norm.bias];\n      } else {\n        normBias = [norm.bias[0], norm.bias[1], norm.bias[2], 0];\n        if (norm.bias[3] !== undefined) {\n          normBias[3] = norm.bias[3];\n        }\n      }\n    }\n\n    const stride = height * width;\n    // Default pointer assignments\n    let rTensorPointer = 0,\n      gTensorPointer = stride,\n      bTensorPointer = stride * 2,\n      aTensorPointer = -1;\n\n    // Updating the pointer assignments based on the input image format\n    if (inputformat === 'RGBA') {\n      rTensorPointer = 0;\n      gTensorPointer = stride;\n      bTensorPointer = stride * 2;\n      aTensorPointer = stride * 3;\n    } else if (inputformat === 'RGB') {\n      rTensorPointer = 0;\n      gTensorPointer = stride;\n      bTensorPointer = stride * 2;\n    } else if (inputformat === 'RBG') {\n      rTensorPointer = 0;\n      bTensorPointer = stride;\n      gTensorPointer = stride * 2;\n    }\n\n    for (let i = 0; i < height; i++) {\n      for (let j = 0; j < width; j++) {\n        const R = ((tensor.data[rTensorPointer++] as number) - normBias[0]) * normMean[0]; // R value\n        const G = ((tensor.data[gTensorPointer++] as number) - normBias[1]) * normMean[1]; // G value\n        const B = ((tensor.data[bTensorPointer++] as number) - normBias[2]) * normMean[2]; // B value\n        const A = aTensorPointer === -1 ? 255 : ((tensor.data[aTensorPointer++] as number) - normBias[3]) * normMean[3]; // A value\n\n        pixels2DContext.fillStyle = 'rgba(' + R + ',' + G + ',' + B + ',' + A + ')';\n        pixels2DContext.fillRect(j, i, 1, 1);\n      }\n    }\n    if ('toDataURL' in canvas) {\n      return canvas.toDataURL();\n    } else {\n      throw new Error('toDataURL is not supported');\n    }\n  } else {\n    throw new Error('Can not access image data');\n  }\n};\n\n/**\n * implementation of Tensor.toImageData()\n */\nexport const tensorToImageData = (tensor: Tensor, options?: TensorToImageDataOptions): ImageData => {\n  const pixels2DContext =\n    typeof document !== 'undefined'\n      ? document.createElement('canvas').getContext('2d')\n      : (new OffscreenCanvas(1, 1).getContext('2d') as OffscreenCanvasRenderingContext2D);\n  let image: ImageData;\n  if (pixels2DContext != null) {\n    // Default values for height and width & format\n    let width: number;\n    let height: number;\n    let channels: number;\n    if (options?.tensorLayout !== undefined && options.tensorLayout === 'NHWC') {\n      width = tensor.dims[2];\n      height = tensor.dims[1];\n      channels = tensor.dims[3];\n    } else {\n      // Default layout is NCWH\n      width = tensor.dims[3];\n      height = tensor.dims[2];\n      channels = tensor.dims[1];\n    }\n    const inputformat = options !== undefined ? (options.format !== undefined ? options.format : 'RGB') : 'RGB';\n\n    const norm = options?.norm;\n    let normMean: [number, number, number, number];\n    let normBias: [number, number, number, number];\n    if (norm === undefined || norm.mean === undefined) {\n      normMean = [255, 255, 255, 255];\n    } else {\n      if (typeof norm.mean === 'number') {\n        normMean = [norm.mean, norm.mean, norm.mean, norm.mean];\n      } else {\n        normMean = [norm.mean[0], norm.mean[1], norm.mean[2], 255];\n        if (norm.mean[3] !== undefined) {\n          normMean[3] = norm.mean[3];\n        }\n      }\n    }\n    if (norm === undefined || norm.bias === undefined) {\n      normBias = [0, 0, 0, 0];\n    } else {\n      if (typeof norm.bias === 'number') {\n        normBias = [norm.bias, norm.bias, norm.bias, norm.bias];\n      } else {\n        normBias = [norm.bias[0], norm.bias[1], norm.bias[2], 0];\n        if (norm.bias[3] !== undefined) {\n          normBias[3] = norm.bias[3];\n        }\n      }\n    }\n\n    const stride = height * width;\n    if (options !== undefined) {\n      if (\n        (options.format !== undefined && channels === 4 && options.format !== 'RGBA') ||\n        (channels === 3 && options.format !== 'RGB' && options.format !== 'BGR')\n      ) {\n        throw new Error(\"Tensor format doesn't match input tensor dims\");\n      }\n    }\n\n    // Default pointer assignments\n    const step = 4;\n    let rImagePointer = 0,\n      gImagePointer = 1,\n      bImagePointer = 2,\n      aImagePointer = 3;\n    let rTensorPointer = 0,\n      gTensorPointer = stride,\n      bTensorPointer = stride * 2,\n      aTensorPointer = -1;\n\n    // Updating the pointer assignments based on the input image format\n    if (inputformat === 'RGBA') {\n      rTensorPointer = 0;\n      gTensorPointer = stride;\n      bTensorPointer = stride * 2;\n      aTensorPointer = stride * 3;\n    } else if (inputformat === 'RGB') {\n      rTensorPointer = 0;\n      gTensorPointer = stride;\n      bTensorPointer = stride * 2;\n    } else if (inputformat === 'RBG') {\n      rTensorPointer = 0;\n      bTensorPointer = stride;\n      gTensorPointer = stride * 2;\n    }\n\n    image = pixels2DContext.createImageData(width, height);\n\n    for (\n      let i = 0;\n      i < height * width;\n      rImagePointer += step, gImagePointer += step, bImagePointer += step, aImagePointer += step, i++\n    ) {\n      image.data[rImagePointer] = ((tensor.data[rTensorPointer++] as number) - normBias[0]) * normMean[0]; // R value\n      image.data[gImagePointer] = ((tensor.data[gTensorPointer++] as number) - normBias[1]) * normMean[1]; // G value\n      image.data[bImagePointer] = ((tensor.data[bTensorPointer++] as number) - normBias[2]) * normMean[2]; // B value\n      image.data[aImagePointer] =\n        aTensorPointer === -1 ? 255 : ((tensor.data[aTensorPointer++] as number) - normBias[3]) * normMean[3]; // A value\n    }\n  } else {\n    throw new Error('Can not access image data');\n  }\n  return image;\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {\n  OptionsDimensions,\n  OptionsFormat,\n  OptionsNormalizationParameters,\n  OptionsTensorFormat,\n  OptionsTensorLayout,\n  TensorFromGpuBufferOptions,\n  TensorFromImageBitmapOptions,\n  TensorFromImageDataOptions,\n  TensorFromImageElementOptions,\n  TensorFromMLTensorOptions,\n  TensorFromTextureOptions,\n  TensorFromUrlOptions,\n} from './tensor-factory.js';\nimport { Tensor } from './tensor-impl.js';\nimport { Tensor as TensorInterface } from './tensor.js';\n\ninterface BufferToTensorOptions\n  extends OptionsDimensions, OptionsTensorLayout, OptionsNormalizationParameters, OptionsFormat, OptionsTensorFormat {}\n\n/**\n * Create a new tensor object from image object\n *\n * @param buffer - Extracted image buffer data - assuming RGBA format\n * @param imageFormat - input image configuration - required configurations height, width, format\n * @param tensorFormat - output tensor configuration - Default is RGB format\n */\nexport const bufferToTensor = (buffer: Uint8ClampedArray | undefined, options: BufferToTensorOptions): Tensor => {\n  if (buffer === undefined) {\n    throw new Error('Image buffer must be defined');\n  }\n  if (options.height === undefined || options.width === undefined) {\n    throw new Error('Image height and width must be defined');\n  }\n  if (options.tensorLayout === 'NHWC') {\n    throw new Error('NHWC Tensor layout is not supported yet');\n  }\n\n  const { height, width } = options;\n\n  const norm = options.norm ?? { mean: 255, bias: 0 };\n  let normMean: [number, number, number, number];\n  let normBias: [number, number, number, number];\n\n  if (typeof norm.mean === 'number') {\n    normMean = [norm.mean, norm.mean, norm.mean, norm.mean];\n  } else {\n    normMean = [norm.mean![0], norm.mean![1], norm.mean![2], norm.mean![3] ?? 255];\n  }\n\n  if (typeof norm.bias === 'number') {\n    normBias = [norm.bias, norm.bias, norm.bias, norm.bias];\n  } else {\n    normBias = [norm.bias![0], norm.bias![1], norm.bias![2], norm.bias![3] ?? 0];\n  }\n\n  const inputformat = options.format !== undefined ? options.format : 'RGBA';\n  // default value is RGBA since imagedata and HTMLImageElement uses it\n\n  const outputformat =\n    options.tensorFormat !== undefined ? (options.tensorFormat !== undefined ? options.tensorFormat : 'RGB') : 'RGB';\n  const stride = height * width;\n  const float32Data = outputformat === 'RGBA' ? new Float32Array(stride * 4) : new Float32Array(stride * 3);\n\n  // Default pointer assignments\n  let step = 4,\n    rImagePointer = 0,\n    gImagePointer = 1,\n    bImagePointer = 2,\n    aImagePointer = 3;\n  let rTensorPointer = 0,\n    gTensorPointer = stride,\n    bTensorPointer = stride * 2,\n    aTensorPointer = -1;\n\n  // Updating the pointer assignments based on the input image format\n  if (inputformat === 'RGB') {\n    step = 3;\n    rImagePointer = 0;\n    gImagePointer = 1;\n    bImagePointer = 2;\n    aImagePointer = -1;\n  }\n\n  // Updating the pointer assignments based on the output tensor format\n  if (outputformat === 'RGBA') {\n    aTensorPointer = stride * 3;\n  } else if (outputformat === 'RBG') {\n    rTensorPointer = 0;\n    bTensorPointer = stride;\n    gTensorPointer = stride * 2;\n  } else if (outputformat === 'BGR') {\n    bTensorPointer = 0;\n    gTensorPointer = stride;\n    rTensorPointer = stride * 2;\n  }\n\n  for (\n    let i = 0;\n    i < stride;\n    i++, rImagePointer += step, bImagePointer += step, gImagePointer += step, aImagePointer += step\n  ) {\n    float32Data[rTensorPointer++] = (buffer[rImagePointer] + normBias[0]) / normMean[0];\n    float32Data[gTensorPointer++] = (buffer[gImagePointer] + normBias[1]) / normMean[1];\n    float32Data[bTensorPointer++] = (buffer[bImagePointer] + normBias[2]) / normMean[2];\n    if (aTensorPointer !== -1 && aImagePointer !== -1) {\n      float32Data[aTensorPointer++] = (buffer[aImagePointer] + normBias[3]) / normMean[3];\n    }\n  }\n\n  // Float32Array -> ort.Tensor\n  const outputTensor =\n    outputformat === 'RGBA'\n      ? new Tensor('float32', float32Data, [1, 4, height, width])\n      : new Tensor('float32', float32Data, [1, 3, height, width]);\n  return outputTensor;\n};\n\n/**\n * implementation of Tensor.fromImage().\n */\nexport const tensorFromImage = async (\n  image: ImageData | HTMLImageElement | ImageBitmap | string,\n  options?:\n    | TensorFromImageDataOptions\n    | TensorFromImageElementOptions\n    | TensorFromImageBitmapOptions\n    | TensorFromUrlOptions,\n): Promise<Tensor> => {\n  // checking the type of image object\n  const isHTMLImageEle = typeof HTMLImageElement !== 'undefined' && image instanceof HTMLImageElement;\n  const isImageDataEle = typeof ImageData !== 'undefined' && image instanceof ImageData;\n  const isImageBitmap = typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap;\n  const isString = typeof image === 'string';\n\n  let data: Uint8ClampedArray | undefined;\n  let bufferToTensorOptions: BufferToTensorOptions = options ?? {};\n\n  const createCanvas = () => {\n    if (typeof document !== 'undefined') {\n      return document.createElement('canvas');\n    } else if (typeof OffscreenCanvas !== 'undefined') {\n      return new OffscreenCanvas(1, 1);\n    } else {\n      throw new Error('Canvas is not supported');\n    }\n  };\n  const createCanvasContext = (canvas: HTMLCanvasElement | OffscreenCanvas) => {\n    if (typeof HTMLCanvasElement !== 'undefined' && canvas instanceof HTMLCanvasElement) {\n      return canvas.getContext('2d');\n    } else if (canvas instanceof OffscreenCanvas) {\n      return canvas.getContext('2d') as OffscreenCanvasRenderingContext2D;\n    } else {\n      return null;\n    }\n  };\n  // filling and checking image configuration options\n  if (isHTMLImageEle) {\n    // HTMLImageElement - image object - format is RGBA by default\n    const canvas = createCanvas();\n    canvas.width = image.width;\n    canvas.height = image.height;\n    const pixels2DContext = createCanvasContext(canvas);\n\n    if (pixels2DContext != null) {\n      let height = image.height;\n      let width = image.width;\n      if (options !== undefined && options.resizedHeight !== undefined && options.resizedWidth !== undefined) {\n        height = options.resizedHeight;\n        width = options.resizedWidth;\n      }\n\n      if (options !== undefined) {\n        bufferToTensorOptions = options;\n        if (options.tensorFormat !== undefined) {\n          throw new Error('Image input config format must be RGBA for HTMLImageElement');\n        } else {\n          bufferToTensorOptions.tensorFormat = 'RGBA';\n        }\n        bufferToTensorOptions.height = height;\n        bufferToTensorOptions.width = width;\n      } else {\n        bufferToTensorOptions.tensorFormat = 'RGBA';\n        bufferToTensorOptions.height = height;\n        bufferToTensorOptions.width = width;\n      }\n\n      pixels2DContext.drawImage(image, 0, 0);\n      data = pixels2DContext.getImageData(0, 0, width, height).data;\n    } else {\n      throw new Error('Can not access image data');\n    }\n  } else if (isImageDataEle) {\n    let height: number;\n    let width: number;\n\n    if (options !== undefined && options.resizedWidth !== undefined && options.resizedHeight !== undefined) {\n      height = options.resizedHeight;\n      width = options.resizedWidth;\n    } else {\n      height = image.height;\n      width = image.width;\n    }\n\n    if (options !== undefined) {\n      bufferToTensorOptions = options;\n    }\n    bufferToTensorOptions.format = 'RGBA';\n    bufferToTensorOptions.height = height;\n    bufferToTensorOptions.width = width;\n\n    if (options !== undefined) {\n      const tempCanvas = createCanvas();\n\n      tempCanvas.width = width;\n      tempCanvas.height = height;\n\n      const pixels2DContext = createCanvasContext(tempCanvas);\n\n      if (pixels2DContext != null) {\n        pixels2DContext.putImageData(image, 0, 0);\n        data = pixels2DContext.getImageData(0, 0, width, height).data;\n      } else {\n        throw new Error('Can not access image data');\n      }\n    } else {\n      data = image.data;\n    }\n  } else if (isImageBitmap) {\n    // ImageBitmap - image object - format must be provided by user\n    if (options === undefined) {\n      throw new Error('Please provide image config with format for Imagebitmap');\n    }\n\n    const canvas = createCanvas();\n    canvas.width = image.width;\n    canvas.height = image.height;\n    const pixels2DContext = createCanvasContext(canvas);\n\n    if (pixels2DContext != null) {\n      const height = image.height;\n      const width = image.width;\n      pixels2DContext.drawImage(image, 0, 0, width, height);\n      data = pixels2DContext.getImageData(0, 0, width, height).data;\n      bufferToTensorOptions.height = height;\n      bufferToTensorOptions.width = width;\n      return bufferToTensor(data, bufferToTensorOptions);\n    } else {\n      throw new Error('Can not access image data');\n    }\n  } else if (isString) {\n    return new Promise((resolve, reject) => {\n      const canvas = createCanvas();\n      const context = createCanvasContext(canvas);\n      if (!image || !context) {\n        return reject();\n      }\n      const newImage = new Image();\n      newImage.crossOrigin = 'Anonymous';\n      newImage.src = image;\n      newImage.onload = () => {\n        canvas.width = newImage.width;\n        canvas.height = newImage.height;\n        context.drawImage(newImage, 0, 0, canvas.width, canvas.height);\n        const img = context.getImageData(0, 0, canvas.width, canvas.height);\n\n        bufferToTensorOptions.height = canvas.height;\n        bufferToTensorOptions.width = canvas.width;\n        resolve(bufferToTensor(img.data, bufferToTensorOptions));\n      };\n    });\n  } else {\n    throw new Error('Input data provided is not supported - aborted tensor creation');\n  }\n\n  if (data !== undefined) {\n    return bufferToTensor(data, bufferToTensorOptions);\n  } else {\n    throw new Error('Input data provided is not supported - aborted tensor creation');\n  }\n};\n\n/**\n * implementation of Tensor.fromTexture().\n */\nexport const tensorFromTexture = <T extends TensorInterface.TextureDataTypes>(\n  texture: TensorInterface.TextureType,\n  options: TensorFromTextureOptions<T>,\n): Tensor => {\n  const { width, height, download, dispose } = options;\n  // Always assume RGBAF32. TODO: support different texture format\n  const dims = [1, height, width, 4];\n  return new Tensor({ location: 'texture', type: 'float32', texture, dims, download, dispose });\n};\n\n/**\n * implementation of Tensor.fromGpuBuffer().\n */\nexport const tensorFromGpuBuffer = <T extends TensorInterface.GpuBufferDataTypes>(\n  gpuBuffer: TensorInterface.GpuBufferType,\n  options: TensorFromGpuBufferOptions<T>,\n): Tensor => {\n  const { dataType, dims, download, dispose } = options;\n  return new Tensor({ location: 'gpu-buffer', type: dataType ?? 'float32', gpuBuffer, dims, download, dispose });\n};\n\n/**\n * implementation of Tensor.fromMLTensor().\n */\nexport const tensorFromMLTensor = <T extends TensorInterface.MLTensorDataTypes>(\n  mlTensor: TensorInterface.MLTensorType,\n  options: TensorFromMLTensorOptions<T>,\n): Tensor => {\n  const { dataType, dims, download, dispose } = options;\n  return new Tensor({ location: 'ml-tensor', type: dataType ?? 'float32', mlTensor, dims, download, dispose });\n};\n\n/**\n * implementation of Tensor.fromPinnedBuffer().\n */\nexport const tensorFromPinnedBuffer = <T extends TensorInterface.CpuPinnedDataTypes>(\n  type: T,\n  buffer: TensorInterface.DataTypeMap[T],\n  dims?: readonly number[],\n): Tensor => new Tensor({ location: 'cpu-pinned', type, data: buffer, dims: dims ?? [buffer.length] });\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Tensor } from './tensor.js';\n\nexport type SupportedTypedArrayConstructors =\n  | Float32ArrayConstructor\n  | Uint8ArrayConstructor\n  | Int8ArrayConstructor\n  | Uint16ArrayConstructor\n  | Int16ArrayConstructor\n  | Int32ArrayConstructor\n  | BigInt64ArrayConstructor\n  | Uint8ArrayConstructor\n  | Float64ArrayConstructor\n  | Uint32ArrayConstructor\n  | BigUint64ArrayConstructor;\nexport type SupportedTypedArray = InstanceType<SupportedTypedArrayConstructors>;\n\n// a runtime map that maps type string to TypedArray constructor. Should match Tensor.DataTypeMap.\nexport const NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP = new Map<string, SupportedTypedArrayConstructors>([\n  ['float32', Float32Array],\n  ['uint8', Uint8Array],\n  ['int8', Int8Array],\n  ['uint16', Uint16Array],\n  ['int16', Int16Array],\n  ['int32', Int32Array],\n  ['bool', Uint8Array],\n  ['float64', Float64Array],\n  ['uint32', Uint32Array],\n  ['int4', Uint8Array],\n  ['uint4', Uint8Array],\n]);\n\n// a runtime map that maps type string to TypedArray constructor. Should match Tensor.DataTypeMap.\nexport const NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP = new Map<SupportedTypedArrayConstructors, Tensor.Type>([\n  [Float32Array, 'float32'],\n  [Uint8Array, 'uint8'],\n  [Int8Array, 'int8'],\n  [Uint16Array, 'uint16'],\n  [Int16Array, 'int16'],\n  [Int32Array, 'int32'],\n  [Float64Array, 'float64'],\n  [Uint32Array, 'uint32'],\n]);\n\n// the following code allows delaying execution of BigInt/Float16Array checking. This allows lazy initialization for\n// NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP and NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP, which allows BigInt/Float16Array\n// polyfill if available.\nlet isTypedArrayChecked = false;\nexport const checkTypedArray = () => {\n  if (!isTypedArrayChecked) {\n    isTypedArrayChecked = true;\n    const isBigInt64ArrayAvailable = typeof BigInt64Array !== 'undefined' && BigInt64Array.from;\n    const isBigUint64ArrayAvailable = typeof BigUint64Array !== 'undefined' && BigUint64Array.from;\n\n    // eslint-disable-next-line @typescript-eslint/naming-convention, @typescript-eslint/no-explicit-any\n    const Float16Array = (globalThis as any).Float16Array;\n    const isFloat16ArrayAvailable = typeof Float16Array !== 'undefined' && Float16Array.from;\n\n    if (isBigInt64ArrayAvailable) {\n      NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set('int64', BigInt64Array);\n      NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.set(BigInt64Array, 'int64');\n    }\n    if (isBigUint64ArrayAvailable) {\n      NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set('uint64', BigUint64Array);\n      NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.set(BigUint64Array, 'uint64');\n    }\n    if (isFloat16ArrayAvailable) {\n      NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set('float16', Float16Array);\n      NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.set(Float16Array, 'float16');\n    } else {\n      // if Float16Array is not available, use 'Uint16Array' to store the data.\n      NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set('float16', Uint16Array);\n    }\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {\n  CpuPinnedConstructorParameters,\n  GpuBufferConstructorParameters,\n  MLTensorConstructorParameters,\n  TextureConstructorParameters,\n} from './tensor-factory.js';\nimport { Tensor } from './tensor-impl.js';\n\n/**\n * calculate size from dims.\n *\n * @param dims the dims array. May be an illegal input.\n */\nexport const calculateSize = (dims: readonly unknown[]): number => {\n  let size = 1;\n  for (let i = 0; i < dims.length; i++) {\n    const dim = dims[i];\n    if (typeof dim !== 'number' || !Number.isSafeInteger(dim)) {\n      throw new TypeError(`dims[${i}] must be an integer, got: ${dim}`);\n    }\n    if (dim < 0) {\n      throw new RangeError(`dims[${i}] must be a non-negative integer, got: ${dim}`);\n    }\n    size *= dim;\n  }\n  return size;\n};\n\n/**\n * implementation of Tensor.reshape()\n */\nexport const tensorReshape = (tensor: Tensor, dims: readonly number[]): Tensor => {\n  switch (tensor.location) {\n    case 'cpu':\n      return new Tensor(tensor.type, tensor.data, dims);\n    case 'cpu-pinned':\n      return new Tensor({\n        location: 'cpu-pinned',\n        data: tensor.data as CpuPinnedConstructorParameters['data'],\n        type: tensor.type as CpuPinnedConstructorParameters['type'],\n        dims,\n      });\n    case 'texture':\n      return new Tensor({\n        location: 'texture',\n        texture: tensor.texture,\n        type: tensor.type as TextureConstructorParameters['type'],\n        dims,\n      });\n    case 'gpu-buffer':\n      return new Tensor({\n        location: 'gpu-buffer',\n        gpuBuffer: tensor.gpuBuffer,\n        type: tensor.type as GpuBufferConstructorParameters['type'],\n        dims,\n      });\n    case 'ml-tensor':\n      return new Tensor({\n        location: 'ml-tensor',\n        mlTensor: tensor.mlTensor,\n        type: tensor.type as MLTensorConstructorParameters['type'],\n        dims,\n      });\n    default:\n      throw new Error(`tensorReshape: tensor location ${tensor.location} is not supported`);\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { tensorToDataURL, tensorToImageData } from './tensor-conversion-impl.js';\nimport { TensorToDataUrlOptions, TensorToImageDataOptions } from './tensor-conversion.js';\nimport {\n  tensorFromGpuBuffer,\n  tensorFromImage,\n  tensorFromMLTensor,\n  tensorFromPinnedBuffer,\n  tensorFromTexture,\n} from './tensor-factory-impl.js';\nimport {\n  CpuPinnedConstructorParameters,\n  GpuBufferConstructorParameters,\n  MLTensorConstructorParameters,\n  TensorFromGpuBufferOptions,\n  TensorFromImageBitmapOptions,\n  TensorFromImageDataOptions,\n  TensorFromImageElementOptions,\n  TensorFromMLTensorOptions,\n  TensorFromTextureOptions,\n  TensorFromUrlOptions,\n  TextureConstructorParameters,\n} from './tensor-factory.js';\nimport {\n  checkTypedArray,\n  NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP,\n  NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP,\n  SupportedTypedArray,\n  SupportedTypedArrayConstructors,\n} from './tensor-impl-type-mapping.js';\nimport { calculateSize, tensorReshape } from './tensor-utils-impl.js';\nimport { Tensor as TensorInterface } from './tensor.js';\n\n// type aliases for those exported from Tensor interface\n\ntype TensorType = TensorInterface.Type;\ntype TensorDataType = TensorInterface.DataType;\ntype TensorDataLocation = TensorInterface.DataLocation;\ntype TensorTextureType = TensorInterface.TextureType;\ntype TensorGpuBufferType = TensorInterface.GpuBufferType;\ntype TensorMLTensorType = TensorInterface.MLTensorType;\n\n/**\n * the implementation of Tensor interface.\n *\n * @ignore\n */\nexport class Tensor implements TensorInterface {\n  // #region constructors\n\n  /**\n   * Construct a new CPU tensor object from the given type, data and dims.\n   */\n  constructor(\n    type: TensorType,\n    data: TensorDataType | Uint8ClampedArray | readonly string[] | readonly number[] | readonly boolean[],\n    dims?: readonly number[],\n  );\n  /**\n   * Construct a new CPU tensor object from the given data and dims. Type is inferred from data.\n   */\n  constructor(\n    data: TensorDataType | Uint8ClampedArray | readonly string[] | readonly boolean[],\n    dims?: readonly number[],\n  );\n  /**\n   * Construct a new tensor object from the pinned CPU data with the given type and dims.\n   *\n   * Tensor's location will be set to 'cpu-pinned'.\n   *\n   * @param params - Specify the parameters to construct the tensor.\n   */\n  constructor(params: CpuPinnedConstructorParameters);\n  /**\n   * Construct a new tensor object from the WebGL texture with the given type and dims.\n   *\n   * Tensor's location will be set to 'texture'.\n   *\n   * @param params - Specify the parameters to construct the tensor.\n   */\n  constructor(params: TextureConstructorParameters);\n  /**\n   * Construct a new tensor object from the WebGPU buffer with the given type and dims.\n   *\n   * Tensor's location will be set to 'gpu-buffer'.\n   *\n   * @param params - Specify the parameters to construct the tensor.\n   */\n  constructor(params: GpuBufferConstructorParameters);\n\n  /**\n   * Construct a new tensor object from the WebNN MLTensor with the given type and dims.\n   *\n   * Tensor's location will be set to 'ml-tensor'.\n   *\n   * @param params - Specify the parameters to construct the tensor.\n   */\n  constructor(params: MLTensorConstructorParameters);\n\n  /**\n   * implementation.\n   */\n  constructor(\n    arg0:\n      | TensorType\n      | TensorDataType\n      | Uint8ClampedArray\n      | readonly string[]\n      | readonly boolean[]\n      | CpuPinnedConstructorParameters\n      | TextureConstructorParameters\n      | GpuBufferConstructorParameters\n      | MLTensorConstructorParameters,\n    arg1?: TensorDataType | Uint8ClampedArray | readonly number[] | readonly string[] | readonly boolean[],\n    arg2?: readonly number[],\n  ) {\n    // perform one-time check for BigInt/Float16Array support\n    checkTypedArray();\n\n    let type: TensorType;\n    let dims: readonly number[];\n\n    if (typeof arg0 === 'object' && 'location' in arg0) {\n      //\n      // constructing tensor from specific location\n      //\n      this.dataLocation = arg0.location;\n      type = arg0.type;\n      dims = arg0.dims;\n      switch (arg0.location) {\n        case 'cpu-pinned': {\n          const expectedTypedArrayConstructor = NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.get(type);\n          if (!expectedTypedArrayConstructor) {\n            throw new TypeError(`unsupported type \"${type}\" to create tensor from pinned buffer`);\n          }\n          if (!(arg0.data instanceof expectedTypedArrayConstructor)) {\n            throw new TypeError(`buffer should be of type ${expectedTypedArrayConstructor.name}`);\n          }\n          this.cpuData = arg0.data;\n          break;\n        }\n        case 'texture': {\n          if (type !== 'float32') {\n            throw new TypeError(`unsupported type \"${type}\" to create tensor from texture`);\n          }\n          this.gpuTextureData = arg0.texture;\n          this.downloader = arg0.download;\n          this.disposer = arg0.dispose;\n          break;\n        }\n        case 'gpu-buffer': {\n          if (\n            type !== 'float32' &&\n            type !== 'float16' &&\n            type !== 'int32' &&\n            type !== 'int64' &&\n            type !== 'uint32' &&\n            type !== 'uint8' &&\n            type !== 'bool' &&\n            type !== 'uint4' &&\n            type !== 'int4'\n          ) {\n            throw new TypeError(`unsupported type \"${type}\" to create tensor from gpu buffer`);\n          }\n          this.gpuBufferData = arg0.gpuBuffer;\n          this.downloader = arg0.download;\n          this.disposer = arg0.dispose;\n          break;\n        }\n        case 'ml-tensor': {\n          if (\n            type !== 'float32' &&\n            type !== 'float16' &&\n            type !== 'int32' &&\n            type !== 'int64' &&\n            type !== 'uint32' &&\n            type !== 'uint64' &&\n            type !== 'int8' &&\n            type !== 'uint8' &&\n            type !== 'bool' &&\n            type !== 'uint4' &&\n            type !== 'int4'\n          ) {\n            throw new TypeError(`unsupported type \"${type}\" to create tensor from MLTensor`);\n          }\n          this.mlTensorData = arg0.mlTensor;\n          this.downloader = arg0.download;\n          this.disposer = arg0.dispose;\n          break;\n        }\n        default:\n          throw new Error(`Tensor constructor: unsupported location '${this.dataLocation}'`);\n      }\n    } else {\n      //\n      // constructing tensor of location 'cpu'\n      //\n      let data: TensorDataType;\n      let maybeDims: typeof arg1 | typeof arg2;\n      // check whether arg0 is type or data\n      if (typeof arg0 === 'string') {\n        //\n        // Override: constructor(type, data, ...)\n        //\n        type = arg0;\n        maybeDims = arg2;\n        if (arg0 === 'string') {\n          // string tensor\n          if (!Array.isArray(arg1)) {\n            throw new TypeError(\"A string tensor's data must be a string array.\");\n          }\n          // we don't check whether every element in the array is string; this is too slow. we assume it's correct and\n          // error will be populated at inference\n          data = arg1;\n        } else {\n          // numeric tensor\n          const typedArrayConstructor = NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.get(arg0);\n          if (typedArrayConstructor === undefined) {\n            throw new TypeError(`Unsupported tensor type: ${arg0}.`);\n          }\n          if (Array.isArray(arg1)) {\n            if ((arg0 === 'float16' && typedArrayConstructor === Uint16Array) || arg0 === 'uint4' || arg0 === 'int4') {\n              // - 'float16':\n              //   When no Float16Array polyfill is used, we cannot create 'float16' tensor from number array.\n              //\n              //   Throw error here because when user try to use number array as data,\n              //   e.g. new Tensor('float16', [1, 2, 3, 4], dims)), it will actually call\n              //   Uint16Array.from(arg1) which generates wrong data.\n              //\n              // - 'uint4' and 'int4':\n              //   Uint8Array.from(arg1) will generate wrong data for 'uint4' and 'int4' tensor.\n              //\n              throw new TypeError(\n                `Creating a ${arg0} tensor from number array is not supported. Please use ${typedArrayConstructor.name} as data.`,\n              );\n            } else if (arg0 === 'uint64' || arg0 === 'int64') {\n              // use 'as any' here because:\n              // 1. TypeScript's check on type of 'Array.isArray()' does not work with readonly arrays.\n              // see https://github.com/microsoft/TypeScript/issues/17002\n              // 2. TypeScript's check on union type of '(BigInt64ArrayConstructor|BigUint64ArrayConstructor).from()'\n              // does not accept parameter mapFn.\n              // 3. parameters of 'SupportedTypedArrayConstructors.from()' does not match the requirement of the union\n              // type.\n\n              // assume 'arg1' is of type \"readonly number[]|readonly bigint[]\" here.\n\n              // eslint-disable-next-line @typescript-eslint/no-explicit-any\n              data = (typedArrayConstructor as any).from(arg1, BigInt);\n            } else {\n              // assume 'arg1' is of type \"readonly number[]\" here.\n              // eslint-disable-next-line @typescript-eslint/no-explicit-any\n              data = (typedArrayConstructor as any).from(arg1);\n            }\n          } else if (arg1 instanceof typedArrayConstructor) {\n            data = arg1;\n          } else if (arg1 instanceof Uint8ClampedArray) {\n            if (arg0 === 'uint8') {\n              data = Uint8Array.from(arg1);\n            } else {\n              throw new TypeError(`A Uint8ClampedArray tensor's data must be type of uint8`);\n            }\n          } else if (arg0 === 'float16' && arg1 instanceof Uint16Array && typedArrayConstructor !== Uint16Array) {\n            // when Float16Array is available and data is of type Uint16Array.\n            // We allow Uint16Array to be passed in as data for 'float16' tensor until Float16Array is generally\n            // supported in JavaScript environment.\n\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            data = new (globalThis as any).Float16Array(arg1.buffer, arg1.byteOffset, arg1.length);\n          } else {\n            throw new TypeError(`A ${type} tensor's data must be type of ${typedArrayConstructor}`);\n          }\n        }\n      } else {\n        //\n        // Override: constructor(data, ...)\n        //\n        maybeDims = arg1;\n        if (Array.isArray(arg0)) {\n          // only boolean[] and string[] is supported\n          if (arg0.length === 0) {\n            throw new TypeError('Tensor type cannot be inferred from an empty array.');\n          }\n          const firstElementType = typeof arg0[0];\n          if (firstElementType === 'string') {\n            type = 'string';\n            data = arg0;\n          } else if (firstElementType === 'boolean') {\n            type = 'bool';\n            // 'arg0' is of type 'boolean[]'. Uint8Array.from(boolean[]) actually works, but typescript thinks this is\n            // wrong type. We use 'as any' to make it happy.\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            data = Uint8Array.from(arg0 as any[]);\n          } else {\n            throw new TypeError(`Invalid element type of data array: ${firstElementType}.`);\n          }\n        } else if (arg0 instanceof Uint8ClampedArray) {\n          type = 'uint8';\n          data = Uint8Array.from(arg0);\n        } else {\n          // get tensor type from TypedArray\n          const mappedType = NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.get(\n            arg0.constructor as SupportedTypedArrayConstructors,\n          );\n          if (mappedType === undefined) {\n            throw new TypeError(`Unsupported type for tensor data: ${arg0.constructor}.`);\n          }\n          type = mappedType;\n          data = arg0 as SupportedTypedArray;\n        }\n      }\n\n      // type and data is processed, now processing dims\n      if (maybeDims === undefined) {\n        // assume 1-D tensor if dims omitted\n        maybeDims = [data.length];\n      } else if (!Array.isArray(maybeDims)) {\n        throw new TypeError(\"A tensor's dims must be a number array\");\n      }\n      dims = maybeDims as readonly number[];\n\n      this.cpuData = data;\n      this.dataLocation = 'cpu';\n    }\n\n    // perform check on dims\n    const size = calculateSize(dims);\n    // if data is on CPU, check whether data length matches tensor size\n    if (this.cpuData && size !== this.cpuData.length) {\n      if ((type === 'uint4' || type === 'int4') && Math.ceil(size / 2) === this.cpuData.length) {\n        // for (u)int4, the data length is half of the tensor size. So we check this special case when size is odd.\n      } else {\n        throw new Error(`Tensor's size(${size}) does not match data length(${this.cpuData.length}).`);\n      }\n    }\n\n    this.type = type;\n    this.dims = dims;\n    this.size = size;\n  }\n  // #endregion\n\n  // #region factory\n  static async fromImage(\n    image: ImageData | HTMLImageElement | ImageBitmap | string,\n    options?:\n      | TensorFromImageDataOptions\n      | TensorFromImageElementOptions\n      | TensorFromImageBitmapOptions\n      | TensorFromUrlOptions,\n  ): Promise<TensorInterface> {\n    return tensorFromImage(image, options);\n  }\n\n  static fromTexture<T extends TensorInterface.TextureDataTypes>(\n    texture: TensorTextureType,\n    options: TensorFromTextureOptions<T>,\n  ): TensorInterface {\n    return tensorFromTexture(texture, options);\n  }\n\n  static fromGpuBuffer<T extends TensorInterface.GpuBufferDataTypes>(\n    gpuBuffer: TensorGpuBufferType,\n    options: TensorFromGpuBufferOptions<T>,\n  ): TensorInterface {\n    return tensorFromGpuBuffer(gpuBuffer, options);\n  }\n\n  static fromMLTensor<T extends TensorInterface.MLTensorDataTypes>(\n    mlTensor: TensorMLTensorType,\n    options: TensorFromMLTensorOptions<T>,\n  ): TensorInterface {\n    return tensorFromMLTensor(mlTensor, options);\n  }\n\n  static fromPinnedBuffer<T extends TensorInterface.CpuPinnedDataTypes>(\n    type: T,\n    buffer: TensorInterface.DataTypeMap[T],\n    dims?: readonly number[],\n  ): Tensor {\n    return tensorFromPinnedBuffer(type, buffer, dims);\n  }\n\n  // #endregion\n\n  // #region conversions\n  toDataURL(options?: TensorToDataUrlOptions): string {\n    return tensorToDataURL(this, options);\n  }\n\n  toImageData(options?: TensorToImageDataOptions): ImageData {\n    return tensorToImageData(this, options);\n  }\n  // #endregion\n\n  // #region public fields\n  readonly dims: readonly number[];\n  readonly type: TensorType;\n  readonly size: number;\n  // #endregion\n\n  // #region private fields\n\n  /**\n   * stores the location of the data.\n   */\n  private dataLocation: TensorDataLocation;\n\n  /**\n   * stores the data on CPU, if location is 'cpu' or 'cpu-pinned'. otherwise empty.\n   */\n  private cpuData?: TensorDataType;\n\n  /**\n   * stores the underlying texture when location is 'texture'. otherwise empty.\n   */\n  private gpuTextureData?: TensorTextureType;\n\n  /**\n   * stores the underlying GPU buffer when location is 'gpu-buffer'. otherwise empty.\n   */\n  private gpuBufferData?: TensorGpuBufferType;\n\n  /**\n   * stores the underlying WebNN MLTensor when location is 'ml-tensor'. otherwise empty.\n   */\n  private mlTensorData?: TensorMLTensorType;\n\n  /**\n   * stores an optional downloader function to download data from GPU to CPU.\n   */\n  private downloader?(): Promise<TensorDataType>;\n\n  /**\n   * a flag indicating whether the data is being downloaded from GPU to CPU.\n   */\n  private isDownloading?: boolean;\n\n  /**\n   * stores an optional disposer function to dispose the underlying data.\n   */\n  private disposer?(): void;\n  // #endregion\n\n  // #region properties\n  get data(): TensorDataType {\n    this.ensureValid();\n    if (!this.cpuData) {\n      throw new Error(\n        'The data is not on CPU. Use `getData()` to download GPU data to CPU, ' +\n          'or use `texture` or `gpuBuffer` property to access the GPU data directly.',\n      );\n    }\n    return this.cpuData;\n  }\n\n  get location(): TensorDataLocation {\n    return this.dataLocation;\n  }\n\n  get texture(): TensorTextureType {\n    this.ensureValid();\n    if (!this.gpuTextureData) {\n      throw new Error('The data is not stored as a WebGL texture.');\n    }\n    return this.gpuTextureData;\n  }\n\n  get gpuBuffer(): TensorGpuBufferType {\n    this.ensureValid();\n    if (!this.gpuBufferData) {\n      throw new Error('The data is not stored as a WebGPU buffer.');\n    }\n    return this.gpuBufferData;\n  }\n\n  get mlTensor(): TensorMLTensorType {\n    this.ensureValid();\n    if (!this.mlTensorData) {\n      throw new Error('The data is not stored as a WebNN MLTensor.');\n    }\n    return this.mlTensorData;\n  }\n  // #endregion\n\n  // #region methods\n\n  async getData(releaseData?: boolean): Promise<TensorDataType> {\n    this.ensureValid();\n    switch (this.dataLocation) {\n      case 'cpu':\n      case 'cpu-pinned':\n        return this.data;\n      case 'texture':\n      case 'gpu-buffer':\n      case 'ml-tensor': {\n        if (!this.downloader) {\n          throw new Error('The current tensor is not created with a specified data downloader.');\n        }\n        if (this.isDownloading) {\n          throw new Error('The current tensor is being downloaded.');\n        }\n        try {\n          this.isDownloading = true;\n          const data = await this.downloader();\n          this.downloader = undefined;\n          this.dataLocation = 'cpu';\n          this.cpuData = data;\n\n          if (releaseData && this.disposer) {\n            this.disposer();\n            this.disposer = undefined;\n          }\n\n          return data;\n        } finally {\n          this.isDownloading = false;\n        }\n      }\n      default:\n        throw new Error(`cannot get data from location: ${this.dataLocation}`);\n    }\n  }\n\n  dispose(): void {\n    if (this.isDownloading) {\n      throw new Error('The current tensor is being downloaded.');\n    }\n\n    if (this.disposer) {\n      this.disposer();\n      this.disposer = undefined;\n    }\n    this.cpuData = undefined;\n    this.gpuTextureData = undefined;\n    this.gpuBufferData = undefined;\n    this.mlTensorData = undefined;\n    this.downloader = undefined;\n    this.isDownloading = undefined;\n\n    this.dataLocation = 'none';\n  }\n\n  // #endregion\n\n  // #region tensor utilities\n  private ensureValid(): void {\n    if (this.dataLocation === 'none') {\n      throw new Error('The tensor is disposed.');\n    }\n  }\n\n  reshape(dims: readonly number[]): TensorInterface {\n    this.ensureValid();\n    if (this.downloader || this.disposer) {\n      throw new Error('Cannot reshape a tensor that owns GPU resource.');\n    }\n    return tensorReshape(this, dims);\n  }\n  // #endregion\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { TensorFactory } from './tensor-factory.js';\nimport { Tensor as TensorImpl } from './tensor-impl.js';\nimport { TypedTensorUtils } from './tensor-utils.js';\nimport { TryGetGlobalType } from './type-helper.js';\n\n/* eslint-disable @typescript-eslint/no-redeclare */\n\n/**\n * represent a basic tensor with specified dimensions and data type.\n */\ninterface TypedTensorBase<T extends Tensor.Type> {\n  /**\n   * Get the dimensions of the tensor.\n   */\n  readonly dims: readonly number[];\n  /**\n   * Get the data type of the tensor.\n   */\n  readonly type: T;\n  /**\n   * Get the buffer data of the tensor.\n   *\n   * If the data is not on CPU (eg. it's in the form of WebGL texture or WebGPU buffer), throw error.\n   */\n  readonly data: Tensor.DataTypeMap[T];\n  /**\n   * Get the location of the data.\n   */\n  readonly location: Tensor.DataLocation;\n  /**\n   * Get the WebGL texture that holds the tensor data.\n   *\n   * If the data is not on GPU as WebGL texture, throw error.\n   */\n  readonly texture: Tensor.TextureType;\n  /**\n   * Get the WebGPU buffer that holds the tensor data.\n   *\n   * If the data is not on GPU as WebGPU buffer, throw error.\n   */\n  readonly gpuBuffer: Tensor.GpuBufferType;\n\n  /**\n   * Get the WebNN MLTensor that holds the tensor data.\n   *\n   * If the data is not in a WebNN MLTensor, throw error.\n   */\n  readonly mlTensor: Tensor.MLTensorType;\n\n  /**\n   * Get the buffer data of the tensor.\n   *\n   * If the data is on CPU, returns the data immediately.\n   * If the data is on GPU, downloads the data and returns the promise.\n   *\n   * @param releaseData - whether release the data on GPU. Ignore if data is already on CPU.\n   */\n  getData(releaseData?: boolean): Promise<Tensor.DataTypeMap[T]>;\n\n  /**\n   * Dispose the tensor data.\n   *\n   * If the data is on CPU, remove its internal reference to the underlying data.\n   * If the data is on GPU, release the data on GPU.\n   *\n   * After calling this function, the tensor is considered no longer valid. Its location will be set to 'none'.\n   */\n  dispose(): void;\n}\n\nexport declare namespace Tensor {\n  interface DataTypeMap {\n    float32: Float32Array;\n    uint8: Uint8Array;\n    int8: Int8Array;\n    uint16: Uint16Array;\n    int16: Int16Array;\n    int32: Int32Array;\n    int64: BigInt64Array;\n    string: string[];\n    bool: Uint8Array;\n    float16: Uint16Array; // Keep using Uint16Array until we have a concrete solution for float 16.\n    float64: Float64Array;\n    uint32: Uint32Array;\n    uint64: BigUint64Array;\n    // complex64: never;\n    // complex128: never;\n    // bfloat16: never;\n    uint4: Uint8Array;\n    int4: Int8Array;\n  }\n\n  interface ElementTypeMap {\n    float32: number;\n    uint8: number;\n    int8: number;\n    uint16: number;\n    int16: number;\n    int32: number;\n    int64: bigint;\n    string: string;\n    bool: boolean;\n    float16: number; // Keep using Uint16Array until we have a concrete solution for float 16.\n    float64: number;\n    uint32: number;\n    uint64: bigint;\n    // complex64: never;\n    // complex128: never;\n    // bfloat16: never;\n    uint4: number;\n    int4: number;\n  }\n\n  type DataType = DataTypeMap[Type];\n  type ElementType = ElementTypeMap[Type];\n\n  /**\n   * supported data types for constructing a tensor from a pinned CPU buffer\n   */\n  export type CpuPinnedDataTypes = Exclude<Tensor.Type, 'string'>;\n\n  /**\n   * type alias for WebGL texture\n   */\n  export type TextureType = WebGLTexture;\n\n  /**\n   * supported data types for constructing a tensor from a WebGL texture\n   */\n  export type TextureDataTypes = 'float32';\n\n  type GpuBufferTypeFallback = { size: number; mapState: 'unmapped' | 'pending' | 'mapped' };\n  /**\n   * type alias for WebGPU buffer\n   */\n  export type GpuBufferType = TryGetGlobalType<'GPUBuffer', GpuBufferTypeFallback>;\n\n  type MLTensorTypeFallback = { destroy(): void };\n  /**\n   * type alias for WebNN MLTensor\n   *\n   * The specification for WebNN's MLTensor is currently in flux.\n   */\n  export type MLTensorType = TryGetGlobalType<'MLTensor', MLTensorTypeFallback>;\n\n  /**\n   * supported data types for constructing a tensor from a WebGPU buffer\n   */\n  export type GpuBufferDataTypes = 'float32' | 'float16' | 'int32' | 'int64' | 'uint32' | 'uint8' | 'bool';\n\n  /**\n   * supported data types for constructing a tensor from a WebNN MLTensor\n   */\n  export type MLTensorDataTypes =\n    | 'float32'\n    | 'float16'\n    | 'int8'\n    | 'uint8'\n    | 'int32'\n    | 'uint32'\n    | 'int64'\n    | 'uint64'\n    | 'bool'\n    | 'uint4'\n    | 'int4';\n\n  /**\n   * represent where the tensor data is stored\n   */\n  export type DataLocation = 'none' | 'cpu' | 'cpu-pinned' | 'texture' | 'gpu-buffer' | 'ml-tensor';\n\n  /**\n   * represent the data type of a tensor\n   */\n  export type Type = keyof DataTypeMap;\n}\n\n/**\n * Represent multi-dimensional arrays to feed to or fetch from model inferencing.\n */\nexport interface TypedTensor<T extends Tensor.Type> extends TypedTensorBase<T>, TypedTensorUtils<T> {}\n/**\n * Represent multi-dimensional arrays to feed to or fetch from model inferencing.\n */\nexport interface Tensor extends TypedTensorBase<Tensor.Type>, TypedTensorUtils<Tensor.Type> {}\n\n/**\n * type TensorConstructor defines the constructors of 'Tensor' to create CPU tensor instances.\n */\nexport interface TensorConstructor extends TensorFactory {\n  // #region CPU tensor - specify element type\n  /**\n   * Construct a new string tensor object from the given type, data and dims.\n   *\n   * @param type - Specify the element type.\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (\n    type: 'string',\n    data: Tensor.DataTypeMap['string'] | readonly string[],\n    dims?: readonly number[],\n  ): TypedTensor<'string'>;\n\n  /**\n   * Construct a new bool tensor object from the given type, data and dims.\n   *\n   * @param type - Specify the element type.\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (\n    type: 'bool',\n    data: Tensor.DataTypeMap['bool'] | readonly boolean[],\n    dims?: readonly number[],\n  ): TypedTensor<'bool'>;\n\n  /**\n   * Construct a new uint8 tensor object from a Uint8ClampedArray, data and dims.\n   *\n   * @param type - Specify the element type.\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (type: 'uint8', data: Uint8ClampedArray, dims?: readonly number[]): TypedTensor<'uint8'>;\n\n  /**\n   * Construct a new 64-bit integer typed tensor object from the given type, data and dims.\n   *\n   * @param type - Specify the element type.\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new <T extends 'uint64' | 'int64'>(\n    type: T,\n    data: Tensor.DataTypeMap[T] | readonly bigint[] | readonly number[],\n    dims?: readonly number[],\n  ): TypedTensor<T>;\n\n  /**\n   * Construct a new numeric tensor object from the given type, data and dims.\n   *\n   * @param type - Specify the element type.\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new <T extends Exclude<Tensor.Type, 'string' | 'bool' | 'uint64' | 'int64'>>(\n    type: T,\n    data: Tensor.DataTypeMap[T] | readonly number[],\n    dims?: readonly number[],\n  ): TypedTensor<T>;\n  // #endregion\n\n  // #region CPU tensor - infer element types\n\n  /**\n   * Construct a new float32 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (data: Float32Array, dims?: readonly number[]): TypedTensor<'float32'>;\n\n  /**\n   * Construct a new int8 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (data: Int8Array, dims?: readonly number[]): TypedTensor<'int8'>;\n\n  /**\n   * Construct a new uint8 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (data: Uint8Array, dims?: readonly number[]): TypedTensor<'uint8'>;\n\n  /**\n   * Construct a new uint8 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (data: Uint8ClampedArray, dims?: readonly number[]): TypedTensor<'uint8'>;\n\n  /**\n   * Construct a new uint16 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (data: Uint16Array, dims?: readonly number[]): TypedTensor<'uint16'>;\n\n  /**\n   * Construct a new int16 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (data: Int16Array, dims?: readonly number[]): TypedTensor<'int16'>;\n\n  /**\n   * Construct a new int32 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (data: Int32Array, dims?: readonly number[]): TypedTensor<'int32'>;\n\n  /**\n   * Construct a new int64 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (data: BigInt64Array, dims?: readonly number[]): TypedTensor<'int64'>;\n\n  /**\n   * Construct a new string tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (data: readonly string[], dims?: readonly number[]): TypedTensor<'string'>;\n\n  /**\n   * Construct a new bool tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (data: readonly boolean[], dims?: readonly number[]): TypedTensor<'bool'>;\n\n  /**\n   * Construct a new float64 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (data: Float64Array, dims?: readonly number[]): TypedTensor<'float64'>;\n\n  /**\n   * Construct a new uint32 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (data: Uint32Array, dims?: readonly number[]): TypedTensor<'uint32'>;\n\n  /**\n   * Construct a new uint64 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (data: BigUint64Array, dims?: readonly number[]): TypedTensor<'uint64'>;\n\n  // #endregion\n\n  // #region CPU tensor - fall back to non-generic tensor type declaration\n\n  /**\n   * Construct a new tensor object from the given type, data and dims.\n   *\n   * @param type - Specify the element type.\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (\n    type: Tensor.Type,\n    data: Tensor.DataType | readonly number[] | readonly string[] | readonly bigint[] | readonly boolean[],\n    dims?: readonly number[],\n  ): Tensor;\n\n  /**\n   * Construct a new tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (data: Tensor.DataType, dims?: readonly number[]): Tensor;\n  // #endregion\n}\n\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const Tensor = TensorImpl as TensorConstructor;\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { env } from './env-impl.js';\n\n/**\n * @ignore\n */\nexport const TRACE = (deviceType: string, label: string) => {\n  if (typeof env.trace === 'undefined' ? !env.wasm.trace : !env.trace) {\n    return;\n  }\n  // eslint-disable-next-line no-console\n  console.timeStamp(`${deviceType}::ORT::${label}`);\n};\n\nconst TRACE_FUNC = (msg: string, extraMsg?: string) => {\n  const stack = new Error().stack?.split(/\\r\\n|\\r|\\n/g) || [];\n  let hasTraceFunc = false;\n  for (let i = 0; i < stack.length; i++) {\n    if (hasTraceFunc && !stack[i].includes('TRACE_FUNC')) {\n      let label = `FUNC_${msg}::${stack[i].trim().split(' ')[1]}`;\n      if (extraMsg) {\n        label += `::${extraMsg}`;\n      }\n      TRACE('CPU', label);\n      return;\n    }\n    if (stack[i].includes('TRACE_FUNC')) {\n      hasTraceFunc = true;\n    }\n  }\n};\n\n/**\n * @ignore\n */\nexport const TRACE_FUNC_BEGIN = (extraMsg?: string) => {\n  if (typeof env.trace === 'undefined' ? !env.wasm.trace : !env.trace) {\n    return;\n  }\n  TRACE_FUNC('BEGIN', extraMsg);\n};\n\n/**\n * @ignore\n */\nexport const TRACE_FUNC_END = (extraMsg?: string) => {\n  if (typeof env.trace === 'undefined' ? !env.wasm.trace : !env.trace) {\n    return;\n  }\n  TRACE_FUNC('END', extraMsg);\n};\n\n/**\n * @ignore\n */\nexport const TRACE_EVENT_BEGIN = (extraMsg?: string) => {\n  if (typeof env.trace === 'undefined' ? !env.wasm.trace : !env.trace) {\n    return;\n  }\n  // eslint-disable-next-line no-console\n  console.time(`ORT::${extraMsg}`);\n};\n\n/**\n * @ignore\n */\nexport const TRACE_EVENT_END = (extraMsg?: string) => {\n  if (typeof env.trace === 'undefined' ? !env.wasm.trace : !env.trace) {\n    return;\n  }\n  // eslint-disable-next-line no-console\n  console.timeEnd(`ORT::${extraMsg}`);\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { resolveBackendAndExecutionProviders } from './backend-impl.js';\nimport { InferenceSessionHandler } from './backend.js';\nimport { InferenceSession as InferenceSessionInterface } from './inference-session.js';\nimport { OnnxValue } from './onnx-value.js';\nimport { Tensor } from './tensor.js';\nimport { TRACE_FUNC_BEGIN, TRACE_FUNC_END, TRACE_EVENT_BEGIN, TRACE_EVENT_END } from './trace.js';\n\ntype SessionOptions = InferenceSessionInterface.SessionOptions;\ntype RunOptions = InferenceSessionInterface.RunOptions;\ntype FeedsType = InferenceSessionInterface.FeedsType;\ntype FetchesType = InferenceSessionInterface.FetchesType;\ntype ReturnType = InferenceSessionInterface.ReturnType;\n\nexport class InferenceSession implements InferenceSessionInterface {\n  private constructor(handler: InferenceSessionHandler) {\n    this.handler = handler;\n  }\n  run(feeds: FeedsType, options?: RunOptions): Promise<ReturnType>;\n  run(feeds: FeedsType, fetches: FetchesType, options?: RunOptions): Promise<ReturnType>;\n  async run(feeds: FeedsType, arg1?: FetchesType | RunOptions, arg2?: RunOptions): Promise<ReturnType> {\n    TRACE_FUNC_BEGIN();\n    TRACE_EVENT_BEGIN('InferenceSession.run');\n    const fetches: { [name: string]: OnnxValue | null } = {};\n    let options: RunOptions = {};\n    // check inputs\n    if (typeof feeds !== 'object' || feeds === null || feeds instanceof Tensor || Array.isArray(feeds)) {\n      throw new TypeError(\n        \"'feeds' must be an object that use input names as keys and OnnxValue as corresponding values.\",\n      );\n    }\n\n    let isFetchesEmpty = true;\n    // determine which override is being used\n    if (typeof arg1 === 'object') {\n      if (arg1 === null) {\n        throw new TypeError('Unexpected argument[1]: cannot be null.');\n      }\n      if (arg1 instanceof Tensor) {\n        throw new TypeError(\"'fetches' cannot be a Tensor\");\n      }\n\n      if (Array.isArray(arg1)) {\n        if (arg1.length === 0) {\n          throw new TypeError(\"'fetches' cannot be an empty array.\");\n        }\n        isFetchesEmpty = false;\n        // output names\n        for (const name of arg1) {\n          if (typeof name !== 'string') {\n            throw new TypeError(\"'fetches' must be a string array or an object.\");\n          }\n          if (this.outputNames.indexOf(name) === -1) {\n            throw new RangeError(`'fetches' contains invalid output name: ${name}.`);\n          }\n          fetches[name] = null;\n        }\n\n        if (typeof arg2 === 'object' && arg2 !== null) {\n          options = arg2;\n        } else if (typeof arg2 !== 'undefined') {\n          throw new TypeError(\"'options' must be an object.\");\n        }\n      } else {\n        // decide whether arg1 is fetches or options\n        // if any output name is present and its value is valid OnnxValue, we consider it fetches\n        let isFetches = false;\n        const arg1Keys = Object.getOwnPropertyNames(arg1);\n        for (const name of this.outputNames) {\n          if (arg1Keys.indexOf(name) !== -1) {\n            const v = (arg1 as InferenceSessionInterface.NullableOnnxValueMapType)[name];\n            if (v === null || v instanceof Tensor) {\n              isFetches = true;\n              isFetchesEmpty = false;\n              fetches[name] = v;\n            }\n          }\n        }\n\n        if (isFetches) {\n          if (typeof arg2 === 'object' && arg2 !== null) {\n            options = arg2;\n          } else if (typeof arg2 !== 'undefined') {\n            throw new TypeError(\"'options' must be an object.\");\n          }\n        } else {\n          options = arg1 as RunOptions;\n        }\n      }\n    } else if (typeof arg1 !== 'undefined') {\n      throw new TypeError(\"Unexpected argument[1]: must be 'fetches' or 'options'.\");\n    }\n\n    // check if all inputs are in feed\n    for (const name of this.inputNames) {\n      if (typeof feeds[name] === 'undefined') {\n        throw new Error(`input '${name}' is missing in 'feeds'.`);\n      }\n    }\n\n    // if no fetches is specified, we use the full output names list\n    if (isFetchesEmpty) {\n      for (const name of this.outputNames) {\n        fetches[name] = null;\n      }\n    }\n\n    // feeds, fetches and options are prepared\n\n    const results = await this.handler.run(feeds, fetches, options);\n    const returnValue: { [name: string]: OnnxValue } = {};\n    for (const key in results) {\n      if (Object.hasOwnProperty.call(results, key)) {\n        const result = results[key];\n        if (result instanceof Tensor) {\n          returnValue[key] = result;\n        } else {\n          returnValue[key] = new Tensor(result.type, result.data, result.dims);\n        }\n      }\n    }\n    TRACE_EVENT_END('InferenceSession.run');\n    TRACE_FUNC_END();\n    return returnValue;\n  }\n\n  async release(): Promise<void> {\n    return this.handler.dispose();\n  }\n\n  static create(path: string, options?: SessionOptions): Promise<InferenceSessionInterface>;\n  static create(buffer: ArrayBufferLike, options?: SessionOptions): Promise<InferenceSessionInterface>;\n  static create(\n    buffer: ArrayBufferLike,\n    byteOffset: number,\n    byteLength?: number,\n    options?: SessionOptions,\n  ): Promise<InferenceSessionInterface>;\n  static create(buffer: Uint8Array, options?: SessionOptions): Promise<InferenceSessionInterface>;\n  static async create(\n    arg0: string | ArrayBufferLike | Uint8Array,\n    arg1?: SessionOptions | number,\n    arg2?: number,\n    arg3?: SessionOptions,\n  ): Promise<InferenceSessionInterface> {\n    TRACE_FUNC_BEGIN();\n    TRACE_EVENT_BEGIN('InferenceSession.create');\n    // either load from a file or buffer\n    let filePathOrUint8Array: string | Uint8Array;\n    let options: SessionOptions = {};\n\n    if (typeof arg0 === 'string') {\n      filePathOrUint8Array = arg0;\n      if (typeof arg1 === 'object' && arg1 !== null) {\n        options = arg1;\n      } else if (typeof arg1 !== 'undefined') {\n        throw new TypeError(\"'options' must be an object.\");\n      }\n    } else if (arg0 instanceof Uint8Array) {\n      filePathOrUint8Array = arg0;\n      if (typeof arg1 === 'object' && arg1 !== null) {\n        options = arg1;\n      } else if (typeof arg1 !== 'undefined') {\n        throw new TypeError(\"'options' must be an object.\");\n      }\n    } else if (\n      arg0 instanceof ArrayBuffer ||\n      (typeof SharedArrayBuffer !== 'undefined' && arg0 instanceof SharedArrayBuffer)\n    ) {\n      const buffer = arg0;\n      let byteOffset = 0;\n      let byteLength = arg0.byteLength;\n      if (typeof arg1 === 'object' && arg1 !== null) {\n        options = arg1;\n      } else if (typeof arg1 === 'number') {\n        byteOffset = arg1;\n        if (!Number.isSafeInteger(byteOffset)) {\n          throw new RangeError(\"'byteOffset' must be an integer.\");\n        }\n        if (byteOffset < 0 || byteOffset >= buffer.byteLength) {\n          throw new RangeError(`'byteOffset' is out of range [0, ${buffer.byteLength}).`);\n        }\n        byteLength = arg0.byteLength - byteOffset;\n        if (typeof arg2 === 'number') {\n          byteLength = arg2;\n          if (!Number.isSafeInteger(byteLength)) {\n            throw new RangeError(\"'byteLength' must be an integer.\");\n          }\n          if (byteLength <= 0 || byteOffset + byteLength > buffer.byteLength) {\n            throw new RangeError(`'byteLength' is out of range (0, ${buffer.byteLength - byteOffset}].`);\n          }\n          if (typeof arg3 === 'object' && arg3 !== null) {\n            options = arg3;\n          } else if (typeof arg3 !== 'undefined') {\n            throw new TypeError(\"'options' must be an object.\");\n          }\n        } else if (typeof arg2 !== 'undefined') {\n          throw new TypeError(\"'byteLength' must be a number.\");\n        }\n      } else if (typeof arg1 !== 'undefined') {\n        throw new TypeError(\"'options' must be an object.\");\n      }\n      filePathOrUint8Array = new Uint8Array(buffer, byteOffset, byteLength);\n    } else {\n      throw new TypeError(\"Unexpected argument[0]: must be 'path' or 'buffer'.\");\n    }\n\n    // resolve backend, update session options with validated EPs, and create session handler\n    const [backend, optionsWithValidatedEPs] = await resolveBackendAndExecutionProviders(options);\n    const handler = await backend.createInferenceSessionHandler(filePathOrUint8Array, optionsWithValidatedEPs);\n    TRACE_EVENT_END('InferenceSession.create');\n    TRACE_FUNC_END();\n    return new InferenceSession(handler);\n  }\n\n  startProfiling(): void {\n    this.handler.startProfiling();\n  }\n  endProfiling(): void {\n    this.handler.endProfiling();\n  }\n\n  get inputNames(): readonly string[] {\n    return this.handler.inputNames;\n  }\n  get outputNames(): readonly string[] {\n    return this.handler.outputNames;\n  }\n\n  get inputMetadata(): readonly InferenceSessionInterface.ValueMetadata[] {\n    return this.handler.inputMetadata;\n  }\n\n  get outputMetadata(): readonly InferenceSessionInterface.ValueMetadata[] {\n    return this.handler.outputMetadata;\n  }\n\n  private handler: InferenceSessionHandler;\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { InferenceSession as InferenceSessionImpl } from './inference-session-impl.js';\nimport { OnnxModelOptions } from './onnx-model.js';\nimport { OnnxValue, OnnxValueDataLocation } from './onnx-value.js';\nimport type { Tensor } from './tensor.js';\nimport { TryGetGlobalType } from './type-helper.js';\n\n/* eslint-disable @typescript-eslint/no-redeclare */\n\nexport declare namespace InferenceSession {\n  // #region input/output types\n\n  type OnnxValueMapType = { readonly [name: string]: OnnxValue };\n  type NullableOnnxValueMapType = { readonly [name: string]: OnnxValue | null };\n\n  /**\n   * A feeds (model inputs) is an object that uses input names as keys and OnnxValue as corresponding values.\n   */\n  type FeedsType = OnnxValueMapType;\n\n  /**\n   * A fetches (model outputs) could be one of the following:\n   *\n   * - Omitted. Use model's output names definition.\n   * - An array of string indicating the output names.\n   * - An object that use output names as keys and OnnxValue or null as corresponding values.\n   *\n   * @remarks\n   * different from input argument, in output, OnnxValue is optional. If an OnnxValue is present it will be\n   * used as a pre-allocated value by the inference engine; if omitted, inference engine will allocate buffer\n   * internally.\n   */\n  type FetchesType = readonly string[] | NullableOnnxValueMapType;\n\n  /**\n   * A inferencing return type is an object that uses output names as keys and OnnxValue as corresponding values.\n   */\n  type ReturnType = OnnxValueMapType;\n\n  // #endregion\n\n  // #region session options\n\n  /**\n   * A set of configurations for session behavior.\n   */\n  export interface SessionOptions extends OnnxModelOptions {\n    /**\n     * An array of execution provider options.\n     *\n     * An execution provider option can be a string indicating the name of the execution provider,\n     * or an object of corresponding type.\n     */\n    executionProviders?: readonly ExecutionProviderConfig[];\n\n    /**\n     * The intra OP threads number.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native).\n     */\n    intraOpNumThreads?: number;\n\n    /**\n     * The inter OP threads number.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native).\n     */\n    interOpNumThreads?: number;\n\n    /**\n     * The free dimension override.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    freeDimensionOverrides?: { readonly [dimensionName: string]: number };\n\n    /**\n     * The optimization level.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    graphOptimizationLevel?: 'disabled' | 'basic' | 'extended' | 'layout' | 'all';\n\n    /**\n     * Whether enable CPU memory arena.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    enableCpuMemArena?: boolean;\n\n    /**\n     * Whether enable memory pattern.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    enableMemPattern?: boolean;\n\n    /**\n     * Execution mode.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    executionMode?: 'sequential' | 'parallel';\n\n    /**\n     * Optimized model file path.\n     *\n     * If this setting is specified, the optimized model will be dumped. In browser, a blob will be created\n     * with a pop-up window.\n     */\n    optimizedModelFilePath?: string;\n\n    /**\n     * Whether enable profiling.\n     *\n     * This setting is a placeholder for a future use.\n     */\n    enableProfiling?: boolean;\n\n    /**\n     * File prefix for profiling.\n     *\n     * This setting is a placeholder for a future use.\n     */\n    profileFilePrefix?: string;\n\n    /**\n     * Log ID.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    logId?: string;\n\n    /**\n     * Log severity level. See\n     * https://github.com/microsoft/onnxruntime/blob/main/include/onnxruntime/core/common/logging/severity.h\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    logSeverityLevel?: 0 | 1 | 2 | 3 | 4;\n\n    /**\n     * Log verbosity level.\n     *\n     * This setting is available only in WebAssembly backend. Will support Node.js binding and react-native later\n     */\n    logVerbosityLevel?: number;\n\n    /**\n     * Specify string as a preferred data location for all outputs, or an object that use output names as keys and a\n     * preferred data location as corresponding values.\n     *\n     * This setting is available only in ONNXRuntime Web for WebGL and WebGPU EP.\n     */\n    preferredOutputLocation?: OnnxValueDataLocation | { readonly [outputName: string]: OnnxValueDataLocation };\n\n    /**\n     * Whether enable graph capture.\n     * This setting is available only in ONNXRuntime Web for WebGPU EP.\n     */\n    enableGraphCapture?: boolean;\n\n    /**\n     * Store configurations for a session. See\n     * https://github.com/microsoft/onnxruntime/blob/main/include/onnxruntime/core/session/\n     * onnxruntime_session_options_config_keys.h\n     *\n     * This setting is available only in WebAssembly backend. Will support Node.js binding and react-native later\n     *\n     * @example\n     * ```js\n     * extra: {\n     *   session: {\n     *     set_denormal_as_zero: \"1\",\n     *     disable_prepacking: \"1\"\n     *   },\n     *   optimization: {\n     *     enable_gelu_approximation: \"1\"\n     *   }\n     * }\n     * ```\n     */\n    extra?: Record<string, unknown>;\n  }\n\n  // #region execution providers\n\n  // Currently, we have the following backends to support execution providers:\n  // Backend Node.js binding: supports 'cpu', 'dml' (win32), 'coreml' (macOS) and 'cuda' (linux).\n  // Backend WebAssembly: supports 'cpu', 'wasm', 'webgpu' and 'webnn'.\n  // Backend ONNX.js: supports 'webgl'.\n  // Backend React Native: supports 'cpu', 'xnnpack', 'coreml' (iOS), 'nnapi' (Android).\n  interface ExecutionProviderOptionMap {\n    coreml: CoreMLExecutionProviderOption;\n    cpu: CpuExecutionProviderOption;\n    cuda: CudaExecutionProviderOption;\n    dml: DmlExecutionProviderOption;\n    nnapi: NnapiExecutionProviderOption;\n    tensorrt: TensorRtExecutionProviderOption;\n    wasm: WebAssemblyExecutionProviderOption;\n    webgl: WebGLExecutionProviderOption;\n    webgpu: WebGpuExecutionProviderOption;\n    webnn: WebNNExecutionProviderOption;\n    qnn: QnnExecutionProviderOption;\n    xnnpack: XnnpackExecutionProviderOption;\n  }\n\n  type ExecutionProviderName = keyof ExecutionProviderOptionMap;\n  type ExecutionProviderConfig =\n    | ExecutionProviderOptionMap[ExecutionProviderName]\n    | ExecutionProviderOption\n    | ExecutionProviderName\n    | string;\n\n  export interface ExecutionProviderOption {\n    readonly name: string;\n  }\n  export interface CpuExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'cpu';\n    useArena?: boolean;\n  }\n  export interface CudaExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'cuda';\n    deviceId?: number;\n  }\n  export interface DmlExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'dml';\n    deviceId?: number;\n  }\n  export interface TensorRtExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'tensorrt';\n    deviceId?: number;\n  }\n  export interface WebAssemblyExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'wasm';\n  }\n  export interface WebGLExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'webgl';\n    // TODO: add flags\n  }\n  export interface XnnpackExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'xnnpack';\n  }\n  export interface WebGpuExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'webgpu';\n\n    /**\n     * Specify the preferred layout when running layout sensitive operators.\n     *\n     * @default 'NCHW'\n     */\n    preferredLayout?: 'NCHW' | 'NHWC';\n\n    /**\n     * Specify a list of node names that should be executed on CPU even when WebGPU EP is used.\n     */\n    forceCpuNodeNames?: readonly string[];\n\n    /**\n     * Specify the validation mode for WebGPU execution provider.\n     * - 'disabled': Disable all validation.\n     * When used in Node.js, disable validation may cause process crash if WebGPU errors occur. Be cautious when using\n     * this mode.\n     * When used in web, this mode is equivalent to 'wgpuOnly'.\n     * - 'wgpuOnly': Perform WebGPU internal validation only.\n     * - 'basic': Perform basic validation including WebGPU internal validation. This is the default mode.\n     * - 'full': Perform full validation. This mode may have performance impact. Use it for debugging purpose.\n     *\n     * @default 'basic'\n     */\n    validationMode?: 'disabled' | 'wgpuOnly' | 'basic' | 'full';\n\n    /**\n     * Enable robust buffer access for an ORT-created Dawn device. This is a global, first-device-wins option. Later\n     * conflicting values and values supplied with an external device are ignored with a warning.\n     *\n     * This setting is available only in ONNX Runtime (Node.js binding).\n     *\n     * @default `true` in Debug builds; `false` in Release and RelWithDebInfo builds\n     */\n    enableRobustness?: boolean;\n\n    /**\n     * Specify the cache mode for storage buffers.\n     * - 'disabled': Disable buffer cache. Buffers are destroyed when no longer in use.\n     * - 'lazyRelease': Buffers are released lazily, at the end of the current run.\n     * - 'simple': Released buffers are cached and reused only for requests of the exact same size.\n     * - 'bucket': Released buffers are cached and reused using predefined size buckets. This is the default mode.\n     *\n     * For static-shape models, 'simple' may reduce GPU memory usage, because exact-size buffers are reused across\n     * runs instead of allocating new bucket-sized buffers.\n     *\n     * @default 'bucket'\n     */\n    storageBufferCacheMode?: 'disabled' | 'lazyRelease' | 'simple' | 'bucket';\n\n    /**\n     * Specify the cache mode for uniform buffers.\n     *\n     * See {@link storageBufferCacheMode} for a description of the available modes.\n     *\n     * @default 'simple'\n     */\n    uniformBufferCacheMode?: 'disabled' | 'lazyRelease' | 'simple' | 'bucket';\n\n    /**\n     * Specify the cache mode for query resolve buffers.\n     *\n     * See {@link storageBufferCacheMode} for a description of the available modes.\n     *\n     * @default 'disabled'\n     */\n    queryResolveBufferCacheMode?: 'disabled' | 'lazyRelease' | 'simple' | 'bucket';\n\n    /**\n     * Specify the cache mode for buffers not covered by the other buffer cache mode options.\n     *\n     * See {@link storageBufferCacheMode} for a description of the available modes.\n     *\n     * @default 'disabled'\n     */\n    defaultBufferCacheMode?: 'disabled' | 'lazyRelease' | 'simple' | 'bucket';\n\n    /**\n     * Specify an optional WebGPU device to be used by the WebGPU execution provider.\n     */\n    device?: TryGetGlobalType<'GPUDevice'>;\n  }\n\n  // #region WebNN options\n\n  interface WebNNExecutionProviderName extends ExecutionProviderOption {\n    readonly name: 'webnn';\n  }\n\n  /**\n   * Represents a set of options for creating a WebNN MLContext.\n   *\n   * @see https://www.w3.org/TR/webnn/#dictdef-mlcontextoptions\n   */\n  export interface WebNNContextOptions {\n    deviceType?: 'cpu' | 'gpu' | 'npu';\n    numThreads?: number;\n    powerPreference?: 'default' | 'low-power' | 'high-performance';\n  }\n\n  /**\n   * Represents a set of options for WebNN execution provider without MLContext.\n   */\n  export interface WebNNOptionsWithoutMLContext extends WebNNExecutionProviderName, WebNNContextOptions {\n    context?: never;\n  }\n\n  /**\n   * Represents a set of options for WebNN execution provider with MLContext.\n   *\n   * When MLContext is provided, the deviceType is also required so that the WebNN EP can determine the preferred\n   * channel layout.\n   *\n   * @see https://www.w3.org/TR/webnn/#dom-ml-createcontext\n   */\n  export interface WebNNOptionsWithMLContext\n    extends\n      WebNNExecutionProviderName,\n      Omit<WebNNContextOptions, 'deviceType'>,\n      Required<Pick<WebNNContextOptions, 'deviceType'>> {\n    context: TryGetGlobalType<'MLContext'>;\n  }\n\n  /**\n   * Represents a set of options for WebNN execution provider with MLContext which is created from GPUDevice.\n   *\n   * @see https://www.w3.org/TR/webnn/#dom-ml-createcontext-gpudevice\n   */\n  export interface WebNNOptionsWebGpu extends WebNNExecutionProviderName {\n    context: TryGetGlobalType<'MLContext'>;\n    gpuDevice: TryGetGlobalType<'GPUDevice'>;\n  }\n\n  /**\n   * Options for WebNN execution provider.\n   */\n  export type WebNNExecutionProviderOption =\n    | WebNNOptionsWithoutMLContext\n    | WebNNOptionsWithMLContext\n    | WebNNOptionsWebGpu;\n\n  // #endregion\n\n  export interface QnnExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'qnn';\n    /**\n     * Specify the QNN backend type. E.g., 'cpu' or 'htp'.\n     * Mutually exclusive with `backendPath`.\n     *\n     * @default 'htp'\n     */\n    backendType?: string;\n    /**\n     * Specify a path to the QNN backend library.\n     * Mutually exclusive with `backendType`.\n     */\n    backendPath?: string;\n    /**\n     * Specify whether to enable HTP FP16 precision.\n     *\n     * @default true\n     */\n    enableFp16Precision?: boolean;\n  }\n  export interface CoreMLExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'coreml';\n    /**\n     * The bit flags for CoreML execution provider.\n     *\n     * ```\n     * COREML_FLAG_USE_CPU_ONLY = 0x001\n     * COREML_FLAG_ENABLE_ON_SUBGRAPH = 0x002\n     * COREML_FLAG_ONLY_ENABLE_DEVICE_WITH_ANE = 0x004\n     * COREML_FLAG_ONLY_ALLOW_STATIC_INPUT_SHAPES = 0x008\n     * COREML_FLAG_CREATE_MLPROGRAM = 0x010\n     * COREML_FLAG_USE_CPU_AND_GPU = 0x020\n     * ```\n     *\n     * See include/onnxruntime/core/providers/coreml/coreml_provider_factory.h for more details.\n     *\n     * This flag is available only in ONNXRuntime (Node.js binding).\n     */\n    coreMlFlags?: number;\n    /**\n     * Specify whether to use CPU only in CoreML EP.\n     *\n     * This setting is available only in ONNXRuntime (react-native).\n     */\n    useCPUOnly?: boolean;\n    useCPUAndGPU?: boolean;\n    /**\n     * Specify whether to enable CoreML EP on subgraph.\n     *\n     * This setting is available only in ONNXRuntime (react-native).\n     */\n    enableOnSubgraph?: boolean;\n    /**\n     * Specify whether to only enable CoreML EP for Apple devices with ANE (Apple Neural Engine).\n     *\n     * This setting is available only in ONNXRuntime (react-native).\n     */\n    onlyEnableDeviceWithANE?: boolean;\n  }\n  export interface NnapiExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'nnapi';\n    useFP16?: boolean;\n    useNCHW?: boolean;\n    cpuDisabled?: boolean;\n    cpuOnly?: boolean;\n  }\n  // #endregion\n\n  // #endregion\n\n  // #region run options\n\n  /**\n   * A set of configurations for inference run behavior\n   */\n  export interface RunOptions {\n    /**\n     * Log severity level. See\n     * https://github.com/microsoft/onnxruntime/blob/main/include/onnxruntime/core/common/logging/severity.h\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    logSeverityLevel?: 0 | 1 | 2 | 3 | 4;\n\n    /**\n     * Log verbosity level.\n     *\n     * This setting is available only in WebAssembly backend. Will support Node.js binding and react-native later\n     */\n    logVerbosityLevel?: number;\n\n    /**\n     * Terminate all incomplete OrtRun calls as soon as possible if true\n     *\n     * This setting is available only in WebAssembly backend. Will support Node.js binding and react-native later\n     */\n    terminate?: boolean;\n\n    /**\n     * A tag for the Run() calls using this\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    tag?: string;\n\n    /**\n     * Set a single run configuration entry. See\n     * https://github.com/microsoft/onnxruntime/blob/main/include/onnxruntime/core/session/\n     * onnxruntime_run_options_config_keys.h\n     *\n     * This setting is available only in WebAssembly backend. Will support Node.js binding and react-native later\n     *\n     * @example\n     *\n     * ```js\n     * extra: {\n     *   memory: {\n     *     enable_memory_arena_shrinkage: \"1\",\n     *   }\n     * }\n     * ```\n     */\n    extra?: Record<string, unknown>;\n  }\n\n  // #endregion\n\n  // #region value metadata\n\n  /**\n   * The common part of the value metadata type for both tensor and non-tensor values.\n   */\n  export interface ValueMetadataBase {\n    /**\n     * The name of the specified input or output.\n     */\n    readonly name: string;\n  }\n\n  /**\n   * Represents the metadata of a non-tensor value.\n   */\n  export interface NonTensorValueMetadata extends ValueMetadataBase {\n    /**\n     * Get a value indicating whether the value is a tensor.\n     */\n    readonly isTensor: false;\n  }\n\n  /**\n   * Represents the metadata of a tensor value.\n   */\n  export interface TensorValueMetadata extends ValueMetadataBase {\n    /**\n     * Get a value indicating whether the value is a tensor.\n     */\n    readonly isTensor: true;\n    /**\n     * Get the data type of the tensor.\n     */\n    readonly type: Tensor.Type;\n    /**\n     * Get the shape of the tensor.\n     *\n     * If the shape is not defined, the value will an empty array. Otherwise, it will be an array representing the shape\n     * of the tensor. Each element in the array can be a number or a string. If the element is a number, it represents\n     * the corresponding dimension size. If the element is a string, it represents a symbolic dimension.\n     */\n    readonly shape: ReadonlyArray<number | string>;\n  }\n\n  /**\n   * Represents the metadata of a value.\n   */\n  export type ValueMetadata = NonTensorValueMetadata | TensorValueMetadata;\n\n  // #endregion\n}\n\n/**\n * Represent a runtime instance of an ONNX model.\n */\nexport interface InferenceSession {\n  // #region run()\n\n  /**\n   * Execute the model asynchronously with the given feeds and options.\n   *\n   * @param feeds - Representation of the model input. See type description of `InferenceSession.InputType` for detail.\n   * @param options - Optional. A set of options that controls the behavior of model inference.\n   * @returns A promise that resolves to a map, which uses output names as keys and OnnxValue as corresponding values.\n   */\n  run(feeds: InferenceSession.FeedsType, options?: InferenceSession.RunOptions): Promise<InferenceSession.ReturnType>;\n\n  /**\n   * Execute the model asynchronously with the given feeds, fetches and options.\n   *\n   * @param feeds - Representation of the model input. See type description of `InferenceSession.InputType` for detail.\n   * @param fetches - Representation of the model output. See type description of `InferenceSession.OutputType` for\n   * detail.\n   * @param options - Optional. A set of options that controls the behavior of model inference.\n   * @returns A promise that resolves to a map, which uses output names as keys and OnnxValue as corresponding values.\n   */\n  run(\n    feeds: InferenceSession.FeedsType,\n    fetches: InferenceSession.FetchesType,\n    options?: InferenceSession.RunOptions,\n  ): Promise<InferenceSession.ReturnType>;\n\n  // #endregion\n\n  // #region release()\n\n  /**\n   * Release the inference session and the underlying resources.\n   */\n  release(): Promise<void>;\n\n  // #endregion\n\n  // #region profiling\n\n  /**\n   * Start profiling.\n   */\n  startProfiling(): void;\n\n  /**\n   * End profiling.\n   */\n  endProfiling(): void;\n\n  // #endregion\n\n  // #region metadata\n\n  /**\n   * Get input names of the loaded model.\n   */\n  readonly inputNames: readonly string[];\n\n  /**\n   * Get output names of the loaded model.\n   */\n  readonly outputNames: readonly string[];\n\n  /**\n   * Get input metadata of the loaded model.\n   */\n  readonly inputMetadata: readonly InferenceSession.ValueMetadata[];\n\n  /**\n   * Get output metadata of the loaded model.\n   */\n  readonly outputMetadata: readonly InferenceSession.ValueMetadata[];\n\n  // #endregion\n}\n\nexport interface InferenceSessionFactory {\n  // #region create()\n\n  /**\n   * Create a new inference session and load model asynchronously from an ONNX model file.\n   *\n   * @param uri - The URI or file path of the model to load.\n   * @param options - specify configuration for creating a new inference session.\n   * @returns A promise that resolves to an InferenceSession object.\n   */\n  create(uri: string, options?: InferenceSession.SessionOptions): Promise<InferenceSession>;\n\n  /**\n   * Create a new inference session and load model asynchronously from an array bufer.\n   *\n   * @param buffer - An ArrayBuffer representation of an ONNX model.\n   * @param options - specify configuration for creating a new inference session.\n   * @returns A promise that resolves to an InferenceSession object.\n   */\n  create(buffer: ArrayBufferLike, options?: InferenceSession.SessionOptions): Promise<InferenceSession>;\n\n  /**\n   * Create a new inference session and load model asynchronously from segment of an array bufer.\n   *\n   * @param buffer - An ArrayBuffer representation of an ONNX model.\n   * @param byteOffset - The beginning of the specified portion of the array buffer.\n   * @param byteLength - The length in bytes of the array buffer.\n   * @param options - specify configuration for creating a new inference session.\n   * @returns A promise that resolves to an InferenceSession object.\n   */\n  create(\n    buffer: ArrayBufferLike,\n    byteOffset: number,\n    byteLength?: number,\n    options?: InferenceSession.SessionOptions,\n  ): Promise<InferenceSession>;\n\n  /**\n   * Create a new inference session and load model asynchronously from a Uint8Array.\n   *\n   * @param buffer - A Uint8Array representation of an ONNX model.\n   * @param options - specify configuration for creating a new inference session.\n   * @returns A promise that resolves to an InferenceSession object.\n   */\n  create(buffer: Uint8Array, options?: InferenceSession.SessionOptions): Promise<InferenceSession>;\n\n  // #endregion\n}\n\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const InferenceSession: InferenceSessionFactory = InferenceSessionImpl;\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { OptionsFormat, OptionsNormalizationParameters, OptionsTensorLayout } from './tensor-factory.js';\n\nexport interface TensorToDataUrlOptions extends OptionsTensorLayout, OptionsFormat, OptionsNormalizationParameters {}\n\nexport interface TensorToImageDataOptions extends OptionsTensorLayout, OptionsFormat, OptionsNormalizationParameters {}\n\nexport interface ConversionUtils {\n  /**\n   * creates a DataURL instance from tensor\n   *\n   * @param options - An optional object representing options for creating a DataURL instance from the tensor.\n   *\n   * The following default settings will be applied:\n   * - `format`: `'RGB'`\n   * - `tensorLayout`: `'NCHW'`\n   * @returns a DataURL string representing the image converted from tensor data\n   */\n  toDataURL(options?: TensorToDataUrlOptions): string;\n\n  /**\n   * creates an ImageData instance from tensor\n   *\n   * @param options - An optional object representing options for creating an ImageData instance from the tensor.\n   *\n   * The following default settings will be applied:\n   * - `format`: `'RGB'`\n   * - `tensorLayout`: `'NCHW'`\n   * @returns an ImageData instance representing the image converted from tensor data\n   */\n  toImageData(options?: TensorToImageDataOptions): ImageData;\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Tensor, TypedTensor } from './tensor.js';\n\nexport type ImageFormat = 'RGB' | 'RGBA' | 'BGR' | 'RBG';\nexport type ImageTensorLayout = 'NHWC' | 'NCHW';\n\n// the following region contains type definitions for constructing tensor from a specific location.\n\n// #region types for constructing a tensor from a specific location\n\n/**\n * represent common properties of the parameter for constructing a tensor from a specific location.\n */\ninterface CommonConstructorParameters<T> extends Pick<Tensor, 'dims'> {\n  /**\n   * Specify the data type of the tensor.\n   */\n  readonly type: T;\n}\n\n/**\n * represent the parameter for constructing a tensor from a GPU resource.\n */\ninterface GpuResourceConstructorParameters<T extends Tensor.Type> {\n  /**\n   * an optional callback function to download data from GPU to CPU.\n   *\n   * If not provided, the tensor treat the GPU data as external resource.\n   */\n  download?(): Promise<Tensor.DataTypeMap[T]>;\n\n  /**\n   * an optional callback function that will be called when the tensor is disposed.\n   *\n   * If not provided, the tensor treat the GPU data as external resource.\n   */\n  dispose?(): void;\n}\n\n/**\n * represent the parameter for constructing a tensor from a pinned CPU buffer\n */\nexport interface CpuPinnedConstructorParameters<\n  T extends Tensor.CpuPinnedDataTypes = Tensor.CpuPinnedDataTypes,\n> extends CommonConstructorParameters<T> {\n  /**\n   * Specify the location of the data to be 'cpu-pinned'.\n   */\n  readonly location: 'cpu-pinned';\n  /**\n   * Specify the CPU pinned buffer that holds the tensor data.\n   */\n  readonly data: Tensor.DataTypeMap[T];\n}\n\n/**\n * represent the parameter for constructing a tensor from a WebGL texture\n */\nexport interface TextureConstructorParameters<T extends Tensor.TextureDataTypes = Tensor.TextureDataTypes>\n  extends CommonConstructorParameters<T>, GpuResourceConstructorParameters<T> {\n  /**\n   * Specify the location of the data to be 'texture'.\n   */\n  readonly location: 'texture';\n  /**\n   * Specify the WebGL texture that holds the tensor data.\n   */\n  readonly texture: Tensor.TextureType;\n}\n\n/**\n * represent the parameter for constructing a tensor from a WebGPU buffer\n */\nexport interface GpuBufferConstructorParameters<T extends Tensor.GpuBufferDataTypes = Tensor.GpuBufferDataTypes>\n  extends CommonConstructorParameters<T>, GpuResourceConstructorParameters<T> {\n  /**\n   * Specify the location of the data to be 'gpu-buffer'.\n   */\n  readonly location: 'gpu-buffer';\n  /**\n   * Specify the WebGPU buffer that holds the tensor data.\n   */\n  readonly gpuBuffer: Tensor.GpuBufferType;\n}\n\nexport interface MLTensorConstructorParameters<T extends Tensor.MLTensorDataTypes = Tensor.MLTensorDataTypes>\n  extends CommonConstructorParameters<T>, GpuResourceConstructorParameters<T> {\n  /**\n   * Specify the location of the data to be 'ml-tensor'.\n   */\n  readonly location: 'ml-tensor';\n\n  /**\n   * Specify the WebNN MLTensor that holds the tensor data.\n   */\n  readonly mlTensor: Tensor.MLTensorType;\n}\n\n// #endregion\n\n// the following region contains type definitions of each individual options.\n// the tensor factory functions use a composition of those options as the parameter type.\n\n// #region Options fields\n\nexport interface OptionsFormat {\n  /**\n   * Describes the image format represented in RGBA color space.\n   */\n  format?: ImageFormat;\n}\n\nexport interface OptionsTensorFormat {\n  /**\n   * Describes the image format of the tensor.\n   *\n   * NOTE: this is different from option 'format'. While option 'format' represents the original image, 'tensorFormat'\n   * represents the target format of the tensor. A transpose will be performed if they are different.\n   */\n  tensorFormat?: ImageFormat;\n}\n\nexport interface OptionsTensorDataType {\n  /**\n   * Describes the data type of the tensor.\n   */\n  dataType?: 'float32' | 'uint8';\n}\n\nexport interface OptionsTensorLayout {\n  /**\n   * Describes the tensor layout when representing data of one or more image(s).\n   */\n  tensorLayout?: ImageTensorLayout;\n}\n\nexport interface OptionsDimensions {\n  /**\n   * Describes the image height in pixel\n   */\n  height?: number;\n  /**\n   * Describes the image width in pixel\n   */\n  width?: number;\n}\n\nexport interface OptionResizedDimensions {\n  /**\n   * Describes the resized height. If omitted, original height will be used.\n   */\n  resizedHeight?: number;\n  /**\n   * Describes resized width - can be accessed via tensor dimensions as well\n   */\n  resizedWidth?: number;\n}\n\nexport interface OptionsNormalizationParameters {\n  /**\n   * Describes normalization parameters when preprocessing the image as model input.\n   *\n   * Data element are ranged from 0 to 255.\n   */\n  norm?: {\n    /**\n     * The 'bias' value for image normalization.\n     * - If omitted, use default value 0.\n     * - If it's a single number, apply to each channel\n     * - If it's an array of 3 or 4 numbers, apply element-wise. Number of elements need to match the number of channels\n     * for the corresponding image format\n     */\n    bias?: number | [number, number, number] | [number, number, number, number];\n    /**\n     * The 'mean' value for image normalization.\n     * - If omitted, use default value 255.\n     * - If it's a single number, apply to each channel\n     * - If it's an array of 3 or 4 numbers, apply element-wise. Number of elements need to match the number of channels\n     * for the corresponding image format\n     */\n    mean?: number | [number, number, number] | [number, number, number, number];\n  };\n}\n\n// #endregion\n\n// #region Options composition\n\nexport interface TensorFromImageDataOptions\n  extends\n    OptionResizedDimensions,\n    OptionsTensorFormat,\n    OptionsTensorLayout,\n    OptionsTensorDataType,\n    OptionsNormalizationParameters {}\n\nexport interface TensorFromImageElementOptions\n  extends\n    OptionResizedDimensions,\n    OptionsTensorFormat,\n    OptionsTensorLayout,\n    OptionsTensorDataType,\n    OptionsNormalizationParameters {}\n\nexport interface TensorFromUrlOptions\n  extends\n    OptionsDimensions,\n    OptionResizedDimensions,\n    OptionsTensorFormat,\n    OptionsTensorLayout,\n    OptionsTensorDataType,\n    OptionsNormalizationParameters {}\n\nexport interface TensorFromImageBitmapOptions\n  extends\n    OptionResizedDimensions,\n    OptionsTensorFormat,\n    OptionsTensorLayout,\n    OptionsTensorDataType,\n    OptionsNormalizationParameters {}\n\nexport interface TensorFromTextureOptions<T extends Tensor.TextureDataTypes>\n  extends Required<OptionsDimensions>, OptionsFormat, GpuResourceConstructorParameters<T> /* TODO: add more */ {}\n\nexport interface TensorFromGpuBufferOptions<T extends Tensor.GpuBufferDataTypes>\n  extends Pick<Tensor, 'dims'>, GpuResourceConstructorParameters<T> {\n  /**\n   * Describes the data type of the tensor.\n   */\n  dataType?: T;\n}\n\nexport interface TensorFromMLTensorOptions<T extends Tensor.MLTensorDataTypes>\n  extends Pick<Tensor, 'dims'>, GpuResourceConstructorParameters<T> {\n  /**\n   * Describes the data type of the tensor.\n   */\n  dataType?: T;\n}\n\n// #endregion\n\n/**\n * type TensorFactory defines the factory functions of 'Tensor' to create tensor instances from existing data or\n * resources.\n */\nexport interface TensorFactory {\n  /**\n   * create a tensor from an ImageData object\n   *\n   * @param imageData - the ImageData object to create tensor from\n   * @param options - An optional object representing options for creating tensor from ImageData.\n   *\n   * The following default settings will be applied:\n   * - `tensorFormat`: `'RGB'`\n   * - `tensorLayout`: `'NCHW'`\n   * - `dataType`: `'float32'`\n   * @returns A promise that resolves to a tensor object\n   */\n  fromImage(\n    imageData: ImageData,\n    options?: TensorFromImageDataOptions,\n  ): Promise<TypedTensor<'float32'> | TypedTensor<'uint8'>>;\n\n  /**\n   * create a tensor from a HTMLImageElement object\n   *\n   * @param imageElement - the HTMLImageElement object to create tensor from\n   * @param options - An optional object representing options for creating tensor from HTMLImageElement.\n   *\n   * The following default settings will be applied:\n   * - `tensorFormat`: `'RGB'`\n   * - `tensorLayout`: `'NCHW'`\n   * - `dataType`: `'float32'`\n   * @returns A promise that resolves to a tensor object\n   */\n  fromImage(\n    imageElement: HTMLImageElement,\n    options?: TensorFromImageElementOptions,\n  ): Promise<TypedTensor<'float32'> | TypedTensor<'uint8'>>;\n\n  /**\n   * create a tensor from URL\n   *\n   * @param urlSource - a string as a URL to the image or a data URL containing the image data.\n   * @param options - An optional object representing options for creating tensor from URL.\n   *\n   * The following default settings will be applied:\n   * - `tensorFormat`: `'RGB'`\n   * - `tensorLayout`: `'NCHW'`\n   * - `dataType`: `'float32'`\n   * @returns A promise that resolves to a tensor object\n   */\n  fromImage(urlSource: string, options?: TensorFromUrlOptions): Promise<TypedTensor<'float32'> | TypedTensor<'uint8'>>;\n\n  /**\n   * create a tensor from an ImageBitmap object\n   *\n   * @param bitmap - the ImageBitmap object to create tensor from\n   * @param options - An optional object representing options for creating tensor from URL.\n   *\n   * The following default settings will be applied:\n   * - `tensorFormat`: `'RGB'`\n   * - `tensorLayout`: `'NCHW'`\n   * - `dataType`: `'float32'`\n   * @returns A promise that resolves to a tensor object\n   */\n  fromImage(\n    bitmap: ImageBitmap,\n    options: TensorFromImageBitmapOptions,\n  ): Promise<TypedTensor<'float32'> | TypedTensor<'uint8'>>;\n\n  /**\n   * create a tensor from a WebGL texture\n   *\n   * @param texture - the WebGLTexture object to create tensor from\n   * @param options - An optional object representing options for creating tensor from WebGL texture.\n   *\n   * The options include following properties:\n   * - `width`: the width of the texture. Required.\n   * - `height`: the height of the texture. Required.\n   * - `format`: the format of the texture. If omitted, assume 'RGBA'.\n   * - `download`: an optional function to download the tensor data from GPU to CPU. If omitted, the GPU data\n   * will not be able to download. Usually, this is provided by a GPU backend for the inference outputs. Users don't\n   * need to provide this function.\n   * - `dispose`: an optional function to dispose the tensor data on GPU. If omitted, the GPU data will not be disposed.\n   * Usually, this is provided by a GPU backend for the inference outputs. Users don't need to provide this function.\n   *\n   * @returns a tensor object\n   */\n  fromTexture<T extends Tensor.TextureDataTypes = 'float32'>(\n    texture: Tensor.TextureType,\n    options: TensorFromTextureOptions<T>,\n  ): TypedTensor<'float32'>;\n\n  /**\n   * create a tensor from a WebGPU buffer\n   *\n   * @param buffer - the GPUBuffer object to create tensor from\n   * @param options - An optional object representing options for creating tensor from WebGPU buffer.\n   *\n   * The options include following properties:\n   * - `dataType`: the data type of the tensor. If omitted, assume 'float32'.\n   * - `dims`: the dimension of the tensor. Required.\n   * - `download`: an optional function to download the tensor data from GPU to CPU. If omitted, the GPU data\n   * will not be able to download. Usually, this is provided by a GPU backend for the inference outputs. Users don't\n   * need to provide this function.\n   * - `dispose`: an optional function to dispose the tensor data on GPU. If omitted, the GPU data will not be disposed.\n   * Usually, this is provided by a GPU backend for the inference outputs. Users don't need to provide this function.\n   *\n   * @returns a tensor object\n   */\n  fromGpuBuffer<T extends Tensor.GpuBufferDataTypes>(\n    buffer: Tensor.GpuBufferType,\n    options: TensorFromGpuBufferOptions<T>,\n  ): TypedTensor<T>;\n\n  /**\n   * create a tensor from a WebNN MLTensor\n   *\n   * @param tensor - the MLTensor object to create tensor from\n   * @param options - An optional object representing options for creating tensor from a WebNN MLTensor.\n   *\n   * The options include following properties:\n   * - `dataType`: the data type of the tensor. If omitted, assume 'float32'.\n   * - `dims`: the dimension of the tensor. Required.\n   * - `download`: an optional function to download the tensor data from the MLTensor to CPU. If omitted, the MLTensor\n   * data will not be able to download. Usually, this is provided by the WebNN backend for the inference outputs.\n   * Users don't need to provide this function.\n   * - `dispose`: an optional function to dispose the tensor data on the WebNN MLTensor. If omitted, the MLTensor will\n   * not be disposed. Usually, this is provided by the WebNN backend for the inference outputs. Users don't need to\n   * provide this function.\n   *\n   * @returns a tensor object\n   */\n  fromMLTensor<T extends Tensor.MLTensorDataTypes>(\n    tensor: Tensor.MLTensorType,\n    options: TensorFromMLTensorOptions<T>,\n  ): TypedTensor<T>;\n\n  /**\n   * create a tensor from a pre-allocated buffer. The buffer will be used as a pinned buffer.\n   *\n   * @param type - the tensor element type.\n   * @param buffer - a TypedArray corresponding to the type.\n   * @param dims - specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   *\n   * @returns a tensor object\n   */\n  fromPinnedBuffer<T extends Exclude<Tensor.Type, 'string'>>(\n    type: T,\n    buffer: Tensor.DataTypeMap[T],\n    dims?: readonly number[],\n  ): TypedTensor<T>;\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n/**\n * A string that represents a file's URL or path.\n *\n * Path is vailable only in onnxruntime-node or onnxruntime-web running in Node.js.\n */\nexport type FileUrlOrPath = string;\n\n/**\n * A Blob object that represents a file.\n */\nexport type FileBlob = Blob;\n\n/**\n * A Uint8Array, ArrayBuffer or SharedArrayBuffer object that represents a file content.\n *\n * When it is an ArrayBuffer or SharedArrayBuffer, the whole buffer is assumed to be the file content.\n */\nexport type FileData = Uint8Array | ArrayBufferLike;\n\n/**\n * Represents a file that can be loaded by the ONNX Runtime JavaScript API.\n */\nexport type FileType = FileUrlOrPath | FileBlob | FileData;\n\n/**\n * Represents an external data file.\n */\nexport interface ExternalDataFileDescription {\n  /**\n   * Specify the external data file.\n   */\n  data: FileType;\n  /**\n   * Specify the file path.\n   */\n  path: string;\n}\n\n/**\n * Represents an external data file.\n *\n * When using a string, it should be a file URL or path that in the same directory as the model file.\n */\nexport type ExternalDataFileType = ExternalDataFileDescription | FileUrlOrPath;\n\n/**\n * Options for model loading.\n */\nexport interface OnnxModelOptions {\n  /**\n   * Specifying a list of files that represents the external data.\n   */\n  externalData?: readonly ExternalDataFileType[];\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Tensor } from './tensor.js';\n\nexport type NonTensorType = never;\n\n/**\n * Type OnnxValue Represents both tensors and non-tensors value for model's inputs/outputs.\n *\n * NOTE: currently not support non-tensor\n */\nexport type OnnxValue = Tensor | NonTensorType;\n\n/**\n * Type OnnxValueDataLocation represents the location of the data of an OnnxValue.\n */\nexport type OnnxValueDataLocation = Tensor.DataLocation;\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n/**\n * # ONNX Runtime JavaScript API\n *\n * ONNX Runtime JavaScript API is a unified API for all JavaScript usages, including the following NPM packages:\n *\n * - [onnxruntime-node](https://www.npmjs.com/package/onnxruntime-node)\n * - [onnxruntime-web](https://www.npmjs.com/package/onnxruntime-web)\n * - [onnxruntime-react-native](https://www.npmjs.com/package/onnxruntime-react-native)\n *\n * See also:\n * - [Get Started](https://onnxruntime.ai/docs/get-started/with-javascript/)\n * - [Inference examples](https://github.com/microsoft/onnxruntime-inference-examples/tree/main/js)\n *\n * @packageDocumentation\n */\n\nexport * from './backend.js';\nexport * from './env.js';\nexport * from './inference-session.js';\nexport * from './tensor.js';\nexport * from './tensor-conversion.js';\nexport * from './tensor-factory.js';\nexport * from './trace.js';\nexport * from './onnx-model.js';\nexport * from './onnx-value.js';\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Env } from 'onnxruntime-common';\n\nimport { WebGLContext } from './backends/webgl/webgl-context';\n\nexport declare namespace Logger {\n  export interface SeverityTypeMap {\n    verbose: 'v';\n    info: 'i';\n    warning: 'w';\n    error: 'e';\n    fatal: 'f';\n  }\n\n  export type Severity = keyof SeverityTypeMap;\n\n  export type Provider = 'none' | 'console';\n\n  /**\n   * Logging config that used to control the behavior of logger\n   */\n  export interface Config {\n    /**\n     * Specify the logging provider. 'console' by default\n     */\n    provider?: Provider;\n    /**\n     * Specify the minimal logger severity. 'warning' by default\n     */\n    minimalSeverity?: Logger.Severity;\n    /**\n     * Whether to output date time in log. true by default\n     */\n    logDateTime?: boolean;\n    /**\n     * Whether to output source information (Not yet supported). false by default\n     */\n    logSourceLocation?: boolean;\n  }\n\n  export interface CategorizedLogger {\n    verbose(content: string): void;\n    info(content: string): void;\n    warning(content: string): void;\n    error(content: string): void;\n    fatal(content: string): void;\n  }\n}\n\n// eslint-disable-next-line @typescript-eslint/no-redeclare\nexport interface Logger {\n  (category: string): Logger.CategorizedLogger;\n\n  verbose(content: string): void;\n  verbose(category: string, content: string): void;\n  info(content: string): void;\n  info(category: string, content: string): void;\n  warning(content: string): void;\n  warning(category: string, content: string): void;\n  error(content: string): void;\n  error(category: string, content: string): void;\n  fatal(content: string): void;\n  fatal(category: string, content: string): void;\n\n  /**\n   * Reset the logger configuration.\n   * @param config specify an optional default config\n   */\n  reset(config?: Logger.Config): void;\n  /**\n   * Set the logger's behavior on the given category\n   * @param category specify a category string. If '*' is specified, all previous configuration will be overwritten. If\n   * '' is specified, the default behavior will be updated.\n   * @param config the config object to indicate the logger's behavior\n   */\n  set(category: string, config: Logger.Config): void;\n\n  /**\n   * Set the logger's behavior from ort-common env\n   * @param env the env used to set logger. Currently only setting loglevel is supported through Env.\n   */\n  setWithEnv(env: Env): void;\n}\n\ninterface LoggerProvider {\n  log(severity: Logger.Severity, content: string, category?: string): void;\n}\nclass NoOpLoggerProvider implements LoggerProvider {\n  log(_severity: Logger.Severity, _content: string, _category?: string) {\n    // do nothing\n  }\n}\nclass ConsoleLoggerProvider implements LoggerProvider {\n  log(severity: Logger.Severity, content: string, category?: string) {\n    // eslint-disable-next-line no-console\n    console.log(`${this.color(severity)} ${category ? '\\x1b[35m' + category + '\\x1b[0m ' : ''}${content}`);\n  }\n\n  private color(severity: Logger.Severity) {\n    switch (severity) {\n      case 'verbose':\n        return '\\x1b[34;40mv\\x1b[0m';\n      case 'info':\n        return '\\x1b[32mi\\x1b[0m';\n      case 'warning':\n        return '\\x1b[30;43mw\\x1b[0m';\n      case 'error':\n        return '\\x1b[31;40me\\x1b[0m';\n      case 'fatal':\n        return '\\x1b[101mf\\x1b[0m';\n      default:\n        throw new Error(`unsupported severity: ${severity}`);\n    }\n  }\n}\n\nconst SEVERITY_VALUE = {\n  verbose: 1000,\n  info: 2000,\n  warning: 4000,\n  error: 5000,\n  fatal: 6000,\n};\n\nconst LOGGER_PROVIDER_MAP: { readonly [provider: string]: Readonly<LoggerProvider> } = {\n  ['none']: new NoOpLoggerProvider(),\n  ['console']: new ConsoleLoggerProvider(),\n};\nconst LOGGER_DEFAULT_CONFIG = {\n  provider: 'console',\n  minimalSeverity: 'warning',\n  logDateTime: true,\n  logSourceLocation: false,\n};\nlet LOGGER_CONFIG_MAP: { [category: string]: Readonly<Required<Logger.Config>> } = {\n  ['']: LOGGER_DEFAULT_CONFIG as Required<Logger.Config>,\n};\n\nfunction log(category: string): Logger.CategorizedLogger;\nfunction log(severity: Logger.Severity, content: string): void;\nfunction log(severity: Logger.Severity, category: string, content: string): void;\nfunction log(severity: Logger.Severity, arg1: string, arg2?: string): void;\nfunction log(\n  arg0: string | Logger.Severity,\n  arg1?: string,\n  arg2?: string | number,\n  arg3?: number,\n): Logger.CategorizedLogger | void {\n  if (arg1 === undefined) {\n    // log(category: string): Logger.CategorizedLogger;\n    return createCategorizedLogger(arg0);\n  } else if (arg2 === undefined) {\n    // log(severity, content);\n    logInternal(arg0 as Logger.Severity, arg1, 1);\n  } else if (typeof arg2 === 'number' && arg3 === undefined) {\n    // log(severity, content, stack)\n    logInternal(arg0 as Logger.Severity, arg1, arg2);\n  } else if (typeof arg2 === 'string' && arg3 === undefined) {\n    // log(severity, category, content)\n    logInternal(arg0 as Logger.Severity, arg2, 1, arg1);\n  } else if (typeof arg2 === 'string' && typeof arg3 === 'number') {\n    // log(severity, category, content, stack)\n    logInternal(arg0 as Logger.Severity, arg2, arg3, arg1);\n  } else {\n    throw new TypeError('input is valid');\n  }\n}\n\nfunction createCategorizedLogger(category: string): Logger.CategorizedLogger {\n  return {\n    verbose: log.verbose.bind(null, category),\n    info: log.info.bind(null, category),\n    warning: log.warning.bind(null, category),\n    error: log.error.bind(null, category),\n    fatal: log.fatal.bind(null, category),\n  };\n}\n\n// NOTE: argument 'category' is put the last parameter because typescript\n// doesn't allow optional argument put in front of required argument. This\n// order is different from a usual logging API.\nfunction logInternal(severity: Logger.Severity, content: string, _stack: number, category?: string) {\n  const config = LOGGER_CONFIG_MAP[category || ''] || LOGGER_CONFIG_MAP[''];\n  if (SEVERITY_VALUE[severity] < SEVERITY_VALUE[config.minimalSeverity]) {\n    return;\n  }\n\n  if (config.logDateTime) {\n    content = `${new Date().toISOString()}|${content}`;\n  }\n\n  if (config.logSourceLocation) {\n    // TODO: calculate source location from 'stack'\n  }\n\n  LOGGER_PROVIDER_MAP[config.provider].log(severity, content, category);\n}\n\n// eslint-disable-next-line @typescript-eslint/no-namespace\nnamespace log {\n  export function verbose(content: string): void;\n  export function verbose(category: string, content: string): void;\n  export function verbose(arg0: string, arg1?: string) {\n    log('verbose', arg0, arg1);\n  }\n  export function info(content: string): void;\n  export function info(category: string, content: string): void;\n  export function info(arg0: string, arg1?: string) {\n    log('info', arg0, arg1);\n  }\n  export function warning(content: string): void;\n  export function warning(category: string, content: string): void;\n  export function warning(arg0: string, arg1?: string) {\n    log('warning', arg0, arg1);\n  }\n  export function error(content: string): void;\n  export function error(category: string, content: string): void;\n  export function error(arg0: string, arg1?: string) {\n    log('error', arg0, arg1);\n  }\n  export function fatal(content: string): void;\n  export function fatal(category: string, content: string): void;\n  export function fatal(arg0: string, arg1?: string) {\n    log('fatal', arg0, arg1);\n  }\n\n  export function reset(config?: Logger.Config): void {\n    LOGGER_CONFIG_MAP = {};\n    set('', config || {});\n  }\n  export function set(category: string, config: Logger.Config): void {\n    if (category === '*') {\n      reset(config);\n    } else {\n      const previousConfig = LOGGER_CONFIG_MAP[category] || LOGGER_DEFAULT_CONFIG;\n      LOGGER_CONFIG_MAP[category] = {\n        provider: config.provider || previousConfig.provider,\n        minimalSeverity: config.minimalSeverity || previousConfig.minimalSeverity,\n        logDateTime: config.logDateTime === undefined ? previousConfig.logDateTime : config.logDateTime,\n        logSourceLocation:\n          config.logSourceLocation === undefined ? previousConfig.logSourceLocation : config.logSourceLocation,\n      };\n    }\n\n    // TODO: we want to support wildcard or regex?\n  }\n\n  export function setWithEnv(env: Env): void {\n    const config: Logger.Config = {};\n    if (env.logLevel) {\n      config.minimalSeverity = env.logLevel as Logger.Severity;\n    }\n    set('', config);\n  }\n}\n\n// eslint-disable-next-line @typescript-eslint/no-redeclare, @typescript-eslint/naming-convention\nexport const Logger: Logger = log;\n\nexport declare namespace Profiler {\n  export interface Config {\n    maxNumberEvents?: number;\n    flushBatchSize?: number;\n    flushIntervalInMilliseconds?: number;\n  }\n\n  export type EventCategory = 'session' | 'node' | 'op' | 'backend';\n\n  export interface Event {\n    end(): void | Promise<void>;\n  }\n}\n// TODO\n// class WebGLEvent implements Profiler.Event {}\n\nclass Event implements Profiler.Event {\n  constructor(\n    public category: Profiler.EventCategory,\n    public name: string,\n    public startTime: number,\n    private endCallback: (e: Event) => void | Promise<void>,\n    public timer?: WebGLQuery,\n    public ctx?: WebGLContext,\n  ) {}\n\n  async end() {\n    return this.endCallback(this);\n  }\n\n  async checkTimer(): Promise<number> {\n    if (this.ctx === undefined || this.timer === undefined) {\n      throw new Error('No webgl timer found');\n    } else {\n      this.ctx.endTimer();\n      return this.ctx.waitForQueryAndGetTime(this.timer);\n    }\n  }\n}\n\nclass EventRecord {\n  constructor(\n    public category: Profiler.EventCategory,\n    public name: string,\n    public startTime: number,\n    public endTime: number,\n  ) {}\n}\n\nexport class Profiler {\n  static create(config?: Profiler.Config): Profiler {\n    if (config === undefined) {\n      return new this();\n    }\n    return new this(config.maxNumberEvents, config.flushBatchSize, config.flushIntervalInMilliseconds);\n  }\n\n  private constructor(maxNumberEvents?: number, flushBatchSize?: number, flushIntervalInMilliseconds?: number) {\n    this._started = false;\n    this._maxNumberEvents = maxNumberEvents === undefined ? 10000 : maxNumberEvents;\n    this._flushBatchSize = flushBatchSize === undefined ? 10 : flushBatchSize;\n    this._flushIntervalInMilliseconds = flushIntervalInMilliseconds === undefined ? 5000 : flushIntervalInMilliseconds;\n  }\n\n  // start profiling\n  start() {\n    this._started = true;\n    this._timingEvents = [];\n    this._flushTime = now();\n    this._flushPointer = 0;\n  }\n\n  // stop profiling\n  stop() {\n    this._started = false;\n    for (; this._flushPointer < this._timingEvents.length; this._flushPointer++) {\n      this.logOneEvent(this._timingEvents[this._flushPointer]);\n    }\n  }\n\n  // create an event scope for the specific function\n  event<T>(category: Profiler.EventCategory, name: string, func: () => T, ctx?: WebGLContext): T;\n  event<T>(category: Profiler.EventCategory, name: string, func: () => Promise<T>, ctx?: WebGLContext): Promise<T>;\n\n  event<T>(\n    category: Profiler.EventCategory,\n    name: string,\n    func: () => T | Promise<T>,\n    ctx?: WebGLContext,\n  ): T | Promise<T> {\n    const event = this._started ? this.begin(category, name, ctx) : undefined;\n    let isPromise = false;\n\n    const res = func();\n\n    // we consider a then-able object is a promise\n    if (res && typeof (res as Promise<T>).then === 'function') {\n      isPromise = true;\n      return new Promise<T>((resolve, reject) => {\n        (res as Promise<T>).then(\n          async (value) => {\n            // fulfilled\n            if (event) {\n              await event.end();\n            }\n            resolve(value);\n          },\n          async (reason) => {\n            // rejected\n            if (event) {\n              await event.end();\n            }\n            reject(reason);\n          },\n        );\n      });\n    }\n    if (!isPromise && event) {\n      const eventRes = event.end();\n      if (eventRes && typeof eventRes.then === 'function') {\n        return new Promise<T>((resolve, reject) => {\n          eventRes.then(\n            () => {\n              // fulfilled\n              resolve(res);\n            },\n            (reason) => {\n              // rejected\n              reject(reason);\n            },\n          );\n        });\n      }\n    }\n    return res;\n  }\n\n  // begin an event\n  begin(category: Profiler.EventCategory, name: string, ctx?: WebGLContext): Event {\n    if (!this._started) {\n      throw new Error('profiler is not started yet');\n    }\n    if (ctx === undefined) {\n      const startTime = now();\n      this.flush(startTime);\n      return new Event(category, name, startTime, (e) => this.endSync(e));\n    } else {\n      const timer: WebGLQuery = ctx.beginTimer();\n      return new Event(category, name, 0, async (e) => this.end(e), timer, ctx);\n    }\n  }\n\n  // end the specific event\n  private async end(event: Event): Promise<void> {\n    const endTime: number = await event.checkTimer();\n    if (this._timingEvents.length < this._maxNumberEvents) {\n      this._timingEvents.push(new EventRecord(event.category, event.name, event.startTime, endTime));\n      this.flush(endTime);\n    }\n  }\n\n  private endSync(event: Event): void {\n    const endTime: number = now();\n    if (this._timingEvents.length < this._maxNumberEvents) {\n      this._timingEvents.push(new EventRecord(event.category, event.name, event.startTime, endTime));\n      this.flush(endTime);\n    }\n  }\n\n  private logOneEvent(event: EventRecord) {\n    Logger.verbose(\n      `Profiler.${event.category}`,\n      `${(event.endTime - event.startTime).toFixed(2)}ms on event '${event.name}' at ${event.endTime.toFixed(2)}`,\n    );\n  }\n\n  private flush(currentTime: number) {\n    if (\n      this._timingEvents.length - this._flushPointer >= this._flushBatchSize ||\n      currentTime - this._flushTime >= this._flushIntervalInMilliseconds\n    ) {\n      // should flush when either batch size accumulated or interval elepsed\n\n      for (\n        const previousPointer = this._flushPointer;\n        this._flushPointer < previousPointer + this._flushBatchSize && this._flushPointer < this._timingEvents.length;\n        this._flushPointer++\n      ) {\n        this.logOneEvent(this._timingEvents[this._flushPointer]);\n      }\n\n      this._flushTime = now();\n    }\n  }\n\n  get started() {\n    return this._started;\n  }\n  private _started = false;\n  private _timingEvents: EventRecord[];\n\n  private readonly _maxNumberEvents: number;\n\n  private readonly _flushBatchSize: number;\n  private readonly _flushIntervalInMilliseconds: number;\n\n  private _flushTime: number;\n  private _flushPointer = 0;\n}\n\n/**\n * returns a number to represent the current timestamp in a resolution as high as possible.\n */\nexport const now = typeof performance !== 'undefined' && performance.now ? () => performance.now() : Date.now;\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Graph } from './graph';\nimport { OperatorImplementation, OperatorInitialization } from './operators';\n\nexport interface OpSet {\n  domain: string;\n  version: number;\n}\nexport declare namespace OpSet {\n  /**\n   * Domain of an opset, it can be an empty string(default value, represent for ai.onnx), or 'ai.onnx.ml'\n   */\n  type Domain = '' | 'ai.onnx.ml' | 'com.microsoft';\n  /**\n   * A resolve rule consists of 4 or 5 items: opType, opSetDomain, versionSelector, operatorImplementation and\n   * operatorInitialization (optional)\n   */\n  type ResolveRule =\n    | [string, Domain, string, OperatorImplementation<Graph.Node>]\n    | [string, Domain, string, OperatorImplementation<unknown>, OperatorInitialization<unknown>];\n}\n\nexport function resolveOperator(node: Graph.Node, opsets: readonly OpSet[], rules: readonly OpSet.ResolveRule[]) {\n  for (const rule of rules) {\n    const opType = rule[0];\n    const domain = rule[1];\n    const versionSelector = rule[2];\n    const opImpl = rule[3];\n    const opInit = rule[4];\n\n    if (node.opType === opType) {\n      // operator type matches\n      for (const opset of opsets) {\n        // opset '' and 'ai.onnx' are considered the same.\n        if (opset.domain === domain || (opset.domain === 'ai.onnx' && domain === '')) {\n          // opset domain found\n          if (matchSelector(opset.version, versionSelector)) {\n            return { opImpl, opInit };\n          }\n        }\n      }\n    }\n  }\n\n  throw new TypeError(\n    `cannot resolve operator '${node.opType}' with opsets: ${opsets\n      .map((set) => `${set.domain || 'ai.onnx'} v${set.version}`)\n      .join(', ')}`,\n  );\n}\n\nfunction matchSelector(version: number, selector: string): boolean {\n  if (selector.endsWith('+')) {\n    // minimum version match ('7+' expects version>=7)\n    const rangeStart = Number.parseInt(selector.substring(0, selector.length - 1), 10);\n    return !isNaN(rangeStart) && rangeStart <= version;\n  } else if (selector.split('-').length === 2) {\n    // range match ('6-8' expects 6<=version<=8)\n    const pair = selector.split('-');\n    const rangeStart = Number.parseInt(pair[0], 10);\n    const rangeEnd = Number.parseInt(pair[1], 10);\n    return !isNaN(rangeStart) && !isNaN(rangeEnd) && rangeStart <= version && version <= rangeEnd;\n  } else {\n    // exact match ('7' expects version===7)\n    return Number.parseInt(selector, 10) === version;\n  }\n}\n", "\"use strict\";\r\nexports.__esModule = true;\r\nvar Guid = /** @class */ (function () {\r\n    function Guid(guid) {\r\n        if (!guid) {\r\n            throw new TypeError(\"Invalid argument; `value` has no value.\");\r\n        }\r\n        this.value = Guid.EMPTY;\r\n        if (guid && Guid.isGuid(guid)) {\r\n            this.value = guid;\r\n        }\r\n    }\r\n    Guid.isGuid = function (guid) {\r\n        var value = guid.toString();\r\n        return guid && (guid instanceof Guid || Guid.validator.test(value));\r\n    };\r\n    Guid.create = function () {\r\n        return new Guid([Guid.gen(2), Guid.gen(1), Guid.gen(1), Guid.gen(1), Guid.gen(3)].join(\"-\"));\r\n    };\r\n    Guid.createEmpty = function () {\r\n        return new Guid(\"emptyguid\");\r\n    };\r\n    Guid.parse = function (guid) {\r\n        return new Guid(guid);\r\n    };\r\n    Guid.raw = function () {\r\n        return [Guid.gen(2), Guid.gen(1), Guid.gen(1), Guid.gen(1), Guid.gen(3)].join(\"-\");\r\n    };\r\n    Guid.gen = function (count) {\r\n        var out = \"\";\r\n        for (var i = 0; i < count; i++) {\r\n            // tslint:disable-next-line:no-bitwise\r\n            out += (((1 + Math.random()) * 0x10000) | 0).toString(16).substring(1);\r\n        }\r\n        return out;\r\n    };\r\n    Guid.prototype.equals = function (other) {\r\n        // Comparing string `value` against provided `guid` will auto-call\r\n        // toString on `guid` for comparison\r\n        return Guid.isGuid(other) && this.value === other.toString();\r\n    };\r\n    Guid.prototype.isEmpty = function () {\r\n        return this.value === Guid.EMPTY;\r\n    };\r\n    Guid.prototype.toString = function () {\r\n        return this.value;\r\n    };\r\n    Guid.prototype.toJSON = function () {\r\n        return {\r\n            value: this.value\r\n        };\r\n    };\r\n    Guid.validator = new RegExp(\"^[a-z0-9]{8}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{12}$\", \"i\");\r\n    Guid.EMPTY = \"00000000-0000-0000-0000-000000000000\";\r\n    return Guid;\r\n}());\r\nexports.Guid = Guid;\r\n", "/**\n * @license\n * Copyright 2009 The Closure Library Authors\n * Copyright 2020 Daniel Wirtz / The long.js Authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n * SPDX-License-Identifier: Apache-2.0\n */\n\n// WebAssembly optimizations to do native i64 multiplication and divide\nvar wasm = null;\ntry {\n  wasm = new WebAssembly.Instance(\n    new WebAssembly.Module(\n      new Uint8Array([\n        // \\0asm\n        0, 97, 115, 109,\n        // version 1\n        1, 0, 0, 0,\n\n        // section \"type\"\n        1, 13, 2,\n        // 0, () => i32\n        96, 0, 1, 127,\n        // 1, (i32, i32, i32, i32) => i32\n        96, 4, 127, 127, 127, 127, 1, 127,\n\n        // section \"function\"\n        3, 7, 6,\n        // 0, type 0\n        0,\n        // 1, type 1\n        1,\n        // 2, type 1\n        1,\n        // 3, type 1\n        1,\n        // 4, type 1\n        1,\n        // 5, type 1\n        1,\n\n        // section \"global\"\n        6, 6, 1,\n        // 0, \"high\", mutable i32\n        127, 1, 65, 0, 11,\n\n        // section \"export\"\n        7, 50, 6,\n        // 0, \"mul\"\n        3, 109, 117, 108, 0, 1,\n        // 1, \"div_s\"\n        5, 100, 105, 118, 95, 115, 0, 2,\n        // 2, \"div_u\"\n        5, 100, 105, 118, 95, 117, 0, 3,\n        // 3, \"rem_s\"\n        5, 114, 101, 109, 95, 115, 0, 4,\n        // 4, \"rem_u\"\n        5, 114, 101, 109, 95, 117, 0, 5,\n        // 5, \"get_high\"\n        8, 103, 101, 116, 95, 104, 105, 103, 104, 0, 0,\n\n        // section \"code\"\n        10, 191, 1, 6,\n        // 0, \"get_high\"\n        4, 0, 35, 0, 11,\n        // 1, \"mul\"\n        36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32,\n        3, 173, 66, 32, 134, 132, 126, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4,\n        167, 11,\n        // 2, \"div_s\"\n        36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32,\n        3, 173, 66, 32, 134, 132, 127, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4,\n        167, 11,\n        // 3, \"div_u\"\n        36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32,\n        3, 173, 66, 32, 134, 132, 128, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4,\n        167, 11,\n        // 4, \"rem_s\"\n        36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32,\n        3, 173, 66, 32, 134, 132, 129, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4,\n        167, 11,\n        // 5, \"rem_u\"\n        36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32,\n        3, 173, 66, 32, 134, 132, 130, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4,\n        167, 11,\n      ]),\n    ),\n    {},\n  ).exports;\n} catch {\n  // no wasm support :(\n}\n\n/**\n * Constructs a 64 bit two's-complement integer, given its low and high 32 bit values as *signed* integers.\n *  See the from* functions below for more convenient ways of constructing Longs.\n * @exports Long\n * @class A Long class for representing a 64 bit two's-complement integer value.\n * @param {number} low The low (signed) 32 bits of the long\n * @param {number} high The high (signed) 32 bits of the long\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n * @constructor\n */\nfunction Long(low, high, unsigned) {\n  /**\n   * The low 32 bits as a signed value.\n   * @type {number}\n   */\n  this.low = low | 0;\n\n  /**\n   * The high 32 bits as a signed value.\n   * @type {number}\n   */\n  this.high = high | 0;\n\n  /**\n   * Whether unsigned or not.\n   * @type {boolean}\n   */\n  this.unsigned = !!unsigned;\n}\n\n// The internal representation of a long is the two given signed, 32-bit values.\n// We use 32-bit pieces because these are the size of integers on which\n// Javascript performs bit-operations.  For operations like addition and\n// multiplication, we split each number into 16 bit pieces, which can easily be\n// multiplied within Javascript's floating-point representation without overflow\n// or change in sign.\n//\n// In the algorithms below, we frequently reduce the negative case to the\n// positive case by negating the input(s) and then post-processing the result.\n// Note that we must ALWAYS check specially whether those values are MIN_VALUE\n// (-2^63) because -MIN_VALUE == MIN_VALUE (since 2^63 cannot be represented as\n// a positive number, it overflows back into a negative).  Not handling this\n// case would often result in infinite recursion.\n//\n// Common constant values ZERO, ONE, NEG_ONE, etc. are defined below the from*\n// methods on which they depend.\n\n/**\n * An indicator used to reliably determine if an object is a Long or not.\n * @type {boolean}\n * @const\n * @private\n */\nLong.prototype.__isLong__;\n\nObject.defineProperty(Long.prototype, \"__isLong__\", { value: true });\n\n/**\n * @function\n * @param {*} obj Object\n * @returns {boolean}\n * @inner\n */\nfunction isLong(obj) {\n  return (obj && obj[\"__isLong__\"]) === true;\n}\n\n/**\n * @function\n * @param {*} value number\n * @returns {number}\n * @inner\n */\nfunction ctz32(value) {\n  var c = Math.clz32(value & -value);\n  return value ? 31 - c : c;\n}\n\n/**\n * Tests if the specified object is a Long.\n * @function\n * @param {*} obj Object\n * @returns {boolean}\n */\nLong.isLong = isLong;\n\n/**\n * A cache of the Long representations of small integer values.\n * @type {!Object}\n * @inner\n */\nvar INT_CACHE = {};\n\n/**\n * A cache of the Long representations of small unsigned integer values.\n * @type {!Object}\n * @inner\n */\nvar UINT_CACHE = {};\n\n/**\n * @param {number} value\n * @param {boolean=} unsigned\n * @returns {!Long}\n * @inner\n */\nfunction fromInt(value, unsigned) {\n  var obj, cachedObj, cache;\n  if (unsigned) {\n    value >>>= 0;\n    if ((cache = 0 <= value && value < 256)) {\n      cachedObj = UINT_CACHE[value];\n      if (cachedObj) return cachedObj;\n    }\n    obj = fromBits(value, 0, true);\n    if (cache) UINT_CACHE[value] = obj;\n    return obj;\n  } else {\n    value |= 0;\n    if ((cache = -128 <= value && value < 128)) {\n      cachedObj = INT_CACHE[value];\n      if (cachedObj) return cachedObj;\n    }\n    obj = fromBits(value, value < 0 ? -1 : 0, false);\n    if (cache) INT_CACHE[value] = obj;\n    return obj;\n  }\n}\n\n/**\n * Returns a Long representing the given 32 bit integer value.\n * @function\n * @param {number} value The 32 bit integer in question\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n * @returns {!Long} The corresponding Long value\n */\nLong.fromInt = fromInt;\n\n/**\n * @param {number} value\n * @param {boolean=} unsigned\n * @returns {!Long}\n * @inner\n */\nfunction fromNumber(value, unsigned) {\n  if (isNaN(value)) return unsigned ? UZERO : ZERO;\n  if (unsigned) {\n    if (value < 0) return UZERO;\n    if (value >= TWO_PWR_64_DBL) return MAX_UNSIGNED_VALUE;\n  } else {\n    if (value <= -TWO_PWR_63_DBL) return MIN_VALUE;\n    if (value + 1 >= TWO_PWR_63_DBL) return MAX_VALUE;\n  }\n  if (value < 0) return fromNumber(-value, unsigned).neg();\n  return fromBits(\n    value % TWO_PWR_32_DBL | 0,\n    (value / TWO_PWR_32_DBL) | 0,\n    unsigned,\n  );\n}\n\n/**\n * Returns a Long representing the given value, provided that it is a finite number. Otherwise, zero is returned.\n * @function\n * @param {number} value The number in question\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n * @returns {!Long} The corresponding Long value\n */\nLong.fromNumber = fromNumber;\n\n/**\n * @param {number} lowBits\n * @param {number} highBits\n * @param {boolean=} unsigned\n * @returns {!Long}\n * @inner\n */\nfunction fromBits(lowBits, highBits, unsigned) {\n  return new Long(lowBits, highBits, unsigned);\n}\n\n/**\n * Returns a Long representing the 64 bit integer that comes by concatenating the given low and high bits. Each is\n *  assumed to use 32 bits.\n * @function\n * @param {number} lowBits The low 32 bits\n * @param {number} highBits The high 32 bits\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n * @returns {!Long} The corresponding Long value\n */\nLong.fromBits = fromBits;\n\n/**\n * @function\n * @param {number} base\n * @param {number} exponent\n * @returns {number}\n * @inner\n */\nvar pow_dbl = Math.pow; // Used 4 times (4*8 to 15+4)\n\n/**\n * @param {string} str\n * @param {(boolean|number)=} unsigned\n * @param {number=} radix\n * @returns {!Long}\n * @inner\n */\nfunction fromString(str, unsigned, radix) {\n  if (str.length === 0) throw Error(\"empty string\");\n  if (typeof unsigned === \"number\") {\n    // For goog.math.long compatibility\n    radix = unsigned;\n    unsigned = false;\n  } else {\n    unsigned = !!unsigned;\n  }\n  if (\n    str === \"NaN\" ||\n    str === \"Infinity\" ||\n    str === \"+Infinity\" ||\n    str === \"-Infinity\"\n  )\n    return unsigned ? UZERO : ZERO;\n  radix = radix || 10;\n  if (radix < 2 || 36 < radix) throw RangeError(\"radix\");\n\n  var p;\n  if ((p = str.indexOf(\"-\")) > 0) throw Error(\"interior hyphen\");\n  else if (p === 0) {\n    return fromString(str.substring(1), unsigned, radix).neg();\n  }\n\n  // Do several (8) digits each time through the loop, so as to\n  // minimize the calls to the very expensive emulated div.\n  var radixToPower = fromNumber(pow_dbl(radix, 8));\n\n  var result = ZERO;\n  for (var i = 0; i < str.length; i += 8) {\n    var size = Math.min(8, str.length - i),\n      value = parseInt(str.substring(i, i + size), radix);\n    if (size < 8) {\n      var power = fromNumber(pow_dbl(radix, size));\n      result = result.mul(power).add(fromNumber(value));\n    } else {\n      result = result.mul(radixToPower);\n      result = result.add(fromNumber(value));\n    }\n  }\n  result.unsigned = unsigned;\n  return result;\n}\n\n/**\n * Returns a Long representation of the given string, written using the specified radix.\n * @function\n * @param {string} str The textual representation of the Long\n * @param {(boolean|number)=} unsigned Whether unsigned or not, defaults to signed\n * @param {number=} radix The radix in which the text is written (2-36), defaults to 10\n * @returns {!Long} The corresponding Long value\n */\nLong.fromString = fromString;\n\n/**\n * @function\n * @param {!Long|number|string|!{low: number, high: number, unsigned: boolean}} val\n * @param {boolean=} unsigned\n * @returns {!Long}\n * @inner\n */\nfunction fromValue(val, unsigned) {\n  if (typeof val === \"number\") return fromNumber(val, unsigned);\n  if (typeof val === \"string\") return fromString(val, unsigned);\n  // Throws for non-objects, converts non-instanceof Long:\n  return fromBits(\n    val.low,\n    val.high,\n    typeof unsigned === \"boolean\" ? unsigned : val.unsigned,\n  );\n}\n\n/**\n * Converts the specified value to a Long using the appropriate from* function for its type.\n * @function\n * @param {!Long|number|bigint|string|!{low: number, high: number, unsigned: boolean}} val Value\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n * @returns {!Long}\n */\nLong.fromValue = fromValue;\n\n// NOTE: the compiler should inline these constant values below and then remove these variables, so there should be\n// no runtime penalty for these.\n\n/**\n * @type {number}\n * @const\n * @inner\n */\nvar TWO_PWR_16_DBL = 1 << 16;\n\n/**\n * @type {number}\n * @const\n * @inner\n */\nvar TWO_PWR_24_DBL = 1 << 24;\n\n/**\n * @type {number}\n * @const\n * @inner\n */\nvar TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL;\n\n/**\n * @type {number}\n * @const\n * @inner\n */\nvar TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL;\n\n/**\n * @type {number}\n * @const\n * @inner\n */\nvar TWO_PWR_63_DBL = TWO_PWR_64_DBL / 2;\n\n/**\n * @type {!Long}\n * @const\n * @inner\n */\nvar TWO_PWR_24 = fromInt(TWO_PWR_24_DBL);\n\n/**\n * @type {!Long}\n * @inner\n */\nvar ZERO = fromInt(0);\n\n/**\n * Signed zero.\n * @type {!Long}\n */\nLong.ZERO = ZERO;\n\n/**\n * @type {!Long}\n * @inner\n */\nvar UZERO = fromInt(0, true);\n\n/**\n * Unsigned zero.\n * @type {!Long}\n */\nLong.UZERO = UZERO;\n\n/**\n * @type {!Long}\n * @inner\n */\nvar ONE = fromInt(1);\n\n/**\n * Signed one.\n * @type {!Long}\n */\nLong.ONE = ONE;\n\n/**\n * @type {!Long}\n * @inner\n */\nvar UONE = fromInt(1, true);\n\n/**\n * Unsigned one.\n * @type {!Long}\n */\nLong.UONE = UONE;\n\n/**\n * @type {!Long}\n * @inner\n */\nvar NEG_ONE = fromInt(-1);\n\n/**\n * Signed negative one.\n * @type {!Long}\n */\nLong.NEG_ONE = NEG_ONE;\n\n/**\n * @type {!Long}\n * @inner\n */\nvar MAX_VALUE = fromBits(0xffffffff | 0, 0x7fffffff | 0, false);\n\n/**\n * Maximum signed value.\n * @type {!Long}\n */\nLong.MAX_VALUE = MAX_VALUE;\n\n/**\n * @type {!Long}\n * @inner\n */\nvar MAX_UNSIGNED_VALUE = fromBits(0xffffffff | 0, 0xffffffff | 0, true);\n\n/**\n * Maximum unsigned value.\n * @type {!Long}\n */\nLong.MAX_UNSIGNED_VALUE = MAX_UNSIGNED_VALUE;\n\n/**\n * @type {!Long}\n * @inner\n */\nvar MIN_VALUE = fromBits(0, 0x80000000 | 0, false);\n\n/**\n * Minimum signed value.\n * @type {!Long}\n */\nLong.MIN_VALUE = MIN_VALUE;\n\n/**\n * @alias Long.prototype\n * @inner\n */\nvar LongPrototype = Long.prototype;\n\n/**\n * Converts the Long to a 32 bit integer, assuming it is a 32 bit integer.\n * @this {!Long}\n * @returns {number}\n */\nLongPrototype.toInt = function toInt() {\n  return this.unsigned ? this.low >>> 0 : this.low;\n};\n\n/**\n * Converts the Long to a the nearest floating-point representation of this value (double, 53 bit mantissa).\n * @this {!Long}\n * @returns {number}\n */\nLongPrototype.toNumber = function toNumber() {\n  if (this.unsigned)\n    return (this.high >>> 0) * TWO_PWR_32_DBL + (this.low >>> 0);\n  return this.high * TWO_PWR_32_DBL + (this.low >>> 0);\n};\n\n/**\n * Converts the Long to a string written in the specified radix.\n * @this {!Long}\n * @param {number=} radix Radix (2-36), defaults to 10\n * @returns {string}\n * @override\n * @throws {RangeError} If `radix` is out of range\n */\nLongPrototype.toString = function toString(radix) {\n  radix = radix || 10;\n  if (radix < 2 || 36 < radix) throw RangeError(\"radix\");\n  if (this.isZero()) return \"0\";\n  if (this.isNegative()) {\n    // Unsigned Longs are never negative\n    if (this.eq(MIN_VALUE)) {\n      // We need to change the Long value before it can be negated, so we remove\n      // the bottom-most digit in this base and then recurse to do the rest.\n      var radixLong = fromNumber(radix),\n        div = this.div(radixLong),\n        rem1 = div.mul(radixLong).sub(this);\n      return div.toString(radix) + rem1.toInt().toString(radix);\n    } else return \"-\" + this.neg().toString(radix);\n  }\n\n  // Do several (6) digits each time through the loop, so as to\n  // minimize the calls to the very expensive emulated div.\n  var radixToPower = fromNumber(pow_dbl(radix, 6), this.unsigned),\n    rem = this;\n  var result = \"\";\n  while (true) {\n    var remDiv = rem.div(radixToPower),\n      intval = rem.sub(remDiv.mul(radixToPower)).toInt() >>> 0,\n      digits = intval.toString(radix);\n    rem = remDiv;\n    if (rem.isZero()) return digits + result;\n    else {\n      while (digits.length < 6) digits = \"0\" + digits;\n      result = \"\" + digits + result;\n    }\n  }\n};\n\n/**\n * Gets the high 32 bits as a signed integer.\n * @this {!Long}\n * @returns {number} Signed high bits\n */\nLongPrototype.getHighBits = function getHighBits() {\n  return this.high;\n};\n\n/**\n * Gets the high 32 bits as an unsigned integer.\n * @this {!Long}\n * @returns {number} Unsigned high bits\n */\nLongPrototype.getHighBitsUnsigned = function getHighBitsUnsigned() {\n  return this.high >>> 0;\n};\n\n/**\n * Gets the low 32 bits as a signed integer.\n * @this {!Long}\n * @returns {number} Signed low bits\n */\nLongPrototype.getLowBits = function getLowBits() {\n  return this.low;\n};\n\n/**\n * Gets the low 32 bits as an unsigned integer.\n * @this {!Long}\n * @returns {number} Unsigned low bits\n */\nLongPrototype.getLowBitsUnsigned = function getLowBitsUnsigned() {\n  return this.low >>> 0;\n};\n\n/**\n * Gets the number of bits needed to represent the absolute value of this Long.\n * @this {!Long}\n * @returns {number}\n */\nLongPrototype.getNumBitsAbs = function getNumBitsAbs() {\n  if (this.isNegative())\n    // Unsigned Longs are never negative\n    return this.eq(MIN_VALUE) ? 64 : this.neg().getNumBitsAbs();\n  var val = this.high != 0 ? this.high : this.low;\n  for (var bit = 31; bit > 0; bit--) if ((val & (1 << bit)) != 0) break;\n  return this.high != 0 ? bit + 33 : bit + 1;\n};\n\n/**\n * Tests if this Long can be safely represented as a JavaScript number.\n * @this {!Long}\n * @returns {boolean}\n */\nLongPrototype.isSafeInteger = function isSafeInteger() {\n  // 2^53-1 is the maximum safe value\n  var top11Bits = this.high >> 21;\n  // [0, 2^53-1]\n  if (!top11Bits) return true;\n  // > 2^53-1\n  if (this.unsigned) return false;\n  // [-2^53, -1] except -2^53\n  return top11Bits === -1 && !(this.low === 0 && this.high === -0x200000);\n};\n\n/**\n * Tests if this Long's value equals zero.\n * @this {!Long}\n * @returns {boolean}\n */\nLongPrototype.isZero = function isZero() {\n  return this.high === 0 && this.low === 0;\n};\n\n/**\n * Tests if this Long's value equals zero. This is an alias of {@link Long#isZero}.\n * @returns {boolean}\n */\nLongPrototype.eqz = LongPrototype.isZero;\n\n/**\n * Tests if this Long's value is negative.\n * @this {!Long}\n * @returns {boolean}\n */\nLongPrototype.isNegative = function isNegative() {\n  return !this.unsigned && this.high < 0;\n};\n\n/**\n * Tests if this Long's value is positive or zero.\n * @this {!Long}\n * @returns {boolean}\n */\nLongPrototype.isPositive = function isPositive() {\n  return this.unsigned || this.high >= 0;\n};\n\n/**\n * Tests if this Long's value is odd.\n * @this {!Long}\n * @returns {boolean}\n */\nLongPrototype.isOdd = function isOdd() {\n  return (this.low & 1) === 1;\n};\n\n/**\n * Tests if this Long's value is even.\n * @this {!Long}\n * @returns {boolean}\n */\nLongPrototype.isEven = function isEven() {\n  return (this.low & 1) === 0;\n};\n\n/**\n * Tests if this Long's value equals the specified's.\n * @this {!Long}\n * @param {!Long|number|bigint|string} other Other value\n * @returns {boolean}\n */\nLongPrototype.equals = function equals(other) {\n  if (!isLong(other)) other = fromValue(other);\n  if (\n    this.unsigned !== other.unsigned &&\n    this.high >>> 31 === 1 &&\n    other.high >>> 31 === 1\n  )\n    return false;\n  return this.high === other.high && this.low === other.low;\n};\n\n/**\n * Tests if this Long's value equals the specified's. This is an alias of {@link Long#equals}.\n * @function\n * @param {!Long|number|bigint|string} other Other value\n * @returns {boolean}\n */\nLongPrototype.eq = LongPrototype.equals;\n\n/**\n * Tests if this Long's value differs from the specified's.\n * @this {!Long}\n * @param {!Long|number|bigint|string} other Other value\n * @returns {boolean}\n */\nLongPrototype.notEquals = function notEquals(other) {\n  return !this.eq(/* validates */ other);\n};\n\n/**\n * Tests if this Long's value differs from the specified's. This is an alias of {@link Long#notEquals}.\n * @function\n * @param {!Long|number|bigint|string} other Other value\n * @returns {boolean}\n */\nLongPrototype.neq = LongPrototype.notEquals;\n\n/**\n * Tests if this Long's value differs from the specified's. This is an alias of {@link Long#notEquals}.\n * @function\n * @param {!Long|number|bigint|string} other Other value\n * @returns {boolean}\n */\nLongPrototype.ne = LongPrototype.notEquals;\n\n/**\n * Tests if this Long's value is less than the specified's.\n * @this {!Long}\n * @param {!Long|number|bigint|string} other Other value\n * @returns {boolean}\n */\nLongPrototype.lessThan = function lessThan(other) {\n  return this.comp(/* validates */ other) < 0;\n};\n\n/**\n * Tests if this Long's value is less than the specified's. This is an alias of {@link Long#lessThan}.\n * @function\n * @param {!Long|number|bigint|string} other Other value\n * @returns {boolean}\n */\nLongPrototype.lt = LongPrototype.lessThan;\n\n/**\n * Tests if this Long's value is less than or equal the specified's.\n * @this {!Long}\n * @param {!Long|number|bigint|string} other Other value\n * @returns {boolean}\n */\nLongPrototype.lessThanOrEqual = function lessThanOrEqual(other) {\n  return this.comp(/* validates */ other) <= 0;\n};\n\n/**\n * Tests if this Long's value is less than or equal the specified's. This is an alias of {@link Long#lessThanOrEqual}.\n * @function\n * @param {!Long|number|bigint|string} other Other value\n * @returns {boolean}\n */\nLongPrototype.lte = LongPrototype.lessThanOrEqual;\n\n/**\n * Tests if this Long's value is less than or equal the specified's. This is an alias of {@link Long#lessThanOrEqual}.\n * @function\n * @param {!Long|number|bigint|string} other Other value\n * @returns {boolean}\n */\nLongPrototype.le = LongPrototype.lessThanOrEqual;\n\n/**\n * Tests if this Long's value is greater than the specified's.\n * @this {!Long}\n * @param {!Long|number|bigint|string} other Other value\n * @returns {boolean}\n */\nLongPrototype.greaterThan = function greaterThan(other) {\n  return this.comp(/* validates */ other) > 0;\n};\n\n/**\n * Tests if this Long's value is greater than the specified's. This is an alias of {@link Long#greaterThan}.\n * @function\n * @param {!Long|number|bigint|string} other Other value\n * @returns {boolean}\n */\nLongPrototype.gt = LongPrototype.greaterThan;\n\n/**\n * Tests if this Long's value is greater than or equal the specified's.\n * @this {!Long}\n * @param {!Long|number|bigint|string} other Other value\n * @returns {boolean}\n */\nLongPrototype.greaterThanOrEqual = function greaterThanOrEqual(other) {\n  return this.comp(/* validates */ other) >= 0;\n};\n\n/**\n * Tests if this Long's value is greater than or equal the specified's. This is an alias of {@link Long#greaterThanOrEqual}.\n * @function\n * @param {!Long|number|bigint|string} other Other value\n * @returns {boolean}\n */\nLongPrototype.gte = LongPrototype.greaterThanOrEqual;\n\n/**\n * Tests if this Long's value is greater than or equal the specified's. This is an alias of {@link Long#greaterThanOrEqual}.\n * @function\n * @param {!Long|number|bigint|string} other Other value\n * @returns {boolean}\n */\nLongPrototype.ge = LongPrototype.greaterThanOrEqual;\n\n/**\n * Compares this Long's value with the specified's.\n * @this {!Long}\n * @param {!Long|number|bigint|string} other Other value\n * @returns {number} 0 if they are the same, 1 if the this is greater and -1\n *  if the given one is greater\n */\nLongPrototype.compare = function compare(other) {\n  if (!isLong(other)) other = fromValue(other);\n  if (this.eq(other)) return 0;\n  var thisNeg = this.isNegative(),\n    otherNeg = other.isNegative();\n  if (thisNeg && !otherNeg) return -1;\n  if (!thisNeg && otherNeg) return 1;\n  // At this point the sign bits are the same\n  if (!this.unsigned) return this.sub(other).isNegative() ? -1 : 1;\n  // Both are positive if at least one is unsigned\n  return other.high >>> 0 > this.high >>> 0 ||\n    (other.high === this.high && other.low >>> 0 > this.low >>> 0)\n    ? -1\n    : 1;\n};\n\n/**\n * Compares this Long's value with the specified's. This is an alias of {@link Long#compare}.\n * @function\n * @param {!Long|number|bigint|string} other Other value\n * @returns {number} 0 if they are the same, 1 if the this is greater and -1\n *  if the given one is greater\n */\nLongPrototype.comp = LongPrototype.compare;\n\n/**\n * Negates this Long's value.\n * @this {!Long}\n * @returns {!Long} Negated Long\n */\nLongPrototype.negate = function negate() {\n  if (!this.unsigned && this.eq(MIN_VALUE)) return MIN_VALUE;\n  return this.not().add(ONE);\n};\n\n/**\n * Negates this Long's value. This is an alias of {@link Long#negate}.\n * @function\n * @returns {!Long} Negated Long\n */\nLongPrototype.neg = LongPrototype.negate;\n\n/**\n * Returns the sum of this and the specified Long.\n * @this {!Long}\n * @param {!Long|number|bigint|string} addend Addend\n * @returns {!Long} Sum\n */\nLongPrototype.add = function add(addend) {\n  if (!isLong(addend)) addend = fromValue(addend);\n\n  // Divide each number into 4 chunks of 16 bits, and then sum the chunks.\n\n  var a48 = this.high >>> 16;\n  var a32 = this.high & 0xffff;\n  var a16 = this.low >>> 16;\n  var a00 = this.low & 0xffff;\n\n  var b48 = addend.high >>> 16;\n  var b32 = addend.high & 0xffff;\n  var b16 = addend.low >>> 16;\n  var b00 = addend.low & 0xffff;\n\n  var c48 = 0,\n    c32 = 0,\n    c16 = 0,\n    c00 = 0;\n  c00 += a00 + b00;\n  c16 += c00 >>> 16;\n  c00 &= 0xffff;\n  c16 += a16 + b16;\n  c32 += c16 >>> 16;\n  c16 &= 0xffff;\n  c32 += a32 + b32;\n  c48 += c32 >>> 16;\n  c32 &= 0xffff;\n  c48 += a48 + b48;\n  c48 &= 0xffff;\n  return fromBits((c16 << 16) | c00, (c48 << 16) | c32, this.unsigned);\n};\n\n/**\n * Returns the difference of this and the specified Long.\n * @this {!Long}\n * @param {!Long|number|bigint|string} subtrahend Subtrahend\n * @returns {!Long} Difference\n */\nLongPrototype.subtract = function subtract(subtrahend) {\n  if (!isLong(subtrahend)) subtrahend = fromValue(subtrahend);\n  return this.add(subtrahend.neg());\n};\n\n/**\n * Returns the difference of this and the specified Long. This is an alias of {@link Long#subtract}.\n * @function\n * @param {!Long|number|bigint|string} subtrahend Subtrahend\n * @returns {!Long} Difference\n */\nLongPrototype.sub = LongPrototype.subtract;\n\n/**\n * Returns the product of this and the specified Long.\n * @this {!Long}\n * @param {!Long|number|bigint|string} multiplier Multiplier\n * @returns {!Long} Product\n */\nLongPrototype.multiply = function multiply(multiplier) {\n  if (this.isZero()) return this;\n  if (!isLong(multiplier)) multiplier = fromValue(multiplier);\n\n  // use wasm support if present\n  if (wasm) {\n    var low = wasm[\"mul\"](this.low, this.high, multiplier.low, multiplier.high);\n    return fromBits(low, wasm[\"get_high\"](), this.unsigned);\n  }\n\n  if (multiplier.isZero()) return this.unsigned ? UZERO : ZERO;\n  if (this.eq(MIN_VALUE)) return multiplier.isOdd() ? MIN_VALUE : ZERO;\n  if (multiplier.eq(MIN_VALUE)) return this.isOdd() ? MIN_VALUE : ZERO;\n\n  if (this.isNegative()) {\n    if (multiplier.isNegative()) return this.neg().mul(multiplier.neg());\n    else return this.neg().mul(multiplier).neg();\n  } else if (multiplier.isNegative()) return this.mul(multiplier.neg()).neg();\n\n  // If both longs are small, use float multiplication\n  if (this.lt(TWO_PWR_24) && multiplier.lt(TWO_PWR_24))\n    return fromNumber(this.toNumber() * multiplier.toNumber(), this.unsigned);\n\n  // Divide each long into 4 chunks of 16 bits, and then add up 4x4 products.\n  // We can skip products that would overflow.\n\n  var a48 = this.high >>> 16;\n  var a32 = this.high & 0xffff;\n  var a16 = this.low >>> 16;\n  var a00 = this.low & 0xffff;\n\n  var b48 = multiplier.high >>> 16;\n  var b32 = multiplier.high & 0xffff;\n  var b16 = multiplier.low >>> 16;\n  var b00 = multiplier.low & 0xffff;\n\n  var c48 = 0,\n    c32 = 0,\n    c16 = 0,\n    c00 = 0;\n  c00 += a00 * b00;\n  c16 += c00 >>> 16;\n  c00 &= 0xffff;\n  c16 += a16 * b00;\n  c32 += c16 >>> 16;\n  c16 &= 0xffff;\n  c16 += a00 * b16;\n  c32 += c16 >>> 16;\n  c16 &= 0xffff;\n  c32 += a32 * b00;\n  c48 += c32 >>> 16;\n  c32 &= 0xffff;\n  c32 += a16 * b16;\n  c48 += c32 >>> 16;\n  c32 &= 0xffff;\n  c32 += a00 * b32;\n  c48 += c32 >>> 16;\n  c32 &= 0xffff;\n  c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48;\n  c48 &= 0xffff;\n  return fromBits((c16 << 16) | c00, (c48 << 16) | c32, this.unsigned);\n};\n\n/**\n * Returns the product of this and the specified Long. This is an alias of {@link Long#multiply}.\n * @function\n * @param {!Long|number|bigint|string} multiplier Multiplier\n * @returns {!Long} Product\n */\nLongPrototype.mul = LongPrototype.multiply;\n\n/**\n * Returns this Long divided by the specified. The result is signed if this Long is signed or\n *  unsigned if this Long is unsigned.\n * @this {!Long}\n * @param {!Long|number|bigint|string} divisor Divisor\n * @returns {!Long} Quotient\n */\nLongPrototype.divide = function divide(divisor) {\n  if (!isLong(divisor)) divisor = fromValue(divisor);\n  if (divisor.isZero()) throw Error(\"division by zero\");\n\n  // use wasm support if present\n  if (wasm) {\n    // guard against signed division overflow: the largest\n    // negative number / -1 would be 1 larger than the largest\n    // positive number, due to two's complement.\n    if (\n      !this.unsigned &&\n      this.high === -0x80000000 &&\n      divisor.low === -1 &&\n      divisor.high === -1\n    ) {\n      // be consistent with non-wasm code path\n      return this;\n    }\n    var low = (this.unsigned ? wasm[\"div_u\"] : wasm[\"div_s\"])(\n      this.low,\n      this.high,\n      divisor.low,\n      divisor.high,\n    );\n    return fromBits(low, wasm[\"get_high\"](), this.unsigned);\n  }\n\n  if (this.isZero()) return this.unsigned ? UZERO : ZERO;\n  var approx, rem, res;\n  if (!this.unsigned) {\n    // This section is only relevant for signed longs and is derived from the\n    // closure library as a whole.\n    if (this.eq(MIN_VALUE)) {\n      if (divisor.eq(ONE) || divisor.eq(NEG_ONE))\n        return MIN_VALUE; // recall that -MIN_VALUE == MIN_VALUE\n      else if (divisor.eq(MIN_VALUE)) return ONE;\n      else {\n        // At this point, we have |other| >= 2, so |this/other| < |MIN_VALUE|.\n        var halfThis = this.shr(1);\n        approx = halfThis.div(divisor).shl(1);\n        if (approx.eq(ZERO)) {\n          return divisor.isNegative() ? ONE : NEG_ONE;\n        } else {\n          rem = this.sub(divisor.mul(approx));\n          res = approx.add(rem.div(divisor));\n          return res;\n        }\n      }\n    } else if (divisor.eq(MIN_VALUE)) return this.unsigned ? UZERO : ZERO;\n    if (this.isNegative()) {\n      if (divisor.isNegative()) return this.neg().div(divisor.neg());\n      return this.neg().div(divisor).neg();\n    } else if (divisor.isNegative()) return this.div(divisor.neg()).neg();\n    res = ZERO;\n  } else {\n    // The algorithm below has not been made for unsigned longs. It's therefore\n    // required to take special care of the MSB prior to running it.\n    if (!divisor.unsigned) divisor = divisor.toUnsigned();\n    if (divisor.gt(this)) return UZERO;\n    if (divisor.gt(this.shru(1)))\n      // 15 >>> 1 = 7 ; with divisor = 8 ; true\n      return UONE;\n    res = UZERO;\n  }\n\n  // Repeat the following until the remainder is less than other:  find a\n  // floating-point that approximates remainder / other *from below*, add this\n  // into the result, and subtract it from the remainder.  It is critical that\n  // the approximate value is less than or equal to the real value so that the\n  // remainder never becomes negative.\n  rem = this;\n  while (rem.gte(divisor)) {\n    // Approximate the result of division. This may be a little greater or\n    // smaller than the actual value.\n    approx = Math.max(1, Math.floor(rem.toNumber() / divisor.toNumber()));\n\n    // We will tweak the approximate result by changing it in the 48-th digit or\n    // the smallest non-fractional digit, whichever is larger.\n    var log2 = Math.ceil(Math.log(approx) / Math.LN2),\n      delta = log2 <= 48 ? 1 : pow_dbl(2, log2 - 48),\n      // Decrease the approximation until it is smaller than the remainder.  Note\n      // that if it is too large, the product overflows and is negative.\n      approxRes = fromNumber(approx),\n      approxRem = approxRes.mul(divisor);\n    while (approxRem.isNegative() || approxRem.gt(rem)) {\n      approx -= delta;\n      approxRes = fromNumber(approx, this.unsigned);\n      approxRem = approxRes.mul(divisor);\n    }\n\n    // We know the answer can't be zero... and actually, zero would cause\n    // infinite recursion since we would make no progress.\n    if (approxRes.isZero()) approxRes = ONE;\n\n    res = res.add(approxRes);\n    rem = rem.sub(approxRem);\n  }\n  return res;\n};\n\n/**\n * Returns this Long divided by the specified. This is an alias of {@link Long#divide}.\n * @function\n * @param {!Long|number|bigint|string} divisor Divisor\n * @returns {!Long} Quotient\n */\nLongPrototype.div = LongPrototype.divide;\n\n/**\n * Returns this Long modulo the specified.\n * @this {!Long}\n * @param {!Long|number|bigint|string} divisor Divisor\n * @returns {!Long} Remainder\n */\nLongPrototype.modulo = function modulo(divisor) {\n  if (!isLong(divisor)) divisor = fromValue(divisor);\n\n  // use wasm support if present\n  if (wasm) {\n    var low = (this.unsigned ? wasm[\"rem_u\"] : wasm[\"rem_s\"])(\n      this.low,\n      this.high,\n      divisor.low,\n      divisor.high,\n    );\n    return fromBits(low, wasm[\"get_high\"](), this.unsigned);\n  }\n\n  return this.sub(this.div(divisor).mul(divisor));\n};\n\n/**\n * Returns this Long modulo the specified. This is an alias of {@link Long#modulo}.\n * @function\n * @param {!Long|number|bigint|string} divisor Divisor\n * @returns {!Long} Remainder\n */\nLongPrototype.mod = LongPrototype.modulo;\n\n/**\n * Returns this Long modulo the specified. This is an alias of {@link Long#modulo}.\n * @function\n * @param {!Long|number|bigint|string} divisor Divisor\n * @returns {!Long} Remainder\n */\nLongPrototype.rem = LongPrototype.modulo;\n\n/**\n * Returns the bitwise NOT of this Long.\n * @this {!Long}\n * @returns {!Long}\n */\nLongPrototype.not = function not() {\n  return fromBits(~this.low, ~this.high, this.unsigned);\n};\n\n/**\n * Returns count leading zeros of this Long.\n * @this {!Long}\n * @returns {!number}\n */\nLongPrototype.countLeadingZeros = function countLeadingZeros() {\n  return this.high ? Math.clz32(this.high) : Math.clz32(this.low) + 32;\n};\n\n/**\n * Returns count leading zeros. This is an alias of {@link Long#countLeadingZeros}.\n * @function\n * @param {!Long}\n * @returns {!number}\n */\nLongPrototype.clz = LongPrototype.countLeadingZeros;\n\n/**\n * Returns count trailing zeros of this Long.\n * @this {!Long}\n * @returns {!number}\n */\nLongPrototype.countTrailingZeros = function countTrailingZeros() {\n  return this.low ? ctz32(this.low) : ctz32(this.high) + 32;\n};\n\n/**\n * Returns count trailing zeros. This is an alias of {@link Long#countTrailingZeros}.\n * @function\n * @param {!Long}\n * @returns {!number}\n */\nLongPrototype.ctz = LongPrototype.countTrailingZeros;\n\n/**\n * Returns the bitwise AND of this Long and the specified.\n * @this {!Long}\n * @param {!Long|number|bigint|string} other Other Long\n * @returns {!Long}\n */\nLongPrototype.and = function and(other) {\n  if (!isLong(other)) other = fromValue(other);\n  return fromBits(this.low & other.low, this.high & other.high, this.unsigned);\n};\n\n/**\n * Returns the bitwise OR of this Long and the specified.\n * @this {!Long}\n * @param {!Long|number|bigint|string} other Other Long\n * @returns {!Long}\n */\nLongPrototype.or = function or(other) {\n  if (!isLong(other)) other = fromValue(other);\n  return fromBits(this.low | other.low, this.high | other.high, this.unsigned);\n};\n\n/**\n * Returns the bitwise XOR of this Long and the given one.\n * @this {!Long}\n * @param {!Long|number|bigint|string} other Other Long\n * @returns {!Long}\n */\nLongPrototype.xor = function xor(other) {\n  if (!isLong(other)) other = fromValue(other);\n  return fromBits(this.low ^ other.low, this.high ^ other.high, this.unsigned);\n};\n\n/**\n * Returns this Long with bits shifted to the left by the given amount.\n * @this {!Long}\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Shifted Long\n */\nLongPrototype.shiftLeft = function shiftLeft(numBits) {\n  if (isLong(numBits)) numBits = numBits.toInt();\n  if ((numBits &= 63) === 0) return this;\n  else if (numBits < 32)\n    return fromBits(\n      this.low << numBits,\n      (this.high << numBits) | (this.low >>> (32 - numBits)),\n      this.unsigned,\n    );\n  else return fromBits(0, this.low << (numBits - 32), this.unsigned);\n};\n\n/**\n * Returns this Long with bits shifted to the left by the given amount. This is an alias of {@link Long#shiftLeft}.\n * @function\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Shifted Long\n */\nLongPrototype.shl = LongPrototype.shiftLeft;\n\n/**\n * Returns this Long with bits arithmetically shifted to the right by the given amount.\n * @this {!Long}\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Shifted Long\n */\nLongPrototype.shiftRight = function shiftRight(numBits) {\n  if (isLong(numBits)) numBits = numBits.toInt();\n  if ((numBits &= 63) === 0) return this;\n  else if (numBits < 32)\n    return fromBits(\n      (this.low >>> numBits) | (this.high << (32 - numBits)),\n      this.high >> numBits,\n      this.unsigned,\n    );\n  else\n    return fromBits(\n      this.high >> (numBits - 32),\n      this.high >= 0 ? 0 : -1,\n      this.unsigned,\n    );\n};\n\n/**\n * Returns this Long with bits arithmetically shifted to the right by the given amount. This is an alias of {@link Long#shiftRight}.\n * @function\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Shifted Long\n */\nLongPrototype.shr = LongPrototype.shiftRight;\n\n/**\n * Returns this Long with bits logically shifted to the right by the given amount.\n * @this {!Long}\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Shifted Long\n */\nLongPrototype.shiftRightUnsigned = function shiftRightUnsigned(numBits) {\n  if (isLong(numBits)) numBits = numBits.toInt();\n  if ((numBits &= 63) === 0) return this;\n  if (numBits < 32)\n    return fromBits(\n      (this.low >>> numBits) | (this.high << (32 - numBits)),\n      this.high >>> numBits,\n      this.unsigned,\n    );\n  if (numBits === 32) return fromBits(this.high, 0, this.unsigned);\n  return fromBits(this.high >>> (numBits - 32), 0, this.unsigned);\n};\n\n/**\n * Returns this Long with bits logically shifted to the right by the given amount. This is an alias of {@link Long#shiftRightUnsigned}.\n * @function\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Shifted Long\n */\nLongPrototype.shru = LongPrototype.shiftRightUnsigned;\n\n/**\n * Returns this Long with bits logically shifted to the right by the given amount. This is an alias of {@link Long#shiftRightUnsigned}.\n * @function\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Shifted Long\n */\nLongPrototype.shr_u = LongPrototype.shiftRightUnsigned;\n\n/**\n * Returns this Long with bits rotated to the left by the given amount.\n * @this {!Long}\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Rotated Long\n */\nLongPrototype.rotateLeft = function rotateLeft(numBits) {\n  var b;\n  if (isLong(numBits)) numBits = numBits.toInt();\n  if ((numBits &= 63) === 0) return this;\n  if (numBits === 32) return fromBits(this.high, this.low, this.unsigned);\n  if (numBits < 32) {\n    b = 32 - numBits;\n    return fromBits(\n      (this.low << numBits) | (this.high >>> b),\n      (this.high << numBits) | (this.low >>> b),\n      this.unsigned,\n    );\n  }\n  numBits -= 32;\n  b = 32 - numBits;\n  return fromBits(\n    (this.high << numBits) | (this.low >>> b),\n    (this.low << numBits) | (this.high >>> b),\n    this.unsigned,\n  );\n};\n/**\n * Returns this Long with bits rotated to the left by the given amount. This is an alias of {@link Long#rotateLeft}.\n * @function\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Rotated Long\n */\nLongPrototype.rotl = LongPrototype.rotateLeft;\n\n/**\n * Returns this Long with bits rotated to the right by the given amount.\n * @this {!Long}\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Rotated Long\n */\nLongPrototype.rotateRight = function rotateRight(numBits) {\n  var b;\n  if (isLong(numBits)) numBits = numBits.toInt();\n  if ((numBits &= 63) === 0) return this;\n  if (numBits === 32) return fromBits(this.high, this.low, this.unsigned);\n  if (numBits < 32) {\n    b = 32 - numBits;\n    return fromBits(\n      (this.high << b) | (this.low >>> numBits),\n      (this.low << b) | (this.high >>> numBits),\n      this.unsigned,\n    );\n  }\n  numBits -= 32;\n  b = 32 - numBits;\n  return fromBits(\n    (this.low << b) | (this.high >>> numBits),\n    (this.high << b) | (this.low >>> numBits),\n    this.unsigned,\n  );\n};\n/**\n * Returns this Long with bits rotated to the right by the given amount. This is an alias of {@link Long#rotateRight}.\n * @function\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Rotated Long\n */\nLongPrototype.rotr = LongPrototype.rotateRight;\n\n/**\n * Converts this Long to signed.\n * @this {!Long}\n * @returns {!Long} Signed long\n */\nLongPrototype.toSigned = function toSigned() {\n  if (!this.unsigned) return this;\n  return fromBits(this.low, this.high, false);\n};\n\n/**\n * Converts this Long to unsigned.\n * @this {!Long}\n * @returns {!Long} Unsigned long\n */\nLongPrototype.toUnsigned = function toUnsigned() {\n  if (this.unsigned) return this;\n  return fromBits(this.low, this.high, true);\n};\n\n/**\n * Converts this Long to its byte representation.\n * @param {boolean=} le Whether little or big endian, defaults to big endian\n * @this {!Long}\n * @returns {!Array.<number>} Byte representation\n */\nLongPrototype.toBytes = function toBytes(le) {\n  return le ? this.toBytesLE() : this.toBytesBE();\n};\n\n/**\n * Converts this Long to its little endian byte representation.\n * @this {!Long}\n * @returns {!Array.<number>} Little endian byte representation\n */\nLongPrototype.toBytesLE = function toBytesLE() {\n  var hi = this.high,\n    lo = this.low;\n  return [\n    lo & 0xff,\n    (lo >>> 8) & 0xff,\n    (lo >>> 16) & 0xff,\n    lo >>> 24,\n    hi & 0xff,\n    (hi >>> 8) & 0xff,\n    (hi >>> 16) & 0xff,\n    hi >>> 24,\n  ];\n};\n\n/**\n * Converts this Long to its big endian byte representation.\n * @this {!Long}\n * @returns {!Array.<number>} Big endian byte representation\n */\nLongPrototype.toBytesBE = function toBytesBE() {\n  var hi = this.high,\n    lo = this.low;\n  return [\n    hi >>> 24,\n    (hi >>> 16) & 0xff,\n    (hi >>> 8) & 0xff,\n    hi & 0xff,\n    lo >>> 24,\n    (lo >>> 16) & 0xff,\n    (lo >>> 8) & 0xff,\n    lo & 0xff,\n  ];\n};\n\n/**\n * Creates a Long from its byte representation.\n * @param {!Array.<number>} bytes Byte representation\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n * @param {boolean=} le Whether little or big endian, defaults to big endian\n * @returns {Long} The corresponding Long value\n */\nLong.fromBytes = function fromBytes(bytes, unsigned, le) {\n  return le\n    ? Long.fromBytesLE(bytes, unsigned)\n    : Long.fromBytesBE(bytes, unsigned);\n};\n\n/**\n * Creates a Long from its little endian byte representation.\n * @param {!Array.<number>} bytes Little endian byte representation\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n * @returns {Long} The corresponding Long value\n */\nLong.fromBytesLE = function fromBytesLE(bytes, unsigned) {\n  return new Long(\n    bytes[0] | (bytes[1] << 8) | (bytes[2] << 16) | (bytes[3] << 24),\n    bytes[4] | (bytes[5] << 8) | (bytes[6] << 16) | (bytes[7] << 24),\n    unsigned,\n  );\n};\n\n/**\n * Creates a Long from its big endian byte representation.\n * @param {!Array.<number>} bytes Big endian byte representation\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n * @returns {Long} The corresponding Long value\n */\nLong.fromBytesBE = function fromBytesBE(bytes, unsigned) {\n  return new Long(\n    (bytes[4] << 24) | (bytes[5] << 16) | (bytes[6] << 8) | bytes[7],\n    (bytes[0] << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3],\n    unsigned,\n  );\n};\n\n// Support conversion to/from BigInt where available\nif (typeof BigInt === \"function\") {\n  /**\n   * Returns a Long representing the given big integer.\n   * @function\n   * @param {number} value The big integer value\n   * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n   * @returns {!Long} The corresponding Long value\n   */\n  Long.fromBigInt = function fromBigInt(value, unsigned) {\n    var lowBits = Number(BigInt.asIntN(32, value));\n    var highBits = Number(BigInt.asIntN(32, value >> BigInt(32)));\n    return fromBits(lowBits, highBits, unsigned);\n  };\n\n  // Override\n  Long.fromValue = function fromValueWithBigInt(value, unsigned) {\n    if (typeof value === \"bigint\") return Long.fromBigInt(value, unsigned);\n    return fromValue(value, unsigned);\n  };\n\n  /**\n   * Converts the Long to its big integer representation.\n   * @this {!Long}\n   * @returns {bigint}\n   */\n  LongPrototype.toBigInt = function toBigInt() {\n    var lowBigInt = BigInt(this.low >>> 0);\n    var highBigInt = BigInt(this.unsigned ? this.high >>> 0 : this.high);\n    return (highBigInt << BigInt(32)) | lowBigInt;\n  };\n}\n\nexport default Long;\n", "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nexport enum ArgType {\n  INPUT = 0,\n  OUTPUT = 1,\n}\n", "\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.SIZE_PREFIX_LENGTH = exports.FILE_IDENTIFIER_LENGTH = exports.SIZEOF_INT = exports.SIZEOF_SHORT = void 0;\nexports.SIZEOF_SHORT = 2;\nexports.SIZEOF_INT = 4;\nexports.FILE_IDENTIFIER_LENGTH = 4;\nexports.SIZE_PREFIX_LENGTH = 4;\n", "\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.isLittleEndian = exports.float64 = exports.float32 = exports.int32 = void 0;\nexports.int32 = new Int32Array(2);\nexports.float32 = new Float32Array(exports.int32.buffer);\nexports.float64 = new Float64Array(exports.int32.buffer);\nexports.isLittleEndian = new Uint16Array(new Uint8Array([1, 0]).buffer)[0] === 1;\n", "\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.Encoding = void 0;\nvar Encoding;\n(function (Encoding) {\n    Encoding[Encoding[\"UTF8_BYTES\"] = 1] = \"UTF8_BYTES\";\n    Encoding[Encoding[\"UTF16_STRING\"] = 2] = \"UTF16_STRING\";\n})(Encoding || (exports.Encoding = Encoding = {}));\n", "\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.ByteBuffer = void 0;\nconst constants_js_1 = require(\"./constants.js\");\nconst encoding_js_1 = require(\"./encoding.js\");\nconst utils_js_1 = require(\"./utils.js\");\nclass ByteBuffer {\n    /**\n     * Create a new ByteBuffer with a given array of bytes (`Uint8Array`)\n     */\n    constructor(bytes_) {\n        this.bytes_ = bytes_;\n        this.position_ = 0;\n        this.text_decoder_ = new TextDecoder();\n    }\n    /**\n     * Create and allocate a new ByteBuffer with a given size.\n     */\n    static allocate(byte_size) {\n        return new ByteBuffer(new Uint8Array(byte_size));\n    }\n    clear() {\n        this.position_ = 0;\n    }\n    /**\n     * Get the underlying `Uint8Array`.\n     */\n    bytes() {\n        return this.bytes_;\n    }\n    /**\n     * Get the buffer's position.\n     */\n    position() {\n        return this.position_;\n    }\n    /**\n     * Set the buffer's position.\n     */\n    setPosition(position) {\n        this.position_ = position;\n    }\n    /**\n     * Get the buffer's capacity.\n     */\n    capacity() {\n        return this.bytes_.length;\n    }\n    readInt8(offset) {\n        return (this.readUint8(offset) << 24) >> 24;\n    }\n    readUint8(offset) {\n        return this.bytes_[offset];\n    }\n    readInt16(offset) {\n        return (this.readUint16(offset) << 16) >> 16;\n    }\n    readUint16(offset) {\n        return this.bytes_[offset] | (this.bytes_[offset + 1] << 8);\n    }\n    readInt32(offset) {\n        return (this.bytes_[offset] |\n            (this.bytes_[offset + 1] << 8) |\n            (this.bytes_[offset + 2] << 16) |\n            (this.bytes_[offset + 3] << 24));\n    }\n    readUint32(offset) {\n        return this.readInt32(offset) >>> 0;\n    }\n    readInt64(offset) {\n        return BigInt.asIntN(64, BigInt(this.readUint32(offset)) +\n            (BigInt(this.readUint32(offset + 4)) << BigInt(32)));\n    }\n    readUint64(offset) {\n        return BigInt.asUintN(64, BigInt(this.readUint32(offset)) +\n            (BigInt(this.readUint32(offset + 4)) << BigInt(32)));\n    }\n    readFloat32(offset) {\n        utils_js_1.int32[0] = this.readInt32(offset);\n        return utils_js_1.float32[0];\n    }\n    readFloat64(offset) {\n        utils_js_1.int32[utils_js_1.isLittleEndian ? 0 : 1] = this.readInt32(offset);\n        utils_js_1.int32[utils_js_1.isLittleEndian ? 1 : 0] = this.readInt32(offset + 4);\n        return utils_js_1.float64[0];\n    }\n    writeInt8(offset, value) {\n        this.bytes_[offset] = value;\n    }\n    writeUint8(offset, value) {\n        this.bytes_[offset] = value;\n    }\n    writeInt16(offset, value) {\n        this.bytes_[offset] = value;\n        this.bytes_[offset + 1] = value >> 8;\n    }\n    writeUint16(offset, value) {\n        this.bytes_[offset] = value;\n        this.bytes_[offset + 1] = value >> 8;\n    }\n    writeInt32(offset, value) {\n        this.bytes_[offset] = value;\n        this.bytes_[offset + 1] = value >> 8;\n        this.bytes_[offset + 2] = value >> 16;\n        this.bytes_[offset + 3] = value >> 24;\n    }\n    writeUint32(offset, value) {\n        this.bytes_[offset] = value;\n        this.bytes_[offset + 1] = value >> 8;\n        this.bytes_[offset + 2] = value >> 16;\n        this.bytes_[offset + 3] = value >> 24;\n    }\n    writeInt64(offset, value) {\n        this.writeInt32(offset, Number(BigInt.asIntN(32, value)));\n        this.writeInt32(offset + 4, Number(BigInt.asIntN(32, value >> BigInt(32))));\n    }\n    writeUint64(offset, value) {\n        this.writeUint32(offset, Number(BigInt.asUintN(32, value)));\n        this.writeUint32(offset + 4, Number(BigInt.asUintN(32, value >> BigInt(32))));\n    }\n    writeFloat32(offset, value) {\n        utils_js_1.float32[0] = value;\n        this.writeInt32(offset, utils_js_1.int32[0]);\n    }\n    writeFloat64(offset, value) {\n        utils_js_1.float64[0] = value;\n        this.writeInt32(offset, utils_js_1.int32[utils_js_1.isLittleEndian ? 0 : 1]);\n        this.writeInt32(offset + 4, utils_js_1.int32[utils_js_1.isLittleEndian ? 1 : 0]);\n    }\n    /**\n     * Return the file identifier.   Behavior is undefined for FlatBuffers whose\n     * schema does not include a file_identifier (likely points at padding or the\n     * start of a the root vtable).\n     */\n    getBufferIdentifier() {\n        if (this.bytes_.length <\n            this.position_ + constants_js_1.SIZEOF_INT + constants_js_1.FILE_IDENTIFIER_LENGTH) {\n            throw new Error('FlatBuffers: ByteBuffer is too short to contain an identifier.');\n        }\n        let result = '';\n        for (let i = 0; i < constants_js_1.FILE_IDENTIFIER_LENGTH; i++) {\n            result += String.fromCharCode(this.readInt8(this.position_ + constants_js_1.SIZEOF_INT + i));\n        }\n        return result;\n    }\n    /**\n     * Look up a field in the vtable, return an offset into the object, or 0 if the\n     * field is not present.\n     */\n    __offset(bb_pos, vtable_offset) {\n        const vtable = bb_pos - this.readInt32(bb_pos);\n        return vtable_offset < this.readInt16(vtable)\n            ? this.readInt16(vtable + vtable_offset)\n            : 0;\n    }\n    /**\n     * Initialize any Table-derived type to point to the union at the given offset.\n     */\n    __union(t, offset) {\n        t.bb_pos = offset + this.readInt32(offset);\n        t.bb = this;\n        return t;\n    }\n    /**\n     * Create a JavaScript string from UTF-8 data stored inside the FlatBuffer.\n     * This allocates a new string and converts to wide chars upon each access.\n     *\n     * To avoid the conversion to string, pass Encoding.UTF8_BYTES as the\n     * \"optionalEncoding\" argument. This is useful for avoiding conversion when\n     * the data will just be packaged back up in another FlatBuffer later on.\n     *\n     * @param offset\n     * @param opt_encoding Defaults to UTF16_STRING\n     */\n    __string(offset, opt_encoding) {\n        offset += this.readInt32(offset);\n        const length = this.readInt32(offset);\n        offset += constants_js_1.SIZEOF_INT;\n        const utf8bytes = this.bytes_.subarray(offset, offset + length);\n        if (opt_encoding === encoding_js_1.Encoding.UTF8_BYTES)\n            return utf8bytes;\n        else\n            return this.text_decoder_.decode(utf8bytes);\n    }\n    /**\n     * Handle unions that can contain string as its member, if a Table-derived type then initialize it,\n     * if a string then return a new one\n     *\n     * WARNING: strings are immutable in JS so we can't change the string that the user gave us, this\n     * makes the behaviour of __union_with_string different compared to __union\n     */\n    __union_with_string(o, offset) {\n        if (typeof o === 'string') {\n            return this.__string(offset);\n        }\n        return this.__union(o, offset);\n    }\n    /**\n     * Retrieve the relative offset stored at \"offset\"\n     */\n    __indirect(offset) {\n        return offset + this.readInt32(offset);\n    }\n    /**\n     * Get the start of data of a vector whose offset is stored at \"offset\" in this object.\n     */\n    __vector(offset) {\n        return offset + this.readInt32(offset) + constants_js_1.SIZEOF_INT; // data starts after the length\n    }\n    /**\n     * Get the length of a vector whose offset is stored at \"offset\" in this object.\n     */\n    __vector_len(offset) {\n        return this.readInt32(offset + this.readInt32(offset));\n    }\n    __has_identifier(ident) {\n        if (ident.length != constants_js_1.FILE_IDENTIFIER_LENGTH) {\n            throw new Error('FlatBuffers: file identifier must be length ' + constants_js_1.FILE_IDENTIFIER_LENGTH);\n        }\n        for (let i = 0; i < constants_js_1.FILE_IDENTIFIER_LENGTH; i++) {\n            if (ident.charCodeAt(i) != this.readInt8(this.position() + constants_js_1.SIZEOF_INT + i)) {\n                return false;\n            }\n        }\n        return true;\n    }\n    /**\n     * A helper function for generating list for obj api\n     */\n    createScalarList(listAccessor, listLength) {\n        const ret = [];\n        for (let i = 0; i < listLength; ++i) {\n            const val = listAccessor(i);\n            if (val !== null) {\n                ret.push(val);\n            }\n        }\n        return ret;\n    }\n    /**\n     * A helper function for generating list for obj api\n     * @param listAccessor function that accepts an index and return data at that index\n     * @param listLength listLength\n     * @param res result list\n     */\n    createObjList(listAccessor, listLength) {\n        const ret = [];\n        for (let i = 0; i < listLength; ++i) {\n            const val = listAccessor(i);\n            if (val !== null) {\n                ret.push(val.unpack());\n            }\n        }\n        return ret;\n    }\n}\nexports.ByteBuffer = ByteBuffer;\n", "\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.Builder = void 0;\nconst byte_buffer_js_1 = require(\"./byte-buffer.js\");\nconst constants_js_1 = require(\"./constants.js\");\nclass Builder {\n    /**\n     * Create a FlatBufferBuilder.\n     */\n    constructor(opt_initial_size) {\n        /** Minimum alignment encountered so far. */\n        this.minalign = 1;\n        /** The vtable for the current table. */\n        this.vtable = null;\n        /** The amount of fields we're actually using. */\n        this.vtable_in_use = 0;\n        /** Whether we are currently serializing a table. */\n        this.isNested = false;\n        /** Starting offset of the current struct/table. */\n        this.object_start = 0;\n        /** List of offsets of all vtables. */\n        this.vtables = [];\n        /** For the current vector being built. */\n        this.vector_num_elems = 0;\n        /** False omits default values from the serialized data */\n        this.force_defaults = false;\n        this.string_maps = null;\n        this.text_encoder = new TextEncoder();\n        let initial_size;\n        if (!opt_initial_size) {\n            initial_size = 1024;\n        }\n        else {\n            initial_size = opt_initial_size;\n        }\n        /**\n         * @type {ByteBuffer}\n         * @private\n         */\n        this.bb = byte_buffer_js_1.ByteBuffer.allocate(initial_size);\n        this.space = initial_size;\n    }\n    clear() {\n        this.bb.clear();\n        this.space = this.bb.capacity();\n        this.minalign = 1;\n        this.vtable = null;\n        this.vtable_in_use = 0;\n        this.isNested = false;\n        this.object_start = 0;\n        this.vtables = [];\n        this.vector_num_elems = 0;\n        this.force_defaults = false;\n        this.string_maps = null;\n    }\n    /**\n     * In order to save space, fields that are set to their default value\n     * don't get serialized into the buffer. Forcing defaults provides a\n     * way to manually disable this optimization.\n     *\n     * @param forceDefaults true always serializes default values\n     */\n    forceDefaults(forceDefaults) {\n        this.force_defaults = forceDefaults;\n    }\n    /**\n     * Get the ByteBuffer representing the FlatBuffer. Only call this after you've\n     * called finish(). The actual data starts at the ByteBuffer's current position,\n     * not necessarily at 0.\n     */\n    dataBuffer() {\n        return this.bb;\n    }\n    /**\n     * Get the bytes representing the FlatBuffer. Only call this after you've\n     * called finish().\n     */\n    asUint8Array() {\n        return this.bb\n            .bytes()\n            .subarray(this.bb.position(), this.bb.position() + this.offset());\n    }\n    /**\n     * Prepare to write an element of `size` after `additional_bytes` have been\n     * written, e.g. if you write a string, you need to align such the int length\n     * field is aligned to 4 bytes, and the string data follows it directly. If all\n     * you need to do is alignment, `additional_bytes` will be 0.\n     *\n     * @param size This is the of the new element to write\n     * @param additional_bytes The padding size\n     */\n    prep(size, additional_bytes) {\n        // Track the biggest thing we've ever aligned to.\n        if (size > this.minalign) {\n            this.minalign = size;\n        }\n        // Find the amount of alignment needed such that `size` is properly\n        // aligned after `additional_bytes`\n        const align_size = (~(this.bb.capacity() - this.space + additional_bytes) + 1) & (size - 1);\n        // Reallocate the buffer if needed.\n        while (this.space < align_size + size + additional_bytes) {\n            const old_buf_size = this.bb.capacity();\n            this.bb = Builder.growByteBuffer(this.bb);\n            this.space += this.bb.capacity() - old_buf_size;\n        }\n        this.pad(align_size);\n    }\n    pad(byte_size) {\n        for (let i = 0; i < byte_size; i++) {\n            this.bb.writeInt8(--this.space, 0);\n        }\n    }\n    writeInt8(value) {\n        this.bb.writeInt8((this.space -= 1), value);\n    }\n    writeInt16(value) {\n        this.bb.writeInt16((this.space -= 2), value);\n    }\n    writeInt32(value) {\n        this.bb.writeInt32((this.space -= 4), value);\n    }\n    writeInt64(value) {\n        this.bb.writeInt64((this.space -= 8), value);\n    }\n    writeFloat32(value) {\n        this.bb.writeFloat32((this.space -= 4), value);\n    }\n    writeFloat64(value) {\n        this.bb.writeFloat64((this.space -= 8), value);\n    }\n    /**\n     * Add an `int8` to the buffer, properly aligned, and grows the buffer (if necessary).\n     * @param value The `int8` to add the buffer.\n     */\n    addInt8(value) {\n        this.prep(1, 0);\n        this.writeInt8(value);\n    }\n    /**\n     * Add an `int16` to the buffer, properly aligned, and grows the buffer (if necessary).\n     * @param value The `int16` to add the buffer.\n     */\n    addInt16(value) {\n        this.prep(2, 0);\n        this.writeInt16(value);\n    }\n    /**\n     * Add an `int32` to the buffer, properly aligned, and grows the buffer (if necessary).\n     * @param value The `int32` to add the buffer.\n     */\n    addInt32(value) {\n        this.prep(4, 0);\n        this.writeInt32(value);\n    }\n    /**\n     * Add an `int64` to the buffer, properly aligned, and grows the buffer (if necessary).\n     * @param value The `int64` to add the buffer.\n     */\n    addInt64(value) {\n        this.prep(8, 0);\n        this.writeInt64(value);\n    }\n    /**\n     * Add a `float32` to the buffer, properly aligned, and grows the buffer (if necessary).\n     * @param value The `float32` to add the buffer.\n     */\n    addFloat32(value) {\n        this.prep(4, 0);\n        this.writeFloat32(value);\n    }\n    /**\n     * Add a `float64` to the buffer, properly aligned, and grows the buffer (if necessary).\n     * @param value The `float64` to add the buffer.\n     */\n    addFloat64(value) {\n        this.prep(8, 0);\n        this.writeFloat64(value);\n    }\n    addFieldInt8(voffset, value, defaultValue) {\n        if (this.force_defaults || value != defaultValue) {\n            this.addInt8(value);\n            this.slot(voffset);\n        }\n    }\n    addFieldInt16(voffset, value, defaultValue) {\n        if (this.force_defaults || value != defaultValue) {\n            this.addInt16(value);\n            this.slot(voffset);\n        }\n    }\n    addFieldInt32(voffset, value, defaultValue) {\n        if (this.force_defaults || value != defaultValue) {\n            this.addInt32(value);\n            this.slot(voffset);\n        }\n    }\n    addFieldInt64(voffset, value, defaultValue) {\n        if (this.force_defaults || value !== defaultValue) {\n            this.addInt64(value);\n            this.slot(voffset);\n        }\n    }\n    addFieldFloat32(voffset, value, defaultValue) {\n        if (this.force_defaults || value != defaultValue) {\n            this.addFloat32(value);\n            this.slot(voffset);\n        }\n    }\n    addFieldFloat64(voffset, value, defaultValue) {\n        if (this.force_defaults || value != defaultValue) {\n            this.addFloat64(value);\n            this.slot(voffset);\n        }\n    }\n    addFieldOffset(voffset, value, defaultValue) {\n        if (this.force_defaults || value != defaultValue) {\n            this.addOffset(value);\n            this.slot(voffset);\n        }\n    }\n    /**\n     * Structs are stored inline, so nothing additional is being added. `d` is always 0.\n     */\n    addFieldStruct(voffset, value, defaultValue) {\n        if (value != defaultValue) {\n            this.nested(value);\n            this.slot(voffset);\n        }\n    }\n    /**\n     * Structures are always stored inline, they need to be created right\n     * where they're used.  You'll get this assertion failure if you\n     * created it elsewhere.\n     */\n    nested(obj) {\n        if (obj != this.offset()) {\n            throw new TypeError('FlatBuffers: struct must be serialized inline.');\n        }\n    }\n    /**\n     * Should not be creating any other object, string or vector\n     * while an object is being constructed\n     */\n    notNested() {\n        if (this.isNested) {\n            throw new TypeError('FlatBuffers: object serialization must not be nested.');\n        }\n    }\n    /**\n     * Set the current vtable at `voffset` to the current location in the buffer.\n     */\n    slot(voffset) {\n        if (this.vtable !== null)\n            this.vtable[voffset] = this.offset();\n    }\n    /**\n     * @returns Offset relative to the end of the buffer.\n     */\n    offset() {\n        return this.bb.capacity() - this.space;\n    }\n    /**\n     * Doubles the size of the backing ByteBuffer and copies the old data towards\n     * the end of the new buffer (since we build the buffer backwards).\n     *\n     * @param bb The current buffer with the existing data\n     * @returns A new byte buffer with the old data copied\n     * to it. The data is located at the end of the buffer.\n     *\n     * uint8Array.set() formally takes {Array<number>|ArrayBufferView}, so to pass\n     * it a uint8Array we need to suppress the type check:\n     * @suppress {checkTypes}\n     */\n    static growByteBuffer(bb) {\n        const old_buf_size = bb.capacity();\n        // Ensure we don't grow beyond what fits in an int.\n        if (old_buf_size & 0xc0000000) {\n            throw new Error('FlatBuffers: cannot grow buffer beyond 2 gigabytes.');\n        }\n        const new_buf_size = old_buf_size << 1;\n        const nbb = byte_buffer_js_1.ByteBuffer.allocate(new_buf_size);\n        nbb.setPosition(new_buf_size - old_buf_size);\n        nbb.bytes().set(bb.bytes(), new_buf_size - old_buf_size);\n        return nbb;\n    }\n    /**\n     * Adds on offset, relative to where it will be written.\n     *\n     * @param offset The offset to add.\n     */\n    addOffset(offset) {\n        this.prep(constants_js_1.SIZEOF_INT, 0); // Ensure alignment is already done.\n        this.writeInt32(this.offset() - offset + constants_js_1.SIZEOF_INT);\n    }\n    /**\n     * Start encoding a new object in the buffer.  Users will not usually need to\n     * call this directly. The FlatBuffers compiler will generate helper methods\n     * that call this method internally.\n     */\n    startObject(numfields) {\n        this.notNested();\n        if (this.vtable == null) {\n            this.vtable = [];\n        }\n        this.vtable_in_use = numfields;\n        for (let i = 0; i < numfields; i++) {\n            this.vtable[i] = 0; // This will push additional elements as needed\n        }\n        this.isNested = true;\n        this.object_start = this.offset();\n    }\n    /**\n     * Finish off writing the object that is under construction.\n     *\n     * @returns The offset to the object inside `dataBuffer`\n     */\n    endObject() {\n        if (this.vtable == null || !this.isNested) {\n            throw new Error('FlatBuffers: endObject called without startObject');\n        }\n        this.addInt32(0);\n        const vtableloc = this.offset();\n        // Trim trailing zeroes.\n        let i = this.vtable_in_use - 1;\n        // eslint-disable-next-line no-empty\n        for (; i >= 0 && this.vtable[i] == 0; i--) { }\n        const trimmed_size = i + 1;\n        // Write out the current vtable.\n        for (; i >= 0; i--) {\n            // Offset relative to the start of the table.\n            this.addInt16(this.vtable[i] != 0 ? vtableloc - this.vtable[i] : 0);\n        }\n        const standard_fields = 2; // The fields below:\n        this.addInt16(vtableloc - this.object_start);\n        const len = (trimmed_size + standard_fields) * constants_js_1.SIZEOF_SHORT;\n        this.addInt16(len);\n        // Search for an existing vtable that matches the current one.\n        let existing_vtable = 0;\n        const vt1 = this.space;\n        outer_loop: for (i = 0; i < this.vtables.length; i++) {\n            const vt2 = this.bb.capacity() - this.vtables[i];\n            if (len == this.bb.readInt16(vt2)) {\n                for (let j = constants_js_1.SIZEOF_SHORT; j < len; j += constants_js_1.SIZEOF_SHORT) {\n                    if (this.bb.readInt16(vt1 + j) != this.bb.readInt16(vt2 + j)) {\n                        continue outer_loop;\n                    }\n                }\n                existing_vtable = this.vtables[i];\n                break;\n            }\n        }\n        if (existing_vtable) {\n            // Found a match:\n            // Remove the current vtable.\n            this.space = this.bb.capacity() - vtableloc;\n            // Point table to existing vtable.\n            this.bb.writeInt32(this.space, existing_vtable - vtableloc);\n        }\n        else {\n            // No match:\n            // Add the location of the current vtable to the list of vtables.\n            this.vtables.push(this.offset());\n            // Point table to current vtable.\n            this.bb.writeInt32(this.bb.capacity() - vtableloc, this.offset() - vtableloc);\n        }\n        this.isNested = false;\n        return vtableloc;\n    }\n    /**\n     * Finalize a buffer, poiting to the given `root_table`.\n     */\n    finish(root_table, opt_file_identifier, opt_size_prefix) {\n        const size_prefix = opt_size_prefix ? constants_js_1.SIZE_PREFIX_LENGTH : 0;\n        if (opt_file_identifier) {\n            const file_identifier = opt_file_identifier;\n            this.prep(this.minalign, constants_js_1.SIZEOF_INT + constants_js_1.FILE_IDENTIFIER_LENGTH + size_prefix);\n            if (file_identifier.length != constants_js_1.FILE_IDENTIFIER_LENGTH) {\n                throw new TypeError('FlatBuffers: file identifier must be length ' +\n                    constants_js_1.FILE_IDENTIFIER_LENGTH);\n            }\n            for (let i = constants_js_1.FILE_IDENTIFIER_LENGTH - 1; i >= 0; i--) {\n                this.writeInt8(file_identifier.charCodeAt(i));\n            }\n        }\n        this.prep(this.minalign, constants_js_1.SIZEOF_INT + size_prefix);\n        this.addOffset(root_table);\n        if (size_prefix) {\n            this.addInt32(this.bb.capacity() - this.space);\n        }\n        this.bb.setPosition(this.space);\n    }\n    /**\n     * Finalize a size prefixed buffer, pointing to the given `root_table`.\n     */\n    finishSizePrefixed(root_table, opt_file_identifier) {\n        this.finish(root_table, opt_file_identifier, true);\n    }\n    /**\n     * This checks a required field has been set in a given table that has\n     * just been constructed.\n     */\n    requiredField(table, field) {\n        const table_start = this.bb.capacity() - table;\n        const vtable_start = table_start - this.bb.readInt32(table_start);\n        const ok = field < this.bb.readInt16(vtable_start) &&\n            this.bb.readInt16(vtable_start + field) != 0;\n        // If this fails, the caller will show what field needs to be set.\n        if (!ok) {\n            throw new TypeError('FlatBuffers: field ' + field + ' must be set');\n        }\n    }\n    /**\n     * Start a new array/vector of objects.  Users usually will not call\n     * this directly. The FlatBuffers compiler will create a start/end\n     * method for vector types in generated code.\n     *\n     * @param elem_size The size of each element in the array\n     * @param num_elems The number of elements in the array\n     * @param alignment The alignment of the array\n     */\n    startVector(elem_size, num_elems, alignment) {\n        this.notNested();\n        this.vector_num_elems = num_elems;\n        this.prep(constants_js_1.SIZEOF_INT, elem_size * num_elems);\n        this.prep(alignment, elem_size * num_elems); // Just in case alignment > int.\n    }\n    /**\n     * Finish off the creation of an array and all its elements. The array must be\n     * created with `startVector`.\n     *\n     * @returns The offset at which the newly created array\n     * starts.\n     */\n    endVector() {\n        this.writeInt32(this.vector_num_elems);\n        return this.offset();\n    }\n    /**\n     * Encode the string `s` in the buffer using UTF-8. If the string passed has\n     * already been seen, we return the offset of the already written string\n     *\n     * @param s The string to encode\n     * @return The offset in the buffer where the encoded string starts\n     */\n    createSharedString(s) {\n        if (!s) {\n            return 0;\n        }\n        if (!this.string_maps) {\n            this.string_maps = new Map();\n        }\n        if (this.string_maps.has(s)) {\n            return this.string_maps.get(s);\n        }\n        const offset = this.createString(s);\n        this.string_maps.set(s, offset);\n        return offset;\n    }\n    /**\n     * Encode the string `s` in the buffer using UTF-8. If a Uint8Array is passed\n     * instead of a string, it is assumed to contain valid UTF-8 encoded data.\n     *\n     * @param s The string to encode\n     * @return The offset in the buffer where the encoded string starts\n     */\n    createString(s) {\n        if (s === null || s === undefined) {\n            return 0;\n        }\n        let utf8;\n        if (s instanceof Uint8Array) {\n            utf8 = s;\n        }\n        else {\n            utf8 = this.text_encoder.encode(s);\n        }\n        this.addInt8(0);\n        this.startVector(1, utf8.length, 1);\n        this.bb.setPosition((this.space -= utf8.length));\n        this.bb.bytes().set(utf8, this.space);\n        return this.endVector();\n    }\n    /**\n     * Create a byte vector.\n     *\n     * @param v The bytes to add\n     * @returns The offset in the buffer where the byte vector starts\n     */\n    createByteVector(v) {\n        if (v === null || v === undefined) {\n            return 0;\n        }\n        this.startVector(1, v.length, 1);\n        this.bb.setPosition((this.space -= v.length));\n        this.bb.bytes().set(v, this.space);\n        return this.endVector();\n    }\n    /**\n     * A helper function to pack an object\n     *\n     * @returns offset of obj\n     */\n    createObjectOffset(obj) {\n        if (obj === null) {\n            return 0;\n        }\n        if (typeof obj === 'string') {\n            return this.createString(obj);\n        }\n        else {\n            return obj.pack(this);\n        }\n    }\n    /**\n     * A helper function to pack a list of object\n     *\n     * @returns list of offsets of each non null object\n     */\n    createObjectOffsetList(list) {\n        const ret = [];\n        for (let i = 0; i < list.length; ++i) {\n            const val = list[i];\n            if (val !== null) {\n                ret.push(this.createObjectOffset(val));\n            }\n            else {\n                throw new TypeError('FlatBuffers: Argument for createObjectOffsetList cannot contain null.');\n            }\n        }\n        return ret;\n    }\n    createStructOffsetList(list, startFunc) {\n        startFunc(this, list.length);\n        this.createObjectOffsetList(list.slice().reverse());\n        return this.endVector();\n    }\n}\nexports.Builder = Builder;\n", "\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.Encoding = exports.ByteBuffer = exports.Builder = exports.isLittleEndian = exports.int32 = exports.float64 = exports.float32 = exports.SIZE_PREFIX_LENGTH = exports.SIZEOF_SHORT = exports.SIZEOF_INT = exports.FILE_IDENTIFIER_LENGTH = void 0;\nvar constants_js_1 = require(\"./constants.js\");\nObject.defineProperty(exports, \"FILE_IDENTIFIER_LENGTH\", { enumerable: true, get: function () { return constants_js_1.FILE_IDENTIFIER_LENGTH; } });\nObject.defineProperty(exports, \"SIZEOF_INT\", { enumerable: true, get: function () { return constants_js_1.SIZEOF_INT; } });\nObject.defineProperty(exports, \"SIZEOF_SHORT\", { enumerable: true, get: function () { return constants_js_1.SIZEOF_SHORT; } });\nObject.defineProperty(exports, \"SIZE_PREFIX_LENGTH\", { enumerable: true, get: function () { return constants_js_1.SIZE_PREFIX_LENGTH; } });\nvar utils_js_1 = require(\"./utils.js\");\nObject.defineProperty(exports, \"float32\", { enumerable: true, get: function () { return utils_js_1.float32; } });\nObject.defineProperty(exports, \"float64\", { enumerable: true, get: function () { return utils_js_1.float64; } });\nObject.defineProperty(exports, \"int32\", { enumerable: true, get: function () { return utils_js_1.int32; } });\nObject.defineProperty(exports, \"isLittleEndian\", { enumerable: true, get: function () { return utils_js_1.isLittleEndian; } });\nvar builder_js_1 = require(\"./builder.js\");\nObject.defineProperty(exports, \"Builder\", { enumerable: true, get: function () { return builder_js_1.Builder; } });\nvar byte_buffer_js_1 = require(\"./byte-buffer.js\");\nObject.defineProperty(exports, \"ByteBuffer\", { enumerable: true, get: function () { return byte_buffer_js_1.ByteBuffer; } });\nvar encoding_js_1 = require(\"./encoding.js\");\nObject.defineProperty(exports, \"Encoding\", { enumerable: true, get: function () { return encoding_js_1.Encoding; } });\n", "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nimport * as flatbuffers from 'flatbuffers';\n\nimport { ArgType } from '../../onnxruntime/fbs/arg-type.js';\n\nexport class ArgTypeAndIndex {\n  bb: flatbuffers.ByteBuffer | null = null;\n  bb_pos = 0;\n  __init(i: number, bb: flatbuffers.ByteBuffer): ArgTypeAndIndex {\n    this.bb_pos = i;\n    this.bb = bb;\n    return this;\n  }\n\n  static getRootAsArgTypeAndIndex(bb: flatbuffers.ByteBuffer, obj?: ArgTypeAndIndex): ArgTypeAndIndex {\n    return (obj || new ArgTypeAndIndex()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  static getSizePrefixedRootAsArgTypeAndIndex(bb: flatbuffers.ByteBuffer, obj?: ArgTypeAndIndex): ArgTypeAndIndex {\n    bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);\n    return (obj || new ArgTypeAndIndex()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  argType(): ArgType {\n    const offset = this.bb!.__offset(this.bb_pos, 4);\n    return offset ? this.bb!.readInt8(this.bb_pos + offset) : ArgType.INPUT;\n  }\n\n  index(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 6);\n    return offset ? this.bb!.readUint32(this.bb_pos + offset) : 0;\n  }\n\n  static startArgTypeAndIndex(builder: flatbuffers.Builder) {\n    builder.startObject(2);\n  }\n\n  static addArgType(builder: flatbuffers.Builder, argType: ArgType) {\n    builder.addFieldInt8(0, argType, ArgType.INPUT);\n  }\n\n  static addIndex(builder: flatbuffers.Builder, index: number) {\n    builder.addFieldInt32(1, index, 0);\n  }\n\n  static endArgTypeAndIndex(builder: flatbuffers.Builder): flatbuffers.Offset {\n    const offset = builder.endObject();\n    return offset;\n  }\n\n  static createArgTypeAndIndex(builder: flatbuffers.Builder, argType: ArgType, index: number): flatbuffers.Offset {\n    ArgTypeAndIndex.startArgTypeAndIndex(builder);\n    ArgTypeAndIndex.addArgType(builder, argType);\n    ArgTypeAndIndex.addIndex(builder, index);\n    return ArgTypeAndIndex.endArgTypeAndIndex(builder);\n  }\n}\n", "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nexport enum AttributeType {\n  UNDEFINED = 0,\n  FLOAT = 1,\n  INT = 2,\n  STRING = 3,\n  TENSOR = 4,\n  GRAPH = 5,\n  FLOATS = 6,\n  INTS = 7,\n  STRINGS = 8,\n  TENSORS = 9,\n  GRAPHS = 10,\n  SPARSE_TENSOR = 11,\n  SPARSE_TENSORS = 12,\n}\n", "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nexport enum NodeType {\n  Primitive = 0,\n  Fused = 1,\n}\n", "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nimport * as flatbuffers from 'flatbuffers';\n\nimport { Attribute } from '../../onnxruntime/fbs/attribute.js';\nimport { NodeType } from '../../onnxruntime/fbs/node-type.js';\n\nexport class Node {\n  bb: flatbuffers.ByteBuffer | null = null;\n  bb_pos = 0;\n  __init(i: number, bb: flatbuffers.ByteBuffer): Node {\n    this.bb_pos = i;\n    this.bb = bb;\n    return this;\n  }\n\n  static getRootAsNode(bb: flatbuffers.ByteBuffer, obj?: Node): Node {\n    return (obj || new Node()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  static getSizePrefixedRootAsNode(bb: flatbuffers.ByteBuffer, obj?: Node): Node {\n    bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);\n    return (obj || new Node()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  name(): string | null;\n  name(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;\n  name(optionalEncoding?: any): string | Uint8Array | null {\n    const offset = this.bb!.__offset(this.bb_pos, 4);\n    return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;\n  }\n\n  docString(): string | null;\n  docString(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;\n  docString(optionalEncoding?: any): string | Uint8Array | null {\n    const offset = this.bb!.__offset(this.bb_pos, 6);\n    return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;\n  }\n\n  domain(): string | null;\n  domain(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;\n  domain(optionalEncoding?: any): string | Uint8Array | null {\n    const offset = this.bb!.__offset(this.bb_pos, 8);\n    return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;\n  }\n\n  sinceVersion(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 10);\n    return offset ? this.bb!.readInt32(this.bb_pos + offset) : 0;\n  }\n\n  index(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 12);\n    return offset ? this.bb!.readUint32(this.bb_pos + offset) : 0;\n  }\n\n  opType(): string | null;\n  opType(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;\n  opType(optionalEncoding?: any): string | Uint8Array | null {\n    const offset = this.bb!.__offset(this.bb_pos, 14);\n    return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;\n  }\n\n  type(): NodeType {\n    const offset = this.bb!.__offset(this.bb_pos, 16);\n    return offset ? this.bb!.readInt32(this.bb_pos + offset) : NodeType.Primitive;\n  }\n\n  executionProviderType(): string | null;\n  executionProviderType(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;\n  executionProviderType(optionalEncoding?: any): string | Uint8Array | null {\n    const offset = this.bb!.__offset(this.bb_pos, 18);\n    return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;\n  }\n\n  inputs(index: number): string;\n  inputs(index: number, optionalEncoding: flatbuffers.Encoding): string | Uint8Array;\n  inputs(index: number, optionalEncoding?: any): string | Uint8Array | null {\n    const offset = this.bb!.__offset(this.bb_pos, 20);\n    return offset ? this.bb!.__string(this.bb!.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;\n  }\n\n  inputsLength(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 20);\n    return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n  }\n\n  outputs(index: number): string;\n  outputs(index: number, optionalEncoding: flatbuffers.Encoding): string | Uint8Array;\n  outputs(index: number, optionalEncoding?: any): string | Uint8Array | null {\n    const offset = this.bb!.__offset(this.bb_pos, 22);\n    return offset ? this.bb!.__string(this.bb!.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;\n  }\n\n  outputsLength(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 22);\n    return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n  }\n\n  attributes(index: number, obj?: Attribute): Attribute | null {\n    const offset = this.bb!.__offset(this.bb_pos, 24);\n    return offset\n      ? (obj || new Attribute()).__init(\n          this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4),\n          this.bb!,\n        )\n      : null;\n  }\n\n  attributesLength(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 24);\n    return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n  }\n\n  inputArgCounts(index: number): number | null {\n    const offset = this.bb!.__offset(this.bb_pos, 26);\n    return offset ? this.bb!.readInt32(this.bb!.__vector(this.bb_pos + offset) + index * 4) : 0;\n  }\n\n  inputArgCountsLength(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 26);\n    return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n  }\n\n  inputArgCountsArray(): Int32Array | null {\n    const offset = this.bb!.__offset(this.bb_pos, 26);\n    return offset\n      ? new Int32Array(\n          this.bb!.bytes().buffer,\n          this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset),\n          this.bb!.__vector_len(this.bb_pos + offset),\n        )\n      : null;\n  }\n\n  implicitInputs(index: number): string;\n  implicitInputs(index: number, optionalEncoding: flatbuffers.Encoding): string | Uint8Array;\n  implicitInputs(index: number, optionalEncoding?: any): string | Uint8Array | null {\n    const offset = this.bb!.__offset(this.bb_pos, 28);\n    return offset ? this.bb!.__string(this.bb!.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;\n  }\n\n  implicitInputsLength(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 28);\n    return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n  }\n\n  static startNode(builder: flatbuffers.Builder) {\n    builder.startObject(13);\n  }\n\n  static addName(builder: flatbuffers.Builder, nameOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(0, nameOffset, 0);\n  }\n\n  static addDocString(builder: flatbuffers.Builder, docStringOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(1, docStringOffset, 0);\n  }\n\n  static addDomain(builder: flatbuffers.Builder, domainOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(2, domainOffset, 0);\n  }\n\n  static addSinceVersion(builder: flatbuffers.Builder, sinceVersion: number) {\n    builder.addFieldInt32(3, sinceVersion, 0);\n  }\n\n  static addIndex(builder: flatbuffers.Builder, index: number) {\n    builder.addFieldInt32(4, index, 0);\n  }\n\n  static addOpType(builder: flatbuffers.Builder, opTypeOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(5, opTypeOffset, 0);\n  }\n\n  static addType(builder: flatbuffers.Builder, type: NodeType) {\n    builder.addFieldInt32(6, type, NodeType.Primitive);\n  }\n\n  static addExecutionProviderType(builder: flatbuffers.Builder, executionProviderTypeOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(7, executionProviderTypeOffset, 0);\n  }\n\n  static addInputs(builder: flatbuffers.Builder, inputsOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(8, inputsOffset, 0);\n  }\n\n  static createInputsVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset {\n    builder.startVector(4, data.length, 4);\n    for (let i = data.length - 1; i >= 0; i--) {\n      builder.addOffset(data[i]!);\n    }\n    return builder.endVector();\n  }\n\n  static startInputsVector(builder: flatbuffers.Builder, numElems: number) {\n    builder.startVector(4, numElems, 4);\n  }\n\n  static addOutputs(builder: flatbuffers.Builder, outputsOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(9, outputsOffset, 0);\n  }\n\n  static createOutputsVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset {\n    builder.startVector(4, data.length, 4);\n    for (let i = data.length - 1; i >= 0; i--) {\n      builder.addOffset(data[i]!);\n    }\n    return builder.endVector();\n  }\n\n  static startOutputsVector(builder: flatbuffers.Builder, numElems: number) {\n    builder.startVector(4, numElems, 4);\n  }\n\n  static addAttributes(builder: flatbuffers.Builder, attributesOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(10, attributesOffset, 0);\n  }\n\n  static createAttributesVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset {\n    builder.startVector(4, data.length, 4);\n    for (let i = data.length - 1; i >= 0; i--) {\n      builder.addOffset(data[i]!);\n    }\n    return builder.endVector();\n  }\n\n  static startAttributesVector(builder: flatbuffers.Builder, numElems: number) {\n    builder.startVector(4, numElems, 4);\n  }\n\n  static addInputArgCounts(builder: flatbuffers.Builder, inputArgCountsOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(11, inputArgCountsOffset, 0);\n  }\n\n  static createInputArgCountsVector(builder: flatbuffers.Builder, data: number[] | Int32Array): flatbuffers.Offset;\n  /**\n   * @deprecated This Uint8Array overload will be removed in the future.\n   */\n  static createInputArgCountsVector(builder: flatbuffers.Builder, data: number[] | Uint8Array): flatbuffers.Offset;\n  static createInputArgCountsVector(\n    builder: flatbuffers.Builder,\n    data: number[] | Int32Array | Uint8Array,\n  ): flatbuffers.Offset {\n    builder.startVector(4, data.length, 4);\n    for (let i = data.length - 1; i >= 0; i--) {\n      builder.addInt32(data[i]!);\n    }\n    return builder.endVector();\n  }\n\n  static startInputArgCountsVector(builder: flatbuffers.Builder, numElems: number) {\n    builder.startVector(4, numElems, 4);\n  }\n\n  static addImplicitInputs(builder: flatbuffers.Builder, implicitInputsOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(12, implicitInputsOffset, 0);\n  }\n\n  static createImplicitInputsVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset {\n    builder.startVector(4, data.length, 4);\n    for (let i = data.length - 1; i >= 0; i--) {\n      builder.addOffset(data[i]!);\n    }\n    return builder.endVector();\n  }\n\n  static startImplicitInputsVector(builder: flatbuffers.Builder, numElems: number) {\n    builder.startVector(4, numElems, 4);\n  }\n\n  static endNode(builder: flatbuffers.Builder): flatbuffers.Offset {\n    const offset = builder.endObject();\n    return offset;\n  }\n\n  static createNode(\n    builder: flatbuffers.Builder,\n    nameOffset: flatbuffers.Offset,\n    docStringOffset: flatbuffers.Offset,\n    domainOffset: flatbuffers.Offset,\n    sinceVersion: number,\n    index: number,\n    opTypeOffset: flatbuffers.Offset,\n    type: NodeType,\n    executionProviderTypeOffset: flatbuffers.Offset,\n    inputsOffset: flatbuffers.Offset,\n    outputsOffset: flatbuffers.Offset,\n    attributesOffset: flatbuffers.Offset,\n    inputArgCountsOffset: flatbuffers.Offset,\n    implicitInputsOffset: flatbuffers.Offset,\n  ): flatbuffers.Offset {\n    Node.startNode(builder);\n    Node.addName(builder, nameOffset);\n    Node.addDocString(builder, docStringOffset);\n    Node.addDomain(builder, domainOffset);\n    Node.addSinceVersion(builder, sinceVersion);\n    Node.addIndex(builder, index);\n    Node.addOpType(builder, opTypeOffset);\n    Node.addType(builder, type);\n    Node.addExecutionProviderType(builder, executionProviderTypeOffset);\n    Node.addInputs(builder, inputsOffset);\n    Node.addOutputs(builder, outputsOffset);\n    Node.addAttributes(builder, attributesOffset);\n    Node.addInputArgCounts(builder, inputArgCountsOffset);\n    Node.addImplicitInputs(builder, implicitInputsOffset);\n    return Node.endNode(builder);\n  }\n}\n", "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nimport * as flatbuffers from 'flatbuffers';\n\nexport class EdgeEnd {\n  bb: flatbuffers.ByteBuffer | null = null;\n  bb_pos = 0;\n  __init(i: number, bb: flatbuffers.ByteBuffer): EdgeEnd {\n    this.bb_pos = i;\n    this.bb = bb;\n    return this;\n  }\n\n  nodeIndex(): number {\n    return this.bb!.readUint32(this.bb_pos);\n  }\n\n  srcArgIndex(): number {\n    return this.bb!.readInt32(this.bb_pos + 4);\n  }\n\n  dstArgIndex(): number {\n    return this.bb!.readInt32(this.bb_pos + 8);\n  }\n\n  static sizeOf(): number {\n    return 12;\n  }\n\n  static createEdgeEnd(\n    builder: flatbuffers.Builder,\n    node_index: number,\n    src_arg_index: number,\n    dst_arg_index: number,\n  ): flatbuffers.Offset {\n    builder.prep(4, 12);\n    builder.writeInt32(dst_arg_index);\n    builder.writeInt32(src_arg_index);\n    builder.writeInt32(node_index);\n    return builder.offset();\n  }\n}\n", "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nimport * as flatbuffers from 'flatbuffers';\n\nimport { EdgeEnd } from '../../onnxruntime/fbs/edge-end.js';\n\nexport class NodeEdge {\n  bb: flatbuffers.ByteBuffer | null = null;\n  bb_pos = 0;\n  __init(i: number, bb: flatbuffers.ByteBuffer): NodeEdge {\n    this.bb_pos = i;\n    this.bb = bb;\n    return this;\n  }\n\n  static getRootAsNodeEdge(bb: flatbuffers.ByteBuffer, obj?: NodeEdge): NodeEdge {\n    return (obj || new NodeEdge()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  static getSizePrefixedRootAsNodeEdge(bb: flatbuffers.ByteBuffer, obj?: NodeEdge): NodeEdge {\n    bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);\n    return (obj || new NodeEdge()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  nodeIndex(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 4);\n    return offset ? this.bb!.readUint32(this.bb_pos + offset) : 0;\n  }\n\n  inputEdges(index: number, obj?: EdgeEnd): EdgeEnd | null {\n    const offset = this.bb!.__offset(this.bb_pos, 6);\n    return offset\n      ? (obj || new EdgeEnd()).__init(this.bb!.__vector(this.bb_pos + offset) + index * 12, this.bb!)\n      : null;\n  }\n\n  inputEdgesLength(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 6);\n    return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n  }\n\n  outputEdges(index: number, obj?: EdgeEnd): EdgeEnd | null {\n    const offset = this.bb!.__offset(this.bb_pos, 8);\n    return offset\n      ? (obj || new EdgeEnd()).__init(this.bb!.__vector(this.bb_pos + offset) + index * 12, this.bb!)\n      : null;\n  }\n\n  outputEdgesLength(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 8);\n    return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n  }\n\n  static startNodeEdge(builder: flatbuffers.Builder) {\n    builder.startObject(3);\n  }\n\n  static addNodeIndex(builder: flatbuffers.Builder, nodeIndex: number) {\n    builder.addFieldInt32(0, nodeIndex, 0);\n  }\n\n  static addInputEdges(builder: flatbuffers.Builder, inputEdgesOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(1, inputEdgesOffset, 0);\n  }\n\n  static startInputEdgesVector(builder: flatbuffers.Builder, numElems: number) {\n    builder.startVector(12, numElems, 4);\n  }\n\n  static addOutputEdges(builder: flatbuffers.Builder, outputEdgesOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(2, outputEdgesOffset, 0);\n  }\n\n  static startOutputEdgesVector(builder: flatbuffers.Builder, numElems: number) {\n    builder.startVector(12, numElems, 4);\n  }\n\n  static endNodeEdge(builder: flatbuffers.Builder): flatbuffers.Offset {\n    const offset = builder.endObject();\n    return offset;\n  }\n\n  static createNodeEdge(\n    builder: flatbuffers.Builder,\n    nodeIndex: number,\n    inputEdgesOffset: flatbuffers.Offset,\n    outputEdgesOffset: flatbuffers.Offset,\n  ): flatbuffers.Offset {\n    NodeEdge.startNodeEdge(builder);\n    NodeEdge.addNodeIndex(builder, nodeIndex);\n    NodeEdge.addInputEdges(builder, inputEdgesOffset);\n    NodeEdge.addOutputEdges(builder, outputEdgesOffset);\n    return NodeEdge.endNodeEdge(builder);\n  }\n}\n", "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nimport * as flatbuffers from 'flatbuffers';\n\n/**\n * nodes to consider for a runtime optimization\n * see corresponding type in onnxruntime/core/graph/runtime_optimization_record.h\n */\nexport class NodesToOptimizeIndices {\n  bb: flatbuffers.ByteBuffer | null = null;\n  bb_pos = 0;\n  __init(i: number, bb: flatbuffers.ByteBuffer): NodesToOptimizeIndices {\n    this.bb_pos = i;\n    this.bb = bb;\n    return this;\n  }\n\n  static getRootAsNodesToOptimizeIndices(\n    bb: flatbuffers.ByteBuffer,\n    obj?: NodesToOptimizeIndices,\n  ): NodesToOptimizeIndices {\n    return (obj || new NodesToOptimizeIndices()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  static getSizePrefixedRootAsNodesToOptimizeIndices(\n    bb: flatbuffers.ByteBuffer,\n    obj?: NodesToOptimizeIndices,\n  ): NodesToOptimizeIndices {\n    bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);\n    return (obj || new NodesToOptimizeIndices()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  nodeIndices(index: number): number | null {\n    const offset = this.bb!.__offset(this.bb_pos, 4);\n    return offset ? this.bb!.readUint32(this.bb!.__vector(this.bb_pos + offset) + index * 4) : 0;\n  }\n\n  nodeIndicesLength(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 4);\n    return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n  }\n\n  nodeIndicesArray(): Uint32Array | null {\n    const offset = this.bb!.__offset(this.bb_pos, 4);\n    return offset\n      ? new Uint32Array(\n          this.bb!.bytes().buffer,\n          this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset),\n          this.bb!.__vector_len(this.bb_pos + offset),\n        )\n      : null;\n  }\n\n  numInputs(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 6);\n    return offset ? this.bb!.readUint32(this.bb_pos + offset) : 0;\n  }\n\n  numOutputs(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 8);\n    return offset ? this.bb!.readUint32(this.bb_pos + offset) : 0;\n  }\n\n  hasVariadicInput(): boolean {\n    const offset = this.bb!.__offset(this.bb_pos, 10);\n    return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false;\n  }\n\n  hasVariadicOutput(): boolean {\n    const offset = this.bb!.__offset(this.bb_pos, 12);\n    return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false;\n  }\n\n  numVariadicInputs(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 14);\n    return offset ? this.bb!.readUint32(this.bb_pos + offset) : 0;\n  }\n\n  numVariadicOutputs(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 16);\n    return offset ? this.bb!.readUint32(this.bb_pos + offset) : 0;\n  }\n\n  static startNodesToOptimizeIndices(builder: flatbuffers.Builder) {\n    builder.startObject(7);\n  }\n\n  static addNodeIndices(builder: flatbuffers.Builder, nodeIndicesOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(0, nodeIndicesOffset, 0);\n  }\n\n  static createNodeIndicesVector(builder: flatbuffers.Builder, data: number[] | Uint32Array): flatbuffers.Offset;\n  /**\n   * @deprecated This Uint8Array overload will be removed in the future.\n   */\n  static createNodeIndicesVector(builder: flatbuffers.Builder, data: number[] | Uint8Array): flatbuffers.Offset;\n  static createNodeIndicesVector(\n    builder: flatbuffers.Builder,\n    data: number[] | Uint32Array | Uint8Array,\n  ): flatbuffers.Offset {\n    builder.startVector(4, data.length, 4);\n    for (let i = data.length - 1; i >= 0; i--) {\n      builder.addInt32(data[i]!);\n    }\n    return builder.endVector();\n  }\n\n  static startNodeIndicesVector(builder: flatbuffers.Builder, numElems: number) {\n    builder.startVector(4, numElems, 4);\n  }\n\n  static addNumInputs(builder: flatbuffers.Builder, numInputs: number) {\n    builder.addFieldInt32(1, numInputs, 0);\n  }\n\n  static addNumOutputs(builder: flatbuffers.Builder, numOutputs: number) {\n    builder.addFieldInt32(2, numOutputs, 0);\n  }\n\n  static addHasVariadicInput(builder: flatbuffers.Builder, hasVariadicInput: boolean) {\n    builder.addFieldInt8(3, +hasVariadicInput, +false);\n  }\n\n  static addHasVariadicOutput(builder: flatbuffers.Builder, hasVariadicOutput: boolean) {\n    builder.addFieldInt8(4, +hasVariadicOutput, +false);\n  }\n\n  static addNumVariadicInputs(builder: flatbuffers.Builder, numVariadicInputs: number) {\n    builder.addFieldInt32(5, numVariadicInputs, 0);\n  }\n\n  static addNumVariadicOutputs(builder: flatbuffers.Builder, numVariadicOutputs: number) {\n    builder.addFieldInt32(6, numVariadicOutputs, 0);\n  }\n\n  static endNodesToOptimizeIndices(builder: flatbuffers.Builder): flatbuffers.Offset {\n    const offset = builder.endObject();\n    return offset;\n  }\n\n  static createNodesToOptimizeIndices(\n    builder: flatbuffers.Builder,\n    nodeIndicesOffset: flatbuffers.Offset,\n    numInputs: number,\n    numOutputs: number,\n    hasVariadicInput: boolean,\n    hasVariadicOutput: boolean,\n    numVariadicInputs: number,\n    numVariadicOutputs: number,\n  ): flatbuffers.Offset {\n    NodesToOptimizeIndices.startNodesToOptimizeIndices(builder);\n    NodesToOptimizeIndices.addNodeIndices(builder, nodeIndicesOffset);\n    NodesToOptimizeIndices.addNumInputs(builder, numInputs);\n    NodesToOptimizeIndices.addNumOutputs(builder, numOutputs);\n    NodesToOptimizeIndices.addHasVariadicInput(builder, hasVariadicInput);\n    NodesToOptimizeIndices.addHasVariadicOutput(builder, hasVariadicOutput);\n    NodesToOptimizeIndices.addNumVariadicInputs(builder, numVariadicInputs);\n    NodesToOptimizeIndices.addNumVariadicOutputs(builder, numVariadicOutputs);\n    return NodesToOptimizeIndices.endNodesToOptimizeIndices(builder);\n  }\n}\n", "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nimport * as flatbuffers from 'flatbuffers';\n\nimport { NodesToOptimizeIndices } from '../../onnxruntime/fbs/nodes-to-optimize-indices.js';\n\n/**\n * a single runtime optimization\n * see corresponding type in onnxruntime/core/graph/runtime_optimization_record.h\n */\nexport class RuntimeOptimizationRecord {\n  bb: flatbuffers.ByteBuffer | null = null;\n  bb_pos = 0;\n  __init(i: number, bb: flatbuffers.ByteBuffer): RuntimeOptimizationRecord {\n    this.bb_pos = i;\n    this.bb = bb;\n    return this;\n  }\n\n  static getRootAsRuntimeOptimizationRecord(\n    bb: flatbuffers.ByteBuffer,\n    obj?: RuntimeOptimizationRecord,\n  ): RuntimeOptimizationRecord {\n    return (obj || new RuntimeOptimizationRecord()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  static getSizePrefixedRootAsRuntimeOptimizationRecord(\n    bb: flatbuffers.ByteBuffer,\n    obj?: RuntimeOptimizationRecord,\n  ): RuntimeOptimizationRecord {\n    bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);\n    return (obj || new RuntimeOptimizationRecord()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  actionId(): string | null;\n  actionId(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;\n  actionId(optionalEncoding?: any): string | Uint8Array | null {\n    const offset = this.bb!.__offset(this.bb_pos, 4);\n    return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;\n  }\n\n  nodesToOptimizeIndices(obj?: NodesToOptimizeIndices): NodesToOptimizeIndices | null {\n    const offset = this.bb!.__offset(this.bb_pos, 6);\n    return offset\n      ? (obj || new NodesToOptimizeIndices()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!)\n      : null;\n  }\n\n  producedOpIds(index: number): string;\n  producedOpIds(index: number, optionalEncoding: flatbuffers.Encoding): string | Uint8Array;\n  producedOpIds(index: number, optionalEncoding?: any): string | Uint8Array | null {\n    const offset = this.bb!.__offset(this.bb_pos, 10);\n    return offset ? this.bb!.__string(this.bb!.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;\n  }\n\n  producedOpIdsLength(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 10);\n    return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n  }\n\n  static startRuntimeOptimizationRecord(builder: flatbuffers.Builder) {\n    builder.startObject(4);\n  }\n\n  static addActionId(builder: flatbuffers.Builder, actionIdOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(0, actionIdOffset, 0);\n  }\n\n  static addNodesToOptimizeIndices(builder: flatbuffers.Builder, nodesToOptimizeIndicesOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(1, nodesToOptimizeIndicesOffset, 0);\n  }\n\n  static addProducedOpIds(builder: flatbuffers.Builder, producedOpIdsOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(3, producedOpIdsOffset, 0);\n  }\n\n  static createProducedOpIdsVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset {\n    builder.startVector(4, data.length, 4);\n    for (let i = data.length - 1; i >= 0; i--) {\n      builder.addOffset(data[i]!);\n    }\n    return builder.endVector();\n  }\n\n  static startProducedOpIdsVector(builder: flatbuffers.Builder, numElems: number) {\n    builder.startVector(4, numElems, 4);\n  }\n\n  static endRuntimeOptimizationRecord(builder: flatbuffers.Builder): flatbuffers.Offset {\n    const offset = builder.endObject();\n    return offset;\n  }\n}\n", "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nimport * as flatbuffers from 'flatbuffers';\n\nimport { RuntimeOptimizationRecord } from '../../onnxruntime/fbs/runtime-optimization-record.js';\n\nexport class RuntimeOptimizationRecordContainerEntry {\n  bb: flatbuffers.ByteBuffer | null = null;\n  bb_pos = 0;\n  __init(i: number, bb: flatbuffers.ByteBuffer): RuntimeOptimizationRecordContainerEntry {\n    this.bb_pos = i;\n    this.bb = bb;\n    return this;\n  }\n\n  static getRootAsRuntimeOptimizationRecordContainerEntry(\n    bb: flatbuffers.ByteBuffer,\n    obj?: RuntimeOptimizationRecordContainerEntry,\n  ): RuntimeOptimizationRecordContainerEntry {\n    return (obj || new RuntimeOptimizationRecordContainerEntry()).__init(\n      bb.readInt32(bb.position()) + bb.position(),\n      bb,\n    );\n  }\n\n  static getSizePrefixedRootAsRuntimeOptimizationRecordContainerEntry(\n    bb: flatbuffers.ByteBuffer,\n    obj?: RuntimeOptimizationRecordContainerEntry,\n  ): RuntimeOptimizationRecordContainerEntry {\n    bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);\n    return (obj || new RuntimeOptimizationRecordContainerEntry()).__init(\n      bb.readInt32(bb.position()) + bb.position(),\n      bb,\n    );\n  }\n\n  optimizerName(): string | null;\n  optimizerName(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;\n  optimizerName(optionalEncoding?: any): string | Uint8Array | null {\n    const offset = this.bb!.__offset(this.bb_pos, 4);\n    return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;\n  }\n\n  runtimeOptimizationRecords(index: number, obj?: RuntimeOptimizationRecord): RuntimeOptimizationRecord | null {\n    const offset = this.bb!.__offset(this.bb_pos, 6);\n    return offset\n      ? (obj || new RuntimeOptimizationRecord()).__init(\n          this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4),\n          this.bb!,\n        )\n      : null;\n  }\n\n  runtimeOptimizationRecordsLength(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 6);\n    return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n  }\n\n  static startRuntimeOptimizationRecordContainerEntry(builder: flatbuffers.Builder) {\n    builder.startObject(2);\n  }\n\n  static addOptimizerName(builder: flatbuffers.Builder, optimizerNameOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(0, optimizerNameOffset, 0);\n  }\n\n  static addRuntimeOptimizationRecords(\n    builder: flatbuffers.Builder,\n    runtimeOptimizationRecordsOffset: flatbuffers.Offset,\n  ) {\n    builder.addFieldOffset(1, runtimeOptimizationRecordsOffset, 0);\n  }\n\n  static createRuntimeOptimizationRecordsVector(\n    builder: flatbuffers.Builder,\n    data: flatbuffers.Offset[],\n  ): flatbuffers.Offset {\n    builder.startVector(4, data.length, 4);\n    for (let i = data.length - 1; i >= 0; i--) {\n      builder.addOffset(data[i]!);\n    }\n    return builder.endVector();\n  }\n\n  static startRuntimeOptimizationRecordsVector(builder: flatbuffers.Builder, numElems: number) {\n    builder.startVector(4, numElems, 4);\n  }\n\n  static endRuntimeOptimizationRecordContainerEntry(builder: flatbuffers.Builder): flatbuffers.Offset {\n    const offset = builder.endObject();\n    builder.requiredField(offset, 4); // optimizer_name\n    return offset;\n  }\n\n  static createRuntimeOptimizationRecordContainerEntry(\n    builder: flatbuffers.Builder,\n    optimizerNameOffset: flatbuffers.Offset,\n    runtimeOptimizationRecordsOffset: flatbuffers.Offset,\n  ): flatbuffers.Offset {\n    RuntimeOptimizationRecordContainerEntry.startRuntimeOptimizationRecordContainerEntry(builder);\n    RuntimeOptimizationRecordContainerEntry.addOptimizerName(builder, optimizerNameOffset);\n    RuntimeOptimizationRecordContainerEntry.addRuntimeOptimizationRecords(builder, runtimeOptimizationRecordsOffset);\n    return RuntimeOptimizationRecordContainerEntry.endRuntimeOptimizationRecordContainerEntry(builder);\n  }\n}\n", "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nimport * as flatbuffers from 'flatbuffers';\n\nimport { RuntimeOptimizationRecordContainerEntry } from '../../onnxruntime/fbs/runtime-optimization-record-container-entry.js';\n\nexport class RuntimeOptimizations {\n  bb: flatbuffers.ByteBuffer | null = null;\n  bb_pos = 0;\n  __init(i: number, bb: flatbuffers.ByteBuffer): RuntimeOptimizations {\n    this.bb_pos = i;\n    this.bb = bb;\n    return this;\n  }\n\n  static getRootAsRuntimeOptimizations(bb: flatbuffers.ByteBuffer, obj?: RuntimeOptimizations): RuntimeOptimizations {\n    return (obj || new RuntimeOptimizations()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  static getSizePrefixedRootAsRuntimeOptimizations(\n    bb: flatbuffers.ByteBuffer,\n    obj?: RuntimeOptimizations,\n  ): RuntimeOptimizations {\n    bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);\n    return (obj || new RuntimeOptimizations()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  /**\n   * mapping from optimizer name to [RuntimeOptimizationRecord]\n   */\n  records(\n    index: number,\n    obj?: RuntimeOptimizationRecordContainerEntry,\n  ): RuntimeOptimizationRecordContainerEntry | null {\n    const offset = this.bb!.__offset(this.bb_pos, 4);\n    return offset\n      ? (obj || new RuntimeOptimizationRecordContainerEntry()).__init(\n          this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4),\n          this.bb!,\n        )\n      : null;\n  }\n\n  recordsLength(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 4);\n    return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n  }\n\n  static startRuntimeOptimizations(builder: flatbuffers.Builder) {\n    builder.startObject(1);\n  }\n\n  static addRecords(builder: flatbuffers.Builder, recordsOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(0, recordsOffset, 0);\n  }\n\n  static createRecordsVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset {\n    builder.startVector(4, data.length, 4);\n    for (let i = data.length - 1; i >= 0; i--) {\n      builder.addOffset(data[i]!);\n    }\n    return builder.endVector();\n  }\n\n  static startRecordsVector(builder: flatbuffers.Builder, numElems: number) {\n    builder.startVector(4, numElems, 4);\n  }\n\n  static endRuntimeOptimizations(builder: flatbuffers.Builder): flatbuffers.Offset {\n    const offset = builder.endObject();\n    return offset;\n  }\n\n  static createRuntimeOptimizations(\n    builder: flatbuffers.Builder,\n    recordsOffset: flatbuffers.Offset,\n  ): flatbuffers.Offset {\n    RuntimeOptimizations.startRuntimeOptimizations(builder);\n    RuntimeOptimizations.addRecords(builder, recordsOffset);\n    return RuntimeOptimizations.endRuntimeOptimizations(builder);\n  }\n}\n", "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nexport enum TensorDataType {\n  UNDEFINED = 0,\n  FLOAT = 1,\n  UINT8 = 2,\n  INT8 = 3,\n  UINT16 = 4,\n  INT16 = 5,\n  INT32 = 6,\n  INT64 = 7,\n  STRING = 8,\n  BOOL = 9,\n  FLOAT16 = 10,\n  DOUBLE = 11,\n  UINT32 = 12,\n  UINT64 = 13,\n  COMPLEX64 = 14,\n  COMPLEX128 = 15,\n  BFLOAT16 = 16,\n  FLOAT8E4M3FN = 17,\n  FLOAT8E4M3FNUZ = 18,\n  FLOAT8E5M2 = 19,\n  FLOAT8E5M2FNUZ = 20,\n}\n", "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nimport * as flatbuffers from 'flatbuffers';\n\nimport { TensorDataType } from '../../onnxruntime/fbs/tensor-data-type.js';\n\nexport class Tensor {\n  bb: flatbuffers.ByteBuffer | null = null;\n  bb_pos = 0;\n  __init(i: number, bb: flatbuffers.ByteBuffer): Tensor {\n    this.bb_pos = i;\n    this.bb = bb;\n    return this;\n  }\n\n  static getRootAsTensor(bb: flatbuffers.ByteBuffer, obj?: Tensor): Tensor {\n    return (obj || new Tensor()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  static getSizePrefixedRootAsTensor(bb: flatbuffers.ByteBuffer, obj?: Tensor): Tensor {\n    bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);\n    return (obj || new Tensor()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  name(): string | null;\n  name(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;\n  name(optionalEncoding?: any): string | Uint8Array | null {\n    const offset = this.bb!.__offset(this.bb_pos, 4);\n    return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;\n  }\n\n  docString(): string | null;\n  docString(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;\n  docString(optionalEncoding?: any): string | Uint8Array | null {\n    const offset = this.bb!.__offset(this.bb_pos, 6);\n    return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;\n  }\n\n  dims(index: number): bigint | null {\n    const offset = this.bb!.__offset(this.bb_pos, 8);\n    return offset ? this.bb!.readInt64(this.bb!.__vector(this.bb_pos + offset) + index * 8) : BigInt(0);\n  }\n\n  dimsLength(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 8);\n    return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n  }\n\n  dataType(): TensorDataType {\n    const offset = this.bb!.__offset(this.bb_pos, 10);\n    return offset ? this.bb!.readInt32(this.bb_pos + offset) : TensorDataType.UNDEFINED;\n  }\n\n  rawData(index: number): number | null {\n    const offset = this.bb!.__offset(this.bb_pos, 12);\n    return offset ? this.bb!.readUint8(this.bb!.__vector(this.bb_pos + offset) + index) : 0;\n  }\n\n  rawDataLength(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 12);\n    return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n  }\n\n  rawDataArray(): Uint8Array | null {\n    const offset = this.bb!.__offset(this.bb_pos, 12);\n    return offset\n      ? new Uint8Array(\n          this.bb!.bytes().buffer,\n          this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset),\n          this.bb!.__vector_len(this.bb_pos + offset),\n        )\n      : null;\n  }\n\n  stringData(index: number): string;\n  stringData(index: number, optionalEncoding: flatbuffers.Encoding): string | Uint8Array;\n  stringData(index: number, optionalEncoding?: any): string | Uint8Array | null {\n    const offset = this.bb!.__offset(this.bb_pos, 14);\n    return offset ? this.bb!.__string(this.bb!.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;\n  }\n\n  stringDataLength(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 14);\n    return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n  }\n\n  externalDataOffset(): bigint {\n    const offset = this.bb!.__offset(this.bb_pos, 16);\n    return offset ? this.bb!.readInt64(this.bb_pos + offset) : BigInt('-1');\n  }\n\n  static startTensor(builder: flatbuffers.Builder) {\n    builder.startObject(7);\n  }\n\n  static addName(builder: flatbuffers.Builder, nameOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(0, nameOffset, 0);\n  }\n\n  static addDocString(builder: flatbuffers.Builder, docStringOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(1, docStringOffset, 0);\n  }\n\n  static addDims(builder: flatbuffers.Builder, dimsOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(2, dimsOffset, 0);\n  }\n\n  static createDimsVector(builder: flatbuffers.Builder, data: bigint[]): flatbuffers.Offset {\n    builder.startVector(8, data.length, 8);\n    for (let i = data.length - 1; i >= 0; i--) {\n      builder.addInt64(data[i]!);\n    }\n    return builder.endVector();\n  }\n\n  static startDimsVector(builder: flatbuffers.Builder, numElems: number) {\n    builder.startVector(8, numElems, 8);\n  }\n\n  static addDataType(builder: flatbuffers.Builder, dataType: TensorDataType) {\n    builder.addFieldInt32(3, dataType, TensorDataType.UNDEFINED);\n  }\n\n  static addRawData(builder: flatbuffers.Builder, rawDataOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(4, rawDataOffset, 0);\n  }\n\n  static createRawDataVector(builder: flatbuffers.Builder, data: number[] | Uint8Array): flatbuffers.Offset {\n    builder.startVector(1, data.length, 1);\n    for (let i = data.length - 1; i >= 0; i--) {\n      builder.addInt8(data[i]!);\n    }\n    return builder.endVector();\n  }\n\n  static startRawDataVector(builder: flatbuffers.Builder, numElems: number) {\n    builder.startVector(1, numElems, 1);\n  }\n\n  static addStringData(builder: flatbuffers.Builder, stringDataOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(5, stringDataOffset, 0);\n  }\n\n  static createStringDataVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset {\n    builder.startVector(4, data.length, 4);\n    for (let i = data.length - 1; i >= 0; i--) {\n      builder.addOffset(data[i]!);\n    }\n    return builder.endVector();\n  }\n\n  static startStringDataVector(builder: flatbuffers.Builder, numElems: number) {\n    builder.startVector(4, numElems, 4);\n  }\n\n  static addExternalDataOffset(builder: flatbuffers.Builder, externalDataOffset: bigint) {\n    builder.addFieldInt64(6, externalDataOffset, BigInt('-1'));\n  }\n\n  static endTensor(builder: flatbuffers.Builder): flatbuffers.Offset {\n    const offset = builder.endObject();\n    return offset;\n  }\n\n  static createTensor(\n    builder: flatbuffers.Builder,\n    nameOffset: flatbuffers.Offset,\n    docStringOffset: flatbuffers.Offset,\n    dimsOffset: flatbuffers.Offset,\n    dataType: TensorDataType,\n    rawDataOffset: flatbuffers.Offset,\n    stringDataOffset: flatbuffers.Offset,\n    externalDataOffset: bigint,\n  ): flatbuffers.Offset {\n    Tensor.startTensor(builder);\n    Tensor.addName(builder, nameOffset);\n    Tensor.addDocString(builder, docStringOffset);\n    Tensor.addDims(builder, dimsOffset);\n    Tensor.addDataType(builder, dataType);\n    Tensor.addRawData(builder, rawDataOffset);\n    Tensor.addStringData(builder, stringDataOffset);\n    Tensor.addExternalDataOffset(builder, externalDataOffset);\n    return Tensor.endTensor(builder);\n  }\n}\n", "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nimport * as flatbuffers from 'flatbuffers';\n\nimport { Tensor } from '../../onnxruntime/fbs/tensor.js';\n\nexport class SparseTensor {\n  bb: flatbuffers.ByteBuffer | null = null;\n  bb_pos = 0;\n  __init(i: number, bb: flatbuffers.ByteBuffer): SparseTensor {\n    this.bb_pos = i;\n    this.bb = bb;\n    return this;\n  }\n\n  static getRootAsSparseTensor(bb: flatbuffers.ByteBuffer, obj?: SparseTensor): SparseTensor {\n    return (obj || new SparseTensor()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  static getSizePrefixedRootAsSparseTensor(bb: flatbuffers.ByteBuffer, obj?: SparseTensor): SparseTensor {\n    bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);\n    return (obj || new SparseTensor()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  values(obj?: Tensor): Tensor | null {\n    const offset = this.bb!.__offset(this.bb_pos, 4);\n    return offset ? (obj || new Tensor()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null;\n  }\n\n  indices(obj?: Tensor): Tensor | null {\n    const offset = this.bb!.__offset(this.bb_pos, 6);\n    return offset ? (obj || new Tensor()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null;\n  }\n\n  dims(index: number): bigint | null {\n    const offset = this.bb!.__offset(this.bb_pos, 8);\n    return offset ? this.bb!.readInt64(this.bb!.__vector(this.bb_pos + offset) + index * 8) : BigInt(0);\n  }\n\n  dimsLength(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 8);\n    return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n  }\n\n  static startSparseTensor(builder: flatbuffers.Builder) {\n    builder.startObject(3);\n  }\n\n  static addValues(builder: flatbuffers.Builder, valuesOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(0, valuesOffset, 0);\n  }\n\n  static addIndices(builder: flatbuffers.Builder, indicesOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(1, indicesOffset, 0);\n  }\n\n  static addDims(builder: flatbuffers.Builder, dimsOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(2, dimsOffset, 0);\n  }\n\n  static createDimsVector(builder: flatbuffers.Builder, data: bigint[]): flatbuffers.Offset {\n    builder.startVector(8, data.length, 8);\n    for (let i = data.length - 1; i >= 0; i--) {\n      builder.addInt64(data[i]!);\n    }\n    return builder.endVector();\n  }\n\n  static startDimsVector(builder: flatbuffers.Builder, numElems: number) {\n    builder.startVector(8, numElems, 8);\n  }\n\n  static endSparseTensor(builder: flatbuffers.Builder): flatbuffers.Offset {\n    const offset = builder.endObject();\n    return offset;\n  }\n}\n", "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nimport * as flatbuffers from 'flatbuffers';\n\nimport { TensorDataType } from '../../onnxruntime/fbs/tensor-data-type.js';\nimport { TypeInfo } from '../../onnxruntime/fbs/type-info.js';\n\nexport class MapType {\n  bb: flatbuffers.ByteBuffer | null = null;\n  bb_pos = 0;\n  __init(i: number, bb: flatbuffers.ByteBuffer): MapType {\n    this.bb_pos = i;\n    this.bb = bb;\n    return this;\n  }\n\n  static getRootAsMapType(bb: flatbuffers.ByteBuffer, obj?: MapType): MapType {\n    return (obj || new MapType()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  static getSizePrefixedRootAsMapType(bb: flatbuffers.ByteBuffer, obj?: MapType): MapType {\n    bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);\n    return (obj || new MapType()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  keyType(): TensorDataType {\n    const offset = this.bb!.__offset(this.bb_pos, 4);\n    return offset ? this.bb!.readInt32(this.bb_pos + offset) : TensorDataType.UNDEFINED;\n  }\n\n  valueType(obj?: TypeInfo): TypeInfo | null {\n    const offset = this.bb!.__offset(this.bb_pos, 6);\n    return offset ? (obj || new TypeInfo()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null;\n  }\n\n  static startMapType(builder: flatbuffers.Builder) {\n    builder.startObject(2);\n  }\n\n  static addKeyType(builder: flatbuffers.Builder, keyType: TensorDataType) {\n    builder.addFieldInt32(0, keyType, TensorDataType.UNDEFINED);\n  }\n\n  static addValueType(builder: flatbuffers.Builder, valueTypeOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(1, valueTypeOffset, 0);\n  }\n\n  static endMapType(builder: flatbuffers.Builder): flatbuffers.Offset {\n    const offset = builder.endObject();\n    return offset;\n  }\n}\n", "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nimport * as flatbuffers from 'flatbuffers';\n\nimport { TypeInfo } from '../../onnxruntime/fbs/type-info.js';\n\nexport class SequenceType {\n  bb: flatbuffers.ByteBuffer | null = null;\n  bb_pos = 0;\n  __init(i: number, bb: flatbuffers.ByteBuffer): SequenceType {\n    this.bb_pos = i;\n    this.bb = bb;\n    return this;\n  }\n\n  static getRootAsSequenceType(bb: flatbuffers.ByteBuffer, obj?: SequenceType): SequenceType {\n    return (obj || new SequenceType()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  static getSizePrefixedRootAsSequenceType(bb: flatbuffers.ByteBuffer, obj?: SequenceType): SequenceType {\n    bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);\n    return (obj || new SequenceType()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  elemType(obj?: TypeInfo): TypeInfo | null {\n    const offset = this.bb!.__offset(this.bb_pos, 4);\n    return offset ? (obj || new TypeInfo()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null;\n  }\n\n  static startSequenceType(builder: flatbuffers.Builder) {\n    builder.startObject(1);\n  }\n\n  static addElemType(builder: flatbuffers.Builder, elemTypeOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(0, elemTypeOffset, 0);\n  }\n\n  static endSequenceType(builder: flatbuffers.Builder): flatbuffers.Offset {\n    const offset = builder.endObject();\n    return offset;\n  }\n\n  static createSequenceType(builder: flatbuffers.Builder, elemTypeOffset: flatbuffers.Offset): flatbuffers.Offset {\n    SequenceType.startSequenceType(builder);\n    SequenceType.addElemType(builder, elemTypeOffset);\n    return SequenceType.endSequenceType(builder);\n  }\n}\n", "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nexport enum DimensionValueType {\n  UNKNOWN = 0,\n  VALUE = 1,\n  PARAM = 2,\n}\n", "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nimport * as flatbuffers from 'flatbuffers';\n\nimport { DimensionValueType } from '../../onnxruntime/fbs/dimension-value-type.js';\n\nexport class DimensionValue {\n  bb: flatbuffers.ByteBuffer | null = null;\n  bb_pos = 0;\n  __init(i: number, bb: flatbuffers.ByteBuffer): DimensionValue {\n    this.bb_pos = i;\n    this.bb = bb;\n    return this;\n  }\n\n  static getRootAsDimensionValue(bb: flatbuffers.ByteBuffer, obj?: DimensionValue): DimensionValue {\n    return (obj || new DimensionValue()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  static getSizePrefixedRootAsDimensionValue(bb: flatbuffers.ByteBuffer, obj?: DimensionValue): DimensionValue {\n    bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);\n    return (obj || new DimensionValue()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  dimType(): DimensionValueType {\n    const offset = this.bb!.__offset(this.bb_pos, 4);\n    return offset ? this.bb!.readInt8(this.bb_pos + offset) : DimensionValueType.UNKNOWN;\n  }\n\n  dimValue(): bigint {\n    const offset = this.bb!.__offset(this.bb_pos, 6);\n    return offset ? this.bb!.readInt64(this.bb_pos + offset) : BigInt('0');\n  }\n\n  dimParam(): string | null;\n  dimParam(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;\n  dimParam(optionalEncoding?: any): string | Uint8Array | null {\n    const offset = this.bb!.__offset(this.bb_pos, 8);\n    return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;\n  }\n\n  static startDimensionValue(builder: flatbuffers.Builder) {\n    builder.startObject(3);\n  }\n\n  static addDimType(builder: flatbuffers.Builder, dimType: DimensionValueType) {\n    builder.addFieldInt8(0, dimType, DimensionValueType.UNKNOWN);\n  }\n\n  static addDimValue(builder: flatbuffers.Builder, dimValue: bigint) {\n    builder.addFieldInt64(1, dimValue, BigInt('0'));\n  }\n\n  static addDimParam(builder: flatbuffers.Builder, dimParamOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(2, dimParamOffset, 0);\n  }\n\n  static endDimensionValue(builder: flatbuffers.Builder): flatbuffers.Offset {\n    const offset = builder.endObject();\n    return offset;\n  }\n\n  static createDimensionValue(\n    builder: flatbuffers.Builder,\n    dimType: DimensionValueType,\n    dimValue: bigint,\n    dimParamOffset: flatbuffers.Offset,\n  ): flatbuffers.Offset {\n    DimensionValue.startDimensionValue(builder);\n    DimensionValue.addDimType(builder, dimType);\n    DimensionValue.addDimValue(builder, dimValue);\n    DimensionValue.addDimParam(builder, dimParamOffset);\n    return DimensionValue.endDimensionValue(builder);\n  }\n}\n", "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nimport * as flatbuffers from 'flatbuffers';\n\nimport { DimensionValue } from '../../onnxruntime/fbs/dimension-value.js';\n\nexport class Dimension {\n  bb: flatbuffers.ByteBuffer | null = null;\n  bb_pos = 0;\n  __init(i: number, bb: flatbuffers.ByteBuffer): Dimension {\n    this.bb_pos = i;\n    this.bb = bb;\n    return this;\n  }\n\n  static getRootAsDimension(bb: flatbuffers.ByteBuffer, obj?: Dimension): Dimension {\n    return (obj || new Dimension()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  static getSizePrefixedRootAsDimension(bb: flatbuffers.ByteBuffer, obj?: Dimension): Dimension {\n    bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);\n    return (obj || new Dimension()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  value(obj?: DimensionValue): DimensionValue | null {\n    const offset = this.bb!.__offset(this.bb_pos, 4);\n    return offset ? (obj || new DimensionValue()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null;\n  }\n\n  denotation(): string | null;\n  denotation(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;\n  denotation(optionalEncoding?: any): string | Uint8Array | null {\n    const offset = this.bb!.__offset(this.bb_pos, 6);\n    return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;\n  }\n\n  static startDimension(builder: flatbuffers.Builder) {\n    builder.startObject(2);\n  }\n\n  static addValue(builder: flatbuffers.Builder, valueOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(0, valueOffset, 0);\n  }\n\n  static addDenotation(builder: flatbuffers.Builder, denotationOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(1, denotationOffset, 0);\n  }\n\n  static endDimension(builder: flatbuffers.Builder): flatbuffers.Offset {\n    const offset = builder.endObject();\n    return offset;\n  }\n\n  static createDimension(\n    builder: flatbuffers.Builder,\n    valueOffset: flatbuffers.Offset,\n    denotationOffset: flatbuffers.Offset,\n  ): flatbuffers.Offset {\n    Dimension.startDimension(builder);\n    Dimension.addValue(builder, valueOffset);\n    Dimension.addDenotation(builder, denotationOffset);\n    return Dimension.endDimension(builder);\n  }\n}\n", "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nimport * as flatbuffers from 'flatbuffers';\n\nimport { Dimension } from '../../onnxruntime/fbs/dimension.js';\n\nexport class Shape {\n  bb: flatbuffers.ByteBuffer | null = null;\n  bb_pos = 0;\n  __init(i: number, bb: flatbuffers.ByteBuffer): Shape {\n    this.bb_pos = i;\n    this.bb = bb;\n    return this;\n  }\n\n  static getRootAsShape(bb: flatbuffers.ByteBuffer, obj?: Shape): Shape {\n    return (obj || new Shape()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  static getSizePrefixedRootAsShape(bb: flatbuffers.ByteBuffer, obj?: Shape): Shape {\n    bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);\n    return (obj || new Shape()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  dim(index: number, obj?: Dimension): Dimension | null {\n    const offset = this.bb!.__offset(this.bb_pos, 4);\n    return offset\n      ? (obj || new Dimension()).__init(\n          this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4),\n          this.bb!,\n        )\n      : null;\n  }\n\n  dimLength(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 4);\n    return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n  }\n\n  static startShape(builder: flatbuffers.Builder) {\n    builder.startObject(1);\n  }\n\n  static addDim(builder: flatbuffers.Builder, dimOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(0, dimOffset, 0);\n  }\n\n  static createDimVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset {\n    builder.startVector(4, data.length, 4);\n    for (let i = data.length - 1; i >= 0; i--) {\n      builder.addOffset(data[i]!);\n    }\n    return builder.endVector();\n  }\n\n  static startDimVector(builder: flatbuffers.Builder, numElems: number) {\n    builder.startVector(4, numElems, 4);\n  }\n\n  static endShape(builder: flatbuffers.Builder): flatbuffers.Offset {\n    const offset = builder.endObject();\n    return offset;\n  }\n\n  static createShape(builder: flatbuffers.Builder, dimOffset: flatbuffers.Offset): flatbuffers.Offset {\n    Shape.startShape(builder);\n    Shape.addDim(builder, dimOffset);\n    return Shape.endShape(builder);\n  }\n}\n", "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nimport * as flatbuffers from 'flatbuffers';\n\nimport { Shape } from '../../onnxruntime/fbs/shape.js';\nimport { TensorDataType } from '../../onnxruntime/fbs/tensor-data-type.js';\n\nexport class TensorTypeAndShape {\n  bb: flatbuffers.ByteBuffer | null = null;\n  bb_pos = 0;\n  __init(i: number, bb: flatbuffers.ByteBuffer): TensorTypeAndShape {\n    this.bb_pos = i;\n    this.bb = bb;\n    return this;\n  }\n\n  static getRootAsTensorTypeAndShape(bb: flatbuffers.ByteBuffer, obj?: TensorTypeAndShape): TensorTypeAndShape {\n    return (obj || new TensorTypeAndShape()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  static getSizePrefixedRootAsTensorTypeAndShape(\n    bb: flatbuffers.ByteBuffer,\n    obj?: TensorTypeAndShape,\n  ): TensorTypeAndShape {\n    bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);\n    return (obj || new TensorTypeAndShape()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  elemType(): TensorDataType {\n    const offset = this.bb!.__offset(this.bb_pos, 4);\n    return offset ? this.bb!.readInt32(this.bb_pos + offset) : TensorDataType.UNDEFINED;\n  }\n\n  shape(obj?: Shape): Shape | null {\n    const offset = this.bb!.__offset(this.bb_pos, 6);\n    return offset ? (obj || new Shape()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null;\n  }\n\n  static startTensorTypeAndShape(builder: flatbuffers.Builder) {\n    builder.startObject(2);\n  }\n\n  static addElemType(builder: flatbuffers.Builder, elemType: TensorDataType) {\n    builder.addFieldInt32(0, elemType, TensorDataType.UNDEFINED);\n  }\n\n  static addShape(builder: flatbuffers.Builder, shapeOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(1, shapeOffset, 0);\n  }\n\n  static endTensorTypeAndShape(builder: flatbuffers.Builder): flatbuffers.Offset {\n    const offset = builder.endObject();\n    return offset;\n  }\n}\n", "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nimport { MapType } from '../../onnxruntime/fbs/map-type.js';\nimport { SequenceType } from '../../onnxruntime/fbs/sequence-type.js';\nimport { TensorTypeAndShape } from '../../onnxruntime/fbs/tensor-type-and-shape.js';\n\nexport enum TypeInfoValue {\n  NONE = 0,\n  tensor_type = 1,\n  sequence_type = 2,\n  map_type = 3,\n}\n\nexport function unionToTypeInfoValue(\n  type: TypeInfoValue,\n  accessor: (obj: MapType | SequenceType | TensorTypeAndShape) => MapType | SequenceType | TensorTypeAndShape | null,\n): MapType | SequenceType | TensorTypeAndShape | null {\n  switch (TypeInfoValue[type]) {\n    case 'NONE':\n      return null;\n    case 'tensor_type':\n      return accessor(new TensorTypeAndShape())! as TensorTypeAndShape;\n    case 'sequence_type':\n      return accessor(new SequenceType())! as SequenceType;\n    case 'map_type':\n      return accessor(new MapType())! as MapType;\n    default:\n      return null;\n  }\n}\n\nexport function unionListToTypeInfoValue(\n  type: TypeInfoValue,\n  accessor: (\n    index: number,\n    obj: MapType | SequenceType | TensorTypeAndShape,\n  ) => MapType | SequenceType | TensorTypeAndShape | null,\n  index: number,\n): MapType | SequenceType | TensorTypeAndShape | null {\n  switch (TypeInfoValue[type]) {\n    case 'NONE':\n      return null;\n    case 'tensor_type':\n      return accessor(index, new TensorTypeAndShape())! as TensorTypeAndShape;\n    case 'sequence_type':\n      return accessor(index, new SequenceType())! as SequenceType;\n    case 'map_type':\n      return accessor(index, new MapType())! as MapType;\n    default:\n      return null;\n  }\n}\n", "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nimport * as flatbuffers from 'flatbuffers';\n\nimport { TypeInfoValue } from '../../onnxruntime/fbs/type-info-value.js';\n\nexport class TypeInfo {\n  bb: flatbuffers.ByteBuffer | null = null;\n  bb_pos = 0;\n  __init(i: number, bb: flatbuffers.ByteBuffer): TypeInfo {\n    this.bb_pos = i;\n    this.bb = bb;\n    return this;\n  }\n\n  static getRootAsTypeInfo(bb: flatbuffers.ByteBuffer, obj?: TypeInfo): TypeInfo {\n    return (obj || new TypeInfo()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  static getSizePrefixedRootAsTypeInfo(bb: flatbuffers.ByteBuffer, obj?: TypeInfo): TypeInfo {\n    bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);\n    return (obj || new TypeInfo()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  denotation(): string | null;\n  denotation(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;\n  denotation(optionalEncoding?: any): string | Uint8Array | null {\n    const offset = this.bb!.__offset(this.bb_pos, 4);\n    return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;\n  }\n\n  valueType(): TypeInfoValue {\n    const offset = this.bb!.__offset(this.bb_pos, 6);\n    return offset ? this.bb!.readUint8(this.bb_pos + offset) : TypeInfoValue.NONE;\n  }\n\n  value(obj: any): any | null {\n    const offset = this.bb!.__offset(this.bb_pos, 8);\n    return offset ? this.bb!.__union(obj, this.bb_pos + offset) : null;\n  }\n\n  static startTypeInfo(builder: flatbuffers.Builder) {\n    builder.startObject(3);\n  }\n\n  static addDenotation(builder: flatbuffers.Builder, denotationOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(0, denotationOffset, 0);\n  }\n\n  static addValueType(builder: flatbuffers.Builder, valueType: TypeInfoValue) {\n    builder.addFieldInt8(1, valueType, TypeInfoValue.NONE);\n  }\n\n  static addValue(builder: flatbuffers.Builder, valueOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(2, valueOffset, 0);\n  }\n\n  static endTypeInfo(builder: flatbuffers.Builder): flatbuffers.Offset {\n    const offset = builder.endObject();\n    return offset;\n  }\n\n  static createTypeInfo(\n    builder: flatbuffers.Builder,\n    denotationOffset: flatbuffers.Offset,\n    valueType: TypeInfoValue,\n    valueOffset: flatbuffers.Offset,\n  ): flatbuffers.Offset {\n    TypeInfo.startTypeInfo(builder);\n    TypeInfo.addDenotation(builder, denotationOffset);\n    TypeInfo.addValueType(builder, valueType);\n    TypeInfo.addValue(builder, valueOffset);\n    return TypeInfo.endTypeInfo(builder);\n  }\n}\n", "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nimport * as flatbuffers from 'flatbuffers';\n\nimport { TypeInfo } from '../../onnxruntime/fbs/type-info.js';\n\nexport class ValueInfo {\n  bb: flatbuffers.ByteBuffer | null = null;\n  bb_pos = 0;\n  __init(i: number, bb: flatbuffers.ByteBuffer): ValueInfo {\n    this.bb_pos = i;\n    this.bb = bb;\n    return this;\n  }\n\n  static getRootAsValueInfo(bb: flatbuffers.ByteBuffer, obj?: ValueInfo): ValueInfo {\n    return (obj || new ValueInfo()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  static getSizePrefixedRootAsValueInfo(bb: flatbuffers.ByteBuffer, obj?: ValueInfo): ValueInfo {\n    bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);\n    return (obj || new ValueInfo()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  name(): string | null;\n  name(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;\n  name(optionalEncoding?: any): string | Uint8Array | null {\n    const offset = this.bb!.__offset(this.bb_pos, 4);\n    return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;\n  }\n\n  docString(): string | null;\n  docString(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;\n  docString(optionalEncoding?: any): string | Uint8Array | null {\n    const offset = this.bb!.__offset(this.bb_pos, 6);\n    return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;\n  }\n\n  type(obj?: TypeInfo): TypeInfo | null {\n    const offset = this.bb!.__offset(this.bb_pos, 8);\n    return offset ? (obj || new TypeInfo()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null;\n  }\n\n  static startValueInfo(builder: flatbuffers.Builder) {\n    builder.startObject(3);\n  }\n\n  static addName(builder: flatbuffers.Builder, nameOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(0, nameOffset, 0);\n  }\n\n  static addDocString(builder: flatbuffers.Builder, docStringOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(1, docStringOffset, 0);\n  }\n\n  static addType(builder: flatbuffers.Builder, typeOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(2, typeOffset, 0);\n  }\n\n  static endValueInfo(builder: flatbuffers.Builder): flatbuffers.Offset {\n    const offset = builder.endObject();\n    return offset;\n  }\n}\n", "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nimport * as flatbuffers from 'flatbuffers';\n\nimport { Node } from '../../onnxruntime/fbs/node.js';\nimport { NodeEdge } from '../../onnxruntime/fbs/node-edge.js';\nimport { RuntimeOptimizations } from '../../onnxruntime/fbs/runtime-optimizations.js';\nimport { SparseTensor } from '../../onnxruntime/fbs/sparse-tensor.js';\nimport { Tensor } from '../../onnxruntime/fbs/tensor.js';\nimport { ValueInfo } from '../../onnxruntime/fbs/value-info.js';\n\nexport class Graph {\n  bb: flatbuffers.ByteBuffer | null = null;\n  bb_pos = 0;\n  __init(i: number, bb: flatbuffers.ByteBuffer): Graph {\n    this.bb_pos = i;\n    this.bb = bb;\n    return this;\n  }\n\n  static getRootAsGraph(bb: flatbuffers.ByteBuffer, obj?: Graph): Graph {\n    return (obj || new Graph()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  static getSizePrefixedRootAsGraph(bb: flatbuffers.ByteBuffer, obj?: Graph): Graph {\n    bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);\n    return (obj || new Graph()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  initializers(index: number, obj?: Tensor): Tensor | null {\n    const offset = this.bb!.__offset(this.bb_pos, 4);\n    return offset\n      ? (obj || new Tensor()).__init(this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4), this.bb!)\n      : null;\n  }\n\n  initializersLength(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 4);\n    return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n  }\n\n  nodeArgs(index: number, obj?: ValueInfo): ValueInfo | null {\n    const offset = this.bb!.__offset(this.bb_pos, 6);\n    return offset\n      ? (obj || new ValueInfo()).__init(\n          this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4),\n          this.bb!,\n        )\n      : null;\n  }\n\n  nodeArgsLength(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 6);\n    return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n  }\n\n  nodes(index: number, obj?: Node): Node | null {\n    const offset = this.bb!.__offset(this.bb_pos, 8);\n    return offset\n      ? (obj || new Node()).__init(this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4), this.bb!)\n      : null;\n  }\n\n  nodesLength(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 8);\n    return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n  }\n\n  maxNodeIndex(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 10);\n    return offset ? this.bb!.readUint32(this.bb_pos + offset) : 0;\n  }\n\n  nodeEdges(index: number, obj?: NodeEdge): NodeEdge | null {\n    const offset = this.bb!.__offset(this.bb_pos, 12);\n    return offset\n      ? (obj || new NodeEdge()).__init(\n          this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4),\n          this.bb!,\n        )\n      : null;\n  }\n\n  nodeEdgesLength(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 12);\n    return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n  }\n\n  inputs(index: number): string;\n  inputs(index: number, optionalEncoding: flatbuffers.Encoding): string | Uint8Array;\n  inputs(index: number, optionalEncoding?: any): string | Uint8Array | null {\n    const offset = this.bb!.__offset(this.bb_pos, 14);\n    return offset ? this.bb!.__string(this.bb!.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;\n  }\n\n  inputsLength(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 14);\n    return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n  }\n\n  outputs(index: number): string;\n  outputs(index: number, optionalEncoding: flatbuffers.Encoding): string | Uint8Array;\n  outputs(index: number, optionalEncoding?: any): string | Uint8Array | null {\n    const offset = this.bb!.__offset(this.bb_pos, 16);\n    return offset ? this.bb!.__string(this.bb!.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;\n  }\n\n  outputsLength(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 16);\n    return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n  }\n\n  sparseInitializers(index: number, obj?: SparseTensor): SparseTensor | null {\n    const offset = this.bb!.__offset(this.bb_pos, 18);\n    return offset\n      ? (obj || new SparseTensor()).__init(\n          this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4),\n          this.bb!,\n        )\n      : null;\n  }\n\n  sparseInitializersLength(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 18);\n    return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n  }\n\n  runtimeOptimizations(obj?: RuntimeOptimizations): RuntimeOptimizations | null {\n    const offset = this.bb!.__offset(this.bb_pos, 20);\n    return offset\n      ? (obj || new RuntimeOptimizations()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!)\n      : null;\n  }\n\n  static startGraph(builder: flatbuffers.Builder) {\n    builder.startObject(9);\n  }\n\n  static addInitializers(builder: flatbuffers.Builder, initializersOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(0, initializersOffset, 0);\n  }\n\n  static createInitializersVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset {\n    builder.startVector(4, data.length, 4);\n    for (let i = data.length - 1; i >= 0; i--) {\n      builder.addOffset(data[i]!);\n    }\n    return builder.endVector();\n  }\n\n  static startInitializersVector(builder: flatbuffers.Builder, numElems: number) {\n    builder.startVector(4, numElems, 4);\n  }\n\n  static addNodeArgs(builder: flatbuffers.Builder, nodeArgsOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(1, nodeArgsOffset, 0);\n  }\n\n  static createNodeArgsVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset {\n    builder.startVector(4, data.length, 4);\n    for (let i = data.length - 1; i >= 0; i--) {\n      builder.addOffset(data[i]!);\n    }\n    return builder.endVector();\n  }\n\n  static startNodeArgsVector(builder: flatbuffers.Builder, numElems: number) {\n    builder.startVector(4, numElems, 4);\n  }\n\n  static addNodes(builder: flatbuffers.Builder, nodesOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(2, nodesOffset, 0);\n  }\n\n  static createNodesVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset {\n    builder.startVector(4, data.length, 4);\n    for (let i = data.length - 1; i >= 0; i--) {\n      builder.addOffset(data[i]!);\n    }\n    return builder.endVector();\n  }\n\n  static startNodesVector(builder: flatbuffers.Builder, numElems: number) {\n    builder.startVector(4, numElems, 4);\n  }\n\n  static addMaxNodeIndex(builder: flatbuffers.Builder, maxNodeIndex: number) {\n    builder.addFieldInt32(3, maxNodeIndex, 0);\n  }\n\n  static addNodeEdges(builder: flatbuffers.Builder, nodeEdgesOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(4, nodeEdgesOffset, 0);\n  }\n\n  static createNodeEdgesVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset {\n    builder.startVector(4, data.length, 4);\n    for (let i = data.length - 1; i >= 0; i--) {\n      builder.addOffset(data[i]!);\n    }\n    return builder.endVector();\n  }\n\n  static startNodeEdgesVector(builder: flatbuffers.Builder, numElems: number) {\n    builder.startVector(4, numElems, 4);\n  }\n\n  static addInputs(builder: flatbuffers.Builder, inputsOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(5, inputsOffset, 0);\n  }\n\n  static createInputsVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset {\n    builder.startVector(4, data.length, 4);\n    for (let i = data.length - 1; i >= 0; i--) {\n      builder.addOffset(data[i]!);\n    }\n    return builder.endVector();\n  }\n\n  static startInputsVector(builder: flatbuffers.Builder, numElems: number) {\n    builder.startVector(4, numElems, 4);\n  }\n\n  static addOutputs(builder: flatbuffers.Builder, outputsOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(6, outputsOffset, 0);\n  }\n\n  static createOutputsVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset {\n    builder.startVector(4, data.length, 4);\n    for (let i = data.length - 1; i >= 0; i--) {\n      builder.addOffset(data[i]!);\n    }\n    return builder.endVector();\n  }\n\n  static startOutputsVector(builder: flatbuffers.Builder, numElems: number) {\n    builder.startVector(4, numElems, 4);\n  }\n\n  static addSparseInitializers(builder: flatbuffers.Builder, sparseInitializersOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(7, sparseInitializersOffset, 0);\n  }\n\n  static createSparseInitializersVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset {\n    builder.startVector(4, data.length, 4);\n    for (let i = data.length - 1; i >= 0; i--) {\n      builder.addOffset(data[i]!);\n    }\n    return builder.endVector();\n  }\n\n  static startSparseInitializersVector(builder: flatbuffers.Builder, numElems: number) {\n    builder.startVector(4, numElems, 4);\n  }\n\n  static addRuntimeOptimizations(builder: flatbuffers.Builder, runtimeOptimizationsOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(8, runtimeOptimizationsOffset, 0);\n  }\n\n  static endGraph(builder: flatbuffers.Builder): flatbuffers.Offset {\n    const offset = builder.endObject();\n    return offset;\n  }\n}\n", "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nimport * as flatbuffers from 'flatbuffers';\n\nimport { AttributeType } from '../../onnxruntime/fbs/attribute-type.js';\nimport { Graph } from '../../onnxruntime/fbs/graph.js';\nimport { Tensor } from '../../onnxruntime/fbs/tensor.js';\n\nexport class Attribute {\n  bb: flatbuffers.ByteBuffer | null = null;\n  bb_pos = 0;\n  __init(i: number, bb: flatbuffers.ByteBuffer): Attribute {\n    this.bb_pos = i;\n    this.bb = bb;\n    return this;\n  }\n\n  static getRootAsAttribute(bb: flatbuffers.ByteBuffer, obj?: Attribute): Attribute {\n    return (obj || new Attribute()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  static getSizePrefixedRootAsAttribute(bb: flatbuffers.ByteBuffer, obj?: Attribute): Attribute {\n    bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);\n    return (obj || new Attribute()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  name(): string | null;\n  name(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;\n  name(optionalEncoding?: any): string | Uint8Array | null {\n    const offset = this.bb!.__offset(this.bb_pos, 4);\n    return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;\n  }\n\n  docString(): string | null;\n  docString(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;\n  docString(optionalEncoding?: any): string | Uint8Array | null {\n    const offset = this.bb!.__offset(this.bb_pos, 6);\n    return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;\n  }\n\n  type(): AttributeType {\n    const offset = this.bb!.__offset(this.bb_pos, 8);\n    return offset ? this.bb!.readInt32(this.bb_pos + offset) : AttributeType.UNDEFINED;\n  }\n\n  f(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 10);\n    return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0;\n  }\n\n  i(): bigint {\n    const offset = this.bb!.__offset(this.bb_pos, 12);\n    return offset ? this.bb!.readInt64(this.bb_pos + offset) : BigInt('0');\n  }\n\n  s(): string | null;\n  s(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;\n  s(optionalEncoding?: any): string | Uint8Array | null {\n    const offset = this.bb!.__offset(this.bb_pos, 14);\n    return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;\n  }\n\n  t(obj?: Tensor): Tensor | null {\n    const offset = this.bb!.__offset(this.bb_pos, 16);\n    return offset ? (obj || new Tensor()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null;\n  }\n\n  g(obj?: Graph): Graph | null {\n    const offset = this.bb!.__offset(this.bb_pos, 18);\n    return offset ? (obj || new Graph()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null;\n  }\n\n  floats(index: number): number | null {\n    const offset = this.bb!.__offset(this.bb_pos, 20);\n    return offset ? this.bb!.readFloat32(this.bb!.__vector(this.bb_pos + offset) + index * 4) : 0;\n  }\n\n  floatsLength(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 20);\n    return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n  }\n\n  floatsArray(): Float32Array | null {\n    const offset = this.bb!.__offset(this.bb_pos, 20);\n    return offset\n      ? new Float32Array(\n          this.bb!.bytes().buffer,\n          this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset),\n          this.bb!.__vector_len(this.bb_pos + offset),\n        )\n      : null;\n  }\n\n  ints(index: number): bigint | null {\n    const offset = this.bb!.__offset(this.bb_pos, 22);\n    return offset ? this.bb!.readInt64(this.bb!.__vector(this.bb_pos + offset) + index * 8) : BigInt(0);\n  }\n\n  intsLength(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 22);\n    return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n  }\n\n  strings(index: number): string;\n  strings(index: number, optionalEncoding: flatbuffers.Encoding): string | Uint8Array;\n  strings(index: number, optionalEncoding?: any): string | Uint8Array | null {\n    const offset = this.bb!.__offset(this.bb_pos, 24);\n    return offset ? this.bb!.__string(this.bb!.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;\n  }\n\n  stringsLength(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 24);\n    return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n  }\n\n  tensors(index: number, obj?: Tensor): Tensor | null {\n    const offset = this.bb!.__offset(this.bb_pos, 26);\n    return offset\n      ? (obj || new Tensor()).__init(this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4), this.bb!)\n      : null;\n  }\n\n  tensorsLength(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 26);\n    return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n  }\n\n  graphs(index: number, obj?: Graph): Graph | null {\n    const offset = this.bb!.__offset(this.bb_pos, 28);\n    return offset\n      ? (obj || new Graph()).__init(this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4), this.bb!)\n      : null;\n  }\n\n  graphsLength(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 28);\n    return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n  }\n\n  static startAttribute(builder: flatbuffers.Builder) {\n    builder.startObject(13);\n  }\n\n  static addName(builder: flatbuffers.Builder, nameOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(0, nameOffset, 0);\n  }\n\n  static addDocString(builder: flatbuffers.Builder, docStringOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(1, docStringOffset, 0);\n  }\n\n  static addType(builder: flatbuffers.Builder, type: AttributeType) {\n    builder.addFieldInt32(2, type, AttributeType.UNDEFINED);\n  }\n\n  static addF(builder: flatbuffers.Builder, f: number) {\n    builder.addFieldFloat32(3, f, 0.0);\n  }\n\n  static addI(builder: flatbuffers.Builder, i: bigint) {\n    builder.addFieldInt64(4, i, BigInt('0'));\n  }\n\n  static addS(builder: flatbuffers.Builder, sOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(5, sOffset, 0);\n  }\n\n  static addT(builder: flatbuffers.Builder, tOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(6, tOffset, 0);\n  }\n\n  static addG(builder: flatbuffers.Builder, gOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(7, gOffset, 0);\n  }\n\n  static addFloats(builder: flatbuffers.Builder, floatsOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(8, floatsOffset, 0);\n  }\n\n  static createFloatsVector(builder: flatbuffers.Builder, data: number[] | Float32Array): flatbuffers.Offset;\n  /**\n   * @deprecated This Uint8Array overload will be removed in the future.\n   */\n  static createFloatsVector(builder: flatbuffers.Builder, data: number[] | Uint8Array): flatbuffers.Offset;\n  static createFloatsVector(\n    builder: flatbuffers.Builder,\n    data: number[] | Float32Array | Uint8Array,\n  ): flatbuffers.Offset {\n    builder.startVector(4, data.length, 4);\n    for (let i = data.length - 1; i >= 0; i--) {\n      builder.addFloat32(data[i]!);\n    }\n    return builder.endVector();\n  }\n\n  static startFloatsVector(builder: flatbuffers.Builder, numElems: number) {\n    builder.startVector(4, numElems, 4);\n  }\n\n  static addInts(builder: flatbuffers.Builder, intsOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(9, intsOffset, 0);\n  }\n\n  static createIntsVector(builder: flatbuffers.Builder, data: bigint[]): flatbuffers.Offset {\n    builder.startVector(8, data.length, 8);\n    for (let i = data.length - 1; i >= 0; i--) {\n      builder.addInt64(data[i]!);\n    }\n    return builder.endVector();\n  }\n\n  static startIntsVector(builder: flatbuffers.Builder, numElems: number) {\n    builder.startVector(8, numElems, 8);\n  }\n\n  static addStrings(builder: flatbuffers.Builder, stringsOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(10, stringsOffset, 0);\n  }\n\n  static createStringsVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset {\n    builder.startVector(4, data.length, 4);\n    for (let i = data.length - 1; i >= 0; i--) {\n      builder.addOffset(data[i]!);\n    }\n    return builder.endVector();\n  }\n\n  static startStringsVector(builder: flatbuffers.Builder, numElems: number) {\n    builder.startVector(4, numElems, 4);\n  }\n\n  static addTensors(builder: flatbuffers.Builder, tensorsOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(11, tensorsOffset, 0);\n  }\n\n  static createTensorsVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset {\n    builder.startVector(4, data.length, 4);\n    for (let i = data.length - 1; i >= 0; i--) {\n      builder.addOffset(data[i]!);\n    }\n    return builder.endVector();\n  }\n\n  static startTensorsVector(builder: flatbuffers.Builder, numElems: number) {\n    builder.startVector(4, numElems, 4);\n  }\n\n  static addGraphs(builder: flatbuffers.Builder, graphsOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(12, graphsOffset, 0);\n  }\n\n  static createGraphsVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset {\n    builder.startVector(4, data.length, 4);\n    for (let i = data.length - 1; i >= 0; i--) {\n      builder.addOffset(data[i]!);\n    }\n    return builder.endVector();\n  }\n\n  static startGraphsVector(builder: flatbuffers.Builder, numElems: number) {\n    builder.startVector(4, numElems, 4);\n  }\n\n  static endAttribute(builder: flatbuffers.Builder): flatbuffers.Offset {\n    const offset = builder.endObject();\n    return offset;\n  }\n}\n", "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nimport * as flatbuffers from 'flatbuffers';\n\n/**\n * deprecated: no longer using kernel def hashes\n */\nexport class DeprecatedKernelCreateInfos {\n  bb: flatbuffers.ByteBuffer | null = null;\n  bb_pos = 0;\n  __init(i: number, bb: flatbuffers.ByteBuffer): DeprecatedKernelCreateInfos {\n    this.bb_pos = i;\n    this.bb = bb;\n    return this;\n  }\n\n  static getRootAsDeprecatedKernelCreateInfos(\n    bb: flatbuffers.ByteBuffer,\n    obj?: DeprecatedKernelCreateInfos,\n  ): DeprecatedKernelCreateInfos {\n    return (obj || new DeprecatedKernelCreateInfos()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  static getSizePrefixedRootAsDeprecatedKernelCreateInfos(\n    bb: flatbuffers.ByteBuffer,\n    obj?: DeprecatedKernelCreateInfos,\n  ): DeprecatedKernelCreateInfos {\n    bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);\n    return (obj || new DeprecatedKernelCreateInfos()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  nodeIndices(index: number): number | null {\n    const offset = this.bb!.__offset(this.bb_pos, 4);\n    return offset ? this.bb!.readUint32(this.bb!.__vector(this.bb_pos + offset) + index * 4) : 0;\n  }\n\n  nodeIndicesLength(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 4);\n    return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n  }\n\n  nodeIndicesArray(): Uint32Array | null {\n    const offset = this.bb!.__offset(this.bb_pos, 4);\n    return offset\n      ? new Uint32Array(\n          this.bb!.bytes().buffer,\n          this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset),\n          this.bb!.__vector_len(this.bb_pos + offset),\n        )\n      : null;\n  }\n\n  kernelDefHashes(index: number): bigint | null {\n    const offset = this.bb!.__offset(this.bb_pos, 6);\n    return offset ? this.bb!.readUint64(this.bb!.__vector(this.bb_pos + offset) + index * 8) : BigInt(0);\n  }\n\n  kernelDefHashesLength(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 6);\n    return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n  }\n\n  static startDeprecatedKernelCreateInfos(builder: flatbuffers.Builder) {\n    builder.startObject(2);\n  }\n\n  static addNodeIndices(builder: flatbuffers.Builder, nodeIndicesOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(0, nodeIndicesOffset, 0);\n  }\n\n  static createNodeIndicesVector(builder: flatbuffers.Builder, data: number[] | Uint32Array): flatbuffers.Offset;\n  /**\n   * @deprecated This Uint8Array overload will be removed in the future.\n   */\n  static createNodeIndicesVector(builder: flatbuffers.Builder, data: number[] | Uint8Array): flatbuffers.Offset;\n  static createNodeIndicesVector(\n    builder: flatbuffers.Builder,\n    data: number[] | Uint32Array | Uint8Array,\n  ): flatbuffers.Offset {\n    builder.startVector(4, data.length, 4);\n    for (let i = data.length - 1; i >= 0; i--) {\n      builder.addInt32(data[i]!);\n    }\n    return builder.endVector();\n  }\n\n  static startNodeIndicesVector(builder: flatbuffers.Builder, numElems: number) {\n    builder.startVector(4, numElems, 4);\n  }\n\n  static addKernelDefHashes(builder: flatbuffers.Builder, kernelDefHashesOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(1, kernelDefHashesOffset, 0);\n  }\n\n  static createKernelDefHashesVector(builder: flatbuffers.Builder, data: bigint[]): flatbuffers.Offset {\n    builder.startVector(8, data.length, 8);\n    for (let i = data.length - 1; i >= 0; i--) {\n      builder.addInt64(data[i]!);\n    }\n    return builder.endVector();\n  }\n\n  static startKernelDefHashesVector(builder: flatbuffers.Builder, numElems: number) {\n    builder.startVector(8, numElems, 8);\n  }\n\n  static endDeprecatedKernelCreateInfos(builder: flatbuffers.Builder): flatbuffers.Offset {\n    const offset = builder.endObject();\n    return offset;\n  }\n\n  static createDeprecatedKernelCreateInfos(\n    builder: flatbuffers.Builder,\n    nodeIndicesOffset: flatbuffers.Offset,\n    kernelDefHashesOffset: flatbuffers.Offset,\n  ): flatbuffers.Offset {\n    DeprecatedKernelCreateInfos.startDeprecatedKernelCreateInfos(builder);\n    DeprecatedKernelCreateInfos.addNodeIndices(builder, nodeIndicesOffset);\n    DeprecatedKernelCreateInfos.addKernelDefHashes(builder, kernelDefHashesOffset);\n    return DeprecatedKernelCreateInfos.endDeprecatedKernelCreateInfos(builder);\n  }\n}\n", "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nimport * as flatbuffers from 'flatbuffers';\n\n/**\n * deprecated: no longer using kernel def hashes\n */\nexport class DeprecatedNodeIndexAndKernelDefHash {\n  bb: flatbuffers.ByteBuffer | null = null;\n  bb_pos = 0;\n  __init(i: number, bb: flatbuffers.ByteBuffer): DeprecatedNodeIndexAndKernelDefHash {\n    this.bb_pos = i;\n    this.bb = bb;\n    return this;\n  }\n\n  static getRootAsDeprecatedNodeIndexAndKernelDefHash(\n    bb: flatbuffers.ByteBuffer,\n    obj?: DeprecatedNodeIndexAndKernelDefHash,\n  ): DeprecatedNodeIndexAndKernelDefHash {\n    return (obj || new DeprecatedNodeIndexAndKernelDefHash()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  static getSizePrefixedRootAsDeprecatedNodeIndexAndKernelDefHash(\n    bb: flatbuffers.ByteBuffer,\n    obj?: DeprecatedNodeIndexAndKernelDefHash,\n  ): DeprecatedNodeIndexAndKernelDefHash {\n    bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);\n    return (obj || new DeprecatedNodeIndexAndKernelDefHash()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  nodeIndex(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 4);\n    return offset ? this.bb!.readUint32(this.bb_pos + offset) : 0;\n  }\n\n  kernelDefHash(): bigint {\n    const offset = this.bb!.__offset(this.bb_pos, 6);\n    return offset ? this.bb!.readUint64(this.bb_pos + offset) : BigInt('0');\n  }\n\n  static startDeprecatedNodeIndexAndKernelDefHash(builder: flatbuffers.Builder) {\n    builder.startObject(2);\n  }\n\n  static addNodeIndex(builder: flatbuffers.Builder, nodeIndex: number) {\n    builder.addFieldInt32(0, nodeIndex, 0);\n  }\n\n  static addKernelDefHash(builder: flatbuffers.Builder, kernelDefHash: bigint) {\n    builder.addFieldInt64(1, kernelDefHash, BigInt('0'));\n  }\n\n  static endDeprecatedNodeIndexAndKernelDefHash(builder: flatbuffers.Builder): flatbuffers.Offset {\n    const offset = builder.endObject();\n    return offset;\n  }\n\n  static createDeprecatedNodeIndexAndKernelDefHash(\n    builder: flatbuffers.Builder,\n    nodeIndex: number,\n    kernelDefHash: bigint,\n  ): flatbuffers.Offset {\n    DeprecatedNodeIndexAndKernelDefHash.startDeprecatedNodeIndexAndKernelDefHash(builder);\n    DeprecatedNodeIndexAndKernelDefHash.addNodeIndex(builder, nodeIndex);\n    DeprecatedNodeIndexAndKernelDefHash.addKernelDefHash(builder, kernelDefHash);\n    return DeprecatedNodeIndexAndKernelDefHash.endDeprecatedNodeIndexAndKernelDefHash(builder);\n  }\n}\n", "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nimport * as flatbuffers from 'flatbuffers';\n\nimport { DeprecatedSessionState } from '../../onnxruntime/fbs/deprecated-session-state.js';\n\n/**\n * deprecated: no longer using kernel def hashes\n */\nexport class DeprecatedSubGraphSessionState {\n  bb: flatbuffers.ByteBuffer | null = null;\n  bb_pos = 0;\n  __init(i: number, bb: flatbuffers.ByteBuffer): DeprecatedSubGraphSessionState {\n    this.bb_pos = i;\n    this.bb = bb;\n    return this;\n  }\n\n  static getRootAsDeprecatedSubGraphSessionState(\n    bb: flatbuffers.ByteBuffer,\n    obj?: DeprecatedSubGraphSessionState,\n  ): DeprecatedSubGraphSessionState {\n    return (obj || new DeprecatedSubGraphSessionState()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  static getSizePrefixedRootAsDeprecatedSubGraphSessionState(\n    bb: flatbuffers.ByteBuffer,\n    obj?: DeprecatedSubGraphSessionState,\n  ): DeprecatedSubGraphSessionState {\n    bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);\n    return (obj || new DeprecatedSubGraphSessionState()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  graphId(): string | null;\n  graphId(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;\n  graphId(optionalEncoding?: any): string | Uint8Array | null {\n    const offset = this.bb!.__offset(this.bb_pos, 4);\n    return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;\n  }\n\n  sessionState(obj?: DeprecatedSessionState): DeprecatedSessionState | null {\n    const offset = this.bb!.__offset(this.bb_pos, 6);\n    return offset\n      ? (obj || new DeprecatedSessionState()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!)\n      : null;\n  }\n\n  static startDeprecatedSubGraphSessionState(builder: flatbuffers.Builder) {\n    builder.startObject(2);\n  }\n\n  static addGraphId(builder: flatbuffers.Builder, graphIdOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(0, graphIdOffset, 0);\n  }\n\n  static addSessionState(builder: flatbuffers.Builder, sessionStateOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(1, sessionStateOffset, 0);\n  }\n\n  static endDeprecatedSubGraphSessionState(builder: flatbuffers.Builder): flatbuffers.Offset {\n    const offset = builder.endObject();\n    builder.requiredField(offset, 4); // graph_id\n    return offset;\n  }\n}\n", "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nimport * as flatbuffers from 'flatbuffers';\n\nimport { DeprecatedKernelCreateInfos } from '../../onnxruntime/fbs/deprecated-kernel-create-infos.js';\nimport { DeprecatedSubGraphSessionState } from '../../onnxruntime/fbs/deprecated-sub-graph-session-state.js';\n\n/**\n * deprecated: no longer using kernel def hashes\n */\nexport class DeprecatedSessionState {\n  bb: flatbuffers.ByteBuffer | null = null;\n  bb_pos = 0;\n  __init(i: number, bb: flatbuffers.ByteBuffer): DeprecatedSessionState {\n    this.bb_pos = i;\n    this.bb = bb;\n    return this;\n  }\n\n  static getRootAsDeprecatedSessionState(\n    bb: flatbuffers.ByteBuffer,\n    obj?: DeprecatedSessionState,\n  ): DeprecatedSessionState {\n    return (obj || new DeprecatedSessionState()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  static getSizePrefixedRootAsDeprecatedSessionState(\n    bb: flatbuffers.ByteBuffer,\n    obj?: DeprecatedSessionState,\n  ): DeprecatedSessionState {\n    bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);\n    return (obj || new DeprecatedSessionState()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  kernels(obj?: DeprecatedKernelCreateInfos): DeprecatedKernelCreateInfos | null {\n    const offset = this.bb!.__offset(this.bb_pos, 4);\n    return offset\n      ? (obj || new DeprecatedKernelCreateInfos()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!)\n      : null;\n  }\n\n  subGraphSessionStates(index: number, obj?: DeprecatedSubGraphSessionState): DeprecatedSubGraphSessionState | null {\n    const offset = this.bb!.__offset(this.bb_pos, 6);\n    return offset\n      ? (obj || new DeprecatedSubGraphSessionState()).__init(\n          this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4),\n          this.bb!,\n        )\n      : null;\n  }\n\n  subGraphSessionStatesLength(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 6);\n    return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n  }\n\n  static startDeprecatedSessionState(builder: flatbuffers.Builder) {\n    builder.startObject(2);\n  }\n\n  static addKernels(builder: flatbuffers.Builder, kernelsOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(0, kernelsOffset, 0);\n  }\n\n  static addSubGraphSessionStates(builder: flatbuffers.Builder, subGraphSessionStatesOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(1, subGraphSessionStatesOffset, 0);\n  }\n\n  static createSubGraphSessionStatesVector(\n    builder: flatbuffers.Builder,\n    data: flatbuffers.Offset[],\n  ): flatbuffers.Offset {\n    builder.startVector(4, data.length, 4);\n    for (let i = data.length - 1; i >= 0; i--) {\n      builder.addOffset(data[i]!);\n    }\n    return builder.endVector();\n  }\n\n  static startSubGraphSessionStatesVector(builder: flatbuffers.Builder, numElems: number) {\n    builder.startVector(4, numElems, 4);\n  }\n\n  static endDeprecatedSessionState(builder: flatbuffers.Builder): flatbuffers.Offset {\n    const offset = builder.endObject();\n    return offset;\n  }\n\n  static createDeprecatedSessionState(\n    builder: flatbuffers.Builder,\n    kernelsOffset: flatbuffers.Offset,\n    subGraphSessionStatesOffset: flatbuffers.Offset,\n  ): flatbuffers.Offset {\n    DeprecatedSessionState.startDeprecatedSessionState(builder);\n    DeprecatedSessionState.addKernels(builder, kernelsOffset);\n    DeprecatedSessionState.addSubGraphSessionStates(builder, subGraphSessionStatesOffset);\n    return DeprecatedSessionState.endDeprecatedSessionState(builder);\n  }\n}\n", "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nimport * as flatbuffers from 'flatbuffers';\n\nimport { ArgTypeAndIndex } from '../../onnxruntime/fbs/arg-type-and-index.js';\n\nexport class KernelTypeStrArgsEntry {\n  bb: flatbuffers.ByteBuffer | null = null;\n  bb_pos = 0;\n  __init(i: number, bb: flatbuffers.ByteBuffer): KernelTypeStrArgsEntry {\n    this.bb_pos = i;\n    this.bb = bb;\n    return this;\n  }\n\n  static getRootAsKernelTypeStrArgsEntry(\n    bb: flatbuffers.ByteBuffer,\n    obj?: KernelTypeStrArgsEntry,\n  ): KernelTypeStrArgsEntry {\n    return (obj || new KernelTypeStrArgsEntry()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  static getSizePrefixedRootAsKernelTypeStrArgsEntry(\n    bb: flatbuffers.ByteBuffer,\n    obj?: KernelTypeStrArgsEntry,\n  ): KernelTypeStrArgsEntry {\n    bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);\n    return (obj || new KernelTypeStrArgsEntry()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  kernelTypeStr(): string | null;\n  kernelTypeStr(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;\n  kernelTypeStr(optionalEncoding?: any): string | Uint8Array | null {\n    const offset = this.bb!.__offset(this.bb_pos, 4);\n    return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;\n  }\n\n  args(index: number, obj?: ArgTypeAndIndex): ArgTypeAndIndex | null {\n    const offset = this.bb!.__offset(this.bb_pos, 6);\n    return offset\n      ? (obj || new ArgTypeAndIndex()).__init(\n          this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4),\n          this.bb!,\n        )\n      : null;\n  }\n\n  argsLength(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 6);\n    return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n  }\n\n  static startKernelTypeStrArgsEntry(builder: flatbuffers.Builder) {\n    builder.startObject(2);\n  }\n\n  static addKernelTypeStr(builder: flatbuffers.Builder, kernelTypeStrOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(0, kernelTypeStrOffset, 0);\n  }\n\n  static addArgs(builder: flatbuffers.Builder, argsOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(1, argsOffset, 0);\n  }\n\n  static createArgsVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset {\n    builder.startVector(4, data.length, 4);\n    for (let i = data.length - 1; i >= 0; i--) {\n      builder.addOffset(data[i]!);\n    }\n    return builder.endVector();\n  }\n\n  static startArgsVector(builder: flatbuffers.Builder, numElems: number) {\n    builder.startVector(4, numElems, 4);\n  }\n\n  static endKernelTypeStrArgsEntry(builder: flatbuffers.Builder): flatbuffers.Offset {\n    const offset = builder.endObject();\n    builder.requiredField(offset, 4); // kernel_type_str\n    return offset;\n  }\n\n  static createKernelTypeStrArgsEntry(\n    builder: flatbuffers.Builder,\n    kernelTypeStrOffset: flatbuffers.Offset,\n    argsOffset: flatbuffers.Offset,\n  ): flatbuffers.Offset {\n    KernelTypeStrArgsEntry.startKernelTypeStrArgsEntry(builder);\n    KernelTypeStrArgsEntry.addKernelTypeStr(builder, kernelTypeStrOffset);\n    KernelTypeStrArgsEntry.addArgs(builder, argsOffset);\n    return KernelTypeStrArgsEntry.endKernelTypeStrArgsEntry(builder);\n  }\n}\n", "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nimport * as flatbuffers from 'flatbuffers';\n\nimport { KernelTypeStrArgsEntry } from '../../onnxruntime/fbs/kernel-type-str-args-entry.js';\n\nexport class OpIdKernelTypeStrArgsEntry {\n  bb: flatbuffers.ByteBuffer | null = null;\n  bb_pos = 0;\n  __init(i: number, bb: flatbuffers.ByteBuffer): OpIdKernelTypeStrArgsEntry {\n    this.bb_pos = i;\n    this.bb = bb;\n    return this;\n  }\n\n  static getRootAsOpIdKernelTypeStrArgsEntry(\n    bb: flatbuffers.ByteBuffer,\n    obj?: OpIdKernelTypeStrArgsEntry,\n  ): OpIdKernelTypeStrArgsEntry {\n    return (obj || new OpIdKernelTypeStrArgsEntry()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  static getSizePrefixedRootAsOpIdKernelTypeStrArgsEntry(\n    bb: flatbuffers.ByteBuffer,\n    obj?: OpIdKernelTypeStrArgsEntry,\n  ): OpIdKernelTypeStrArgsEntry {\n    bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);\n    return (obj || new OpIdKernelTypeStrArgsEntry()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  opId(): string | null;\n  opId(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;\n  opId(optionalEncoding?: any): string | Uint8Array | null {\n    const offset = this.bb!.__offset(this.bb_pos, 4);\n    return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;\n  }\n\n  kernelTypeStrArgs(index: number, obj?: KernelTypeStrArgsEntry): KernelTypeStrArgsEntry | null {\n    const offset = this.bb!.__offset(this.bb_pos, 6);\n    return offset\n      ? (obj || new KernelTypeStrArgsEntry()).__init(\n          this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4),\n          this.bb!,\n        )\n      : null;\n  }\n\n  kernelTypeStrArgsLength(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 6);\n    return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n  }\n\n  static startOpIdKernelTypeStrArgsEntry(builder: flatbuffers.Builder) {\n    builder.startObject(2);\n  }\n\n  static addOpId(builder: flatbuffers.Builder, opIdOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(0, opIdOffset, 0);\n  }\n\n  static addKernelTypeStrArgs(builder: flatbuffers.Builder, kernelTypeStrArgsOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(1, kernelTypeStrArgsOffset, 0);\n  }\n\n  static createKernelTypeStrArgsVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset {\n    builder.startVector(4, data.length, 4);\n    for (let i = data.length - 1; i >= 0; i--) {\n      builder.addOffset(data[i]!);\n    }\n    return builder.endVector();\n  }\n\n  static startKernelTypeStrArgsVector(builder: flatbuffers.Builder, numElems: number) {\n    builder.startVector(4, numElems, 4);\n  }\n\n  static endOpIdKernelTypeStrArgsEntry(builder: flatbuffers.Builder): flatbuffers.Offset {\n    const offset = builder.endObject();\n    builder.requiredField(offset, 4); // op_id\n    return offset;\n  }\n\n  static createOpIdKernelTypeStrArgsEntry(\n    builder: flatbuffers.Builder,\n    opIdOffset: flatbuffers.Offset,\n    kernelTypeStrArgsOffset: flatbuffers.Offset,\n  ): flatbuffers.Offset {\n    OpIdKernelTypeStrArgsEntry.startOpIdKernelTypeStrArgsEntry(builder);\n    OpIdKernelTypeStrArgsEntry.addOpId(builder, opIdOffset);\n    OpIdKernelTypeStrArgsEntry.addKernelTypeStrArgs(builder, kernelTypeStrArgsOffset);\n    return OpIdKernelTypeStrArgsEntry.endOpIdKernelTypeStrArgsEntry(builder);\n  }\n}\n", "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nimport * as flatbuffers from 'flatbuffers';\n\nimport { OpIdKernelTypeStrArgsEntry } from '../../onnxruntime/fbs/op-id-kernel-type-str-args-entry.js';\n\nexport class KernelTypeStrResolver {\n  bb: flatbuffers.ByteBuffer | null = null;\n  bb_pos = 0;\n  __init(i: number, bb: flatbuffers.ByteBuffer): KernelTypeStrResolver {\n    this.bb_pos = i;\n    this.bb = bb;\n    return this;\n  }\n\n  static getRootAsKernelTypeStrResolver(\n    bb: flatbuffers.ByteBuffer,\n    obj?: KernelTypeStrResolver,\n  ): KernelTypeStrResolver {\n    return (obj || new KernelTypeStrResolver()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  static getSizePrefixedRootAsKernelTypeStrResolver(\n    bb: flatbuffers.ByteBuffer,\n    obj?: KernelTypeStrResolver,\n  ): KernelTypeStrResolver {\n    bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);\n    return (obj || new KernelTypeStrResolver()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  opKernelTypeStrArgs(index: number, obj?: OpIdKernelTypeStrArgsEntry): OpIdKernelTypeStrArgsEntry | null {\n    const offset = this.bb!.__offset(this.bb_pos, 4);\n    return offset\n      ? (obj || new OpIdKernelTypeStrArgsEntry()).__init(\n          this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4),\n          this.bb!,\n        )\n      : null;\n  }\n\n  opKernelTypeStrArgsLength(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 4);\n    return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n  }\n\n  static startKernelTypeStrResolver(builder: flatbuffers.Builder) {\n    builder.startObject(1);\n  }\n\n  static addOpKernelTypeStrArgs(builder: flatbuffers.Builder, opKernelTypeStrArgsOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(0, opKernelTypeStrArgsOffset, 0);\n  }\n\n  static createOpKernelTypeStrArgsVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset {\n    builder.startVector(4, data.length, 4);\n    for (let i = data.length - 1; i >= 0; i--) {\n      builder.addOffset(data[i]!);\n    }\n    return builder.endVector();\n  }\n\n  static startOpKernelTypeStrArgsVector(builder: flatbuffers.Builder, numElems: number) {\n    builder.startVector(4, numElems, 4);\n  }\n\n  static endKernelTypeStrResolver(builder: flatbuffers.Builder): flatbuffers.Offset {\n    const offset = builder.endObject();\n    return offset;\n  }\n\n  static createKernelTypeStrResolver(\n    builder: flatbuffers.Builder,\n    opKernelTypeStrArgsOffset: flatbuffers.Offset,\n  ): flatbuffers.Offset {\n    KernelTypeStrResolver.startKernelTypeStrResolver(builder);\n    KernelTypeStrResolver.addOpKernelTypeStrArgs(builder, opKernelTypeStrArgsOffset);\n    return KernelTypeStrResolver.endKernelTypeStrResolver(builder);\n  }\n}\n", "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nimport * as flatbuffers from 'flatbuffers';\n\nexport class OperatorSetId {\n  bb: flatbuffers.ByteBuffer | null = null;\n  bb_pos = 0;\n  __init(i: number, bb: flatbuffers.ByteBuffer): OperatorSetId {\n    this.bb_pos = i;\n    this.bb = bb;\n    return this;\n  }\n\n  static getRootAsOperatorSetId(bb: flatbuffers.ByteBuffer, obj?: OperatorSetId): OperatorSetId {\n    return (obj || new OperatorSetId()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  static getSizePrefixedRootAsOperatorSetId(bb: flatbuffers.ByteBuffer, obj?: OperatorSetId): OperatorSetId {\n    bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);\n    return (obj || new OperatorSetId()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  domain(): string | null;\n  domain(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;\n  domain(optionalEncoding?: any): string | Uint8Array | null {\n    const offset = this.bb!.__offset(this.bb_pos, 4);\n    return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;\n  }\n\n  version(): bigint {\n    const offset = this.bb!.__offset(this.bb_pos, 6);\n    return offset ? this.bb!.readInt64(this.bb_pos + offset) : BigInt('0');\n  }\n\n  static startOperatorSetId(builder: flatbuffers.Builder) {\n    builder.startObject(2);\n  }\n\n  static addDomain(builder: flatbuffers.Builder, domainOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(0, domainOffset, 0);\n  }\n\n  static addVersion(builder: flatbuffers.Builder, version: bigint) {\n    builder.addFieldInt64(1, version, BigInt('0'));\n  }\n\n  static endOperatorSetId(builder: flatbuffers.Builder): flatbuffers.Offset {\n    const offset = builder.endObject();\n    return offset;\n  }\n\n  static createOperatorSetId(\n    builder: flatbuffers.Builder,\n    domainOffset: flatbuffers.Offset,\n    version: bigint,\n  ): flatbuffers.Offset {\n    OperatorSetId.startOperatorSetId(builder);\n    OperatorSetId.addDomain(builder, domainOffset);\n    OperatorSetId.addVersion(builder, version);\n    return OperatorSetId.endOperatorSetId(builder);\n  }\n}\n", "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nimport * as flatbuffers from 'flatbuffers';\n\nexport class StringStringEntry {\n  bb: flatbuffers.ByteBuffer | null = null;\n  bb_pos = 0;\n  __init(i: number, bb: flatbuffers.ByteBuffer): StringStringEntry {\n    this.bb_pos = i;\n    this.bb = bb;\n    return this;\n  }\n\n  static getRootAsStringStringEntry(bb: flatbuffers.ByteBuffer, obj?: StringStringEntry): StringStringEntry {\n    return (obj || new StringStringEntry()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  static getSizePrefixedRootAsStringStringEntry(\n    bb: flatbuffers.ByteBuffer,\n    obj?: StringStringEntry,\n  ): StringStringEntry {\n    bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);\n    return (obj || new StringStringEntry()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  key(): string | null;\n  key(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;\n  key(optionalEncoding?: any): string | Uint8Array | null {\n    const offset = this.bb!.__offset(this.bb_pos, 4);\n    return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;\n  }\n\n  value(): string | null;\n  value(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;\n  value(optionalEncoding?: any): string | Uint8Array | null {\n    const offset = this.bb!.__offset(this.bb_pos, 6);\n    return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;\n  }\n\n  static startStringStringEntry(builder: flatbuffers.Builder) {\n    builder.startObject(2);\n  }\n\n  static addKey(builder: flatbuffers.Builder, keyOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(0, keyOffset, 0);\n  }\n\n  static addValue(builder: flatbuffers.Builder, valueOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(1, valueOffset, 0);\n  }\n\n  static endStringStringEntry(builder: flatbuffers.Builder): flatbuffers.Offset {\n    const offset = builder.endObject();\n    return offset;\n  }\n\n  static createStringStringEntry(\n    builder: flatbuffers.Builder,\n    keyOffset: flatbuffers.Offset,\n    valueOffset: flatbuffers.Offset,\n  ): flatbuffers.Offset {\n    StringStringEntry.startStringStringEntry(builder);\n    StringStringEntry.addKey(builder, keyOffset);\n    StringStringEntry.addValue(builder, valueOffset);\n    return StringStringEntry.endStringStringEntry(builder);\n  }\n}\n", "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nimport * as flatbuffers from 'flatbuffers';\n\nimport { Graph } from '../../onnxruntime/fbs/graph.js';\nimport { OperatorSetId } from '../../onnxruntime/fbs/operator-set-id.js';\nimport { StringStringEntry } from '../../onnxruntime/fbs/string-string-entry.js';\n\nexport class Model {\n  bb: flatbuffers.ByteBuffer | null = null;\n  bb_pos = 0;\n  __init(i: number, bb: flatbuffers.ByteBuffer): Model {\n    this.bb_pos = i;\n    this.bb = bb;\n    return this;\n  }\n\n  static getRootAsModel(bb: flatbuffers.ByteBuffer, obj?: Model): Model {\n    return (obj || new Model()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  static getSizePrefixedRootAsModel(bb: flatbuffers.ByteBuffer, obj?: Model): Model {\n    bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);\n    return (obj || new Model()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  irVersion(): bigint {\n    const offset = this.bb!.__offset(this.bb_pos, 4);\n    return offset ? this.bb!.readInt64(this.bb_pos + offset) : BigInt('0');\n  }\n\n  opsetImport(index: number, obj?: OperatorSetId): OperatorSetId | null {\n    const offset = this.bb!.__offset(this.bb_pos, 6);\n    return offset\n      ? (obj || new OperatorSetId()).__init(\n          this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4),\n          this.bb!,\n        )\n      : null;\n  }\n\n  opsetImportLength(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 6);\n    return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n  }\n\n  producerName(): string | null;\n  producerName(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;\n  producerName(optionalEncoding?: any): string | Uint8Array | null {\n    const offset = this.bb!.__offset(this.bb_pos, 8);\n    return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;\n  }\n\n  producerVersion(): string | null;\n  producerVersion(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;\n  producerVersion(optionalEncoding?: any): string | Uint8Array | null {\n    const offset = this.bb!.__offset(this.bb_pos, 10);\n    return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;\n  }\n\n  domain(): string | null;\n  domain(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;\n  domain(optionalEncoding?: any): string | Uint8Array | null {\n    const offset = this.bb!.__offset(this.bb_pos, 12);\n    return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;\n  }\n\n  modelVersion(): bigint {\n    const offset = this.bb!.__offset(this.bb_pos, 14);\n    return offset ? this.bb!.readInt64(this.bb_pos + offset) : BigInt('0');\n  }\n\n  docString(): string | null;\n  docString(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;\n  docString(optionalEncoding?: any): string | Uint8Array | null {\n    const offset = this.bb!.__offset(this.bb_pos, 16);\n    return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;\n  }\n\n  graph(obj?: Graph): Graph | null {\n    const offset = this.bb!.__offset(this.bb_pos, 18);\n    return offset ? (obj || new Graph()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null;\n  }\n\n  graphDocString(): string | null;\n  graphDocString(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;\n  graphDocString(optionalEncoding?: any): string | Uint8Array | null {\n    const offset = this.bb!.__offset(this.bb_pos, 20);\n    return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;\n  }\n\n  metadataProps(index: number, obj?: StringStringEntry): StringStringEntry | null {\n    const offset = this.bb!.__offset(this.bb_pos, 22);\n    return offset\n      ? (obj || new StringStringEntry()).__init(\n          this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4),\n          this.bb!,\n        )\n      : null;\n  }\n\n  metadataPropsLength(): number {\n    const offset = this.bb!.__offset(this.bb_pos, 22);\n    return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n  }\n\n  static startModel(builder: flatbuffers.Builder) {\n    builder.startObject(10);\n  }\n\n  static addIrVersion(builder: flatbuffers.Builder, irVersion: bigint) {\n    builder.addFieldInt64(0, irVersion, BigInt('0'));\n  }\n\n  static addOpsetImport(builder: flatbuffers.Builder, opsetImportOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(1, opsetImportOffset, 0);\n  }\n\n  static createOpsetImportVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset {\n    builder.startVector(4, data.length, 4);\n    for (let i = data.length - 1; i >= 0; i--) {\n      builder.addOffset(data[i]!);\n    }\n    return builder.endVector();\n  }\n\n  static startOpsetImportVector(builder: flatbuffers.Builder, numElems: number) {\n    builder.startVector(4, numElems, 4);\n  }\n\n  static addProducerName(builder: flatbuffers.Builder, producerNameOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(2, producerNameOffset, 0);\n  }\n\n  static addProducerVersion(builder: flatbuffers.Builder, producerVersionOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(3, producerVersionOffset, 0);\n  }\n\n  static addDomain(builder: flatbuffers.Builder, domainOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(4, domainOffset, 0);\n  }\n\n  static addModelVersion(builder: flatbuffers.Builder, modelVersion: bigint) {\n    builder.addFieldInt64(5, modelVersion, BigInt('0'));\n  }\n\n  static addDocString(builder: flatbuffers.Builder, docStringOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(6, docStringOffset, 0);\n  }\n\n  static addGraph(builder: flatbuffers.Builder, graphOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(7, graphOffset, 0);\n  }\n\n  static addGraphDocString(builder: flatbuffers.Builder, graphDocStringOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(8, graphDocStringOffset, 0);\n  }\n\n  static addMetadataProps(builder: flatbuffers.Builder, metadataPropsOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(9, metadataPropsOffset, 0);\n  }\n\n  static createMetadataPropsVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset {\n    builder.startVector(4, data.length, 4);\n    for (let i = data.length - 1; i >= 0; i--) {\n      builder.addOffset(data[i]!);\n    }\n    return builder.endVector();\n  }\n\n  static startMetadataPropsVector(builder: flatbuffers.Builder, numElems: number) {\n    builder.startVector(4, numElems, 4);\n  }\n\n  static endModel(builder: flatbuffers.Builder): flatbuffers.Offset {\n    const offset = builder.endObject();\n    return offset;\n  }\n}\n", "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nimport * as flatbuffers from 'flatbuffers';\n\nimport { KernelTypeStrResolver } from '../../onnxruntime/fbs/kernel-type-str-resolver.js';\nimport { Model } from '../../onnxruntime/fbs/model.js';\n\nexport class InferenceSession {\n  bb: flatbuffers.ByteBuffer | null = null;\n  bb_pos = 0;\n  __init(i: number, bb: flatbuffers.ByteBuffer): InferenceSession {\n    this.bb_pos = i;\n    this.bb = bb;\n    return this;\n  }\n\n  static getRootAsInferenceSession(bb: flatbuffers.ByteBuffer, obj?: InferenceSession): InferenceSession {\n    return (obj || new InferenceSession()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  static getSizePrefixedRootAsInferenceSession(bb: flatbuffers.ByteBuffer, obj?: InferenceSession): InferenceSession {\n    bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);\n    return (obj || new InferenceSession()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n  }\n\n  static bufferHasIdentifier(bb: flatbuffers.ByteBuffer): boolean {\n    return bb.__has_identifier('ORTM');\n  }\n\n  ortVersion(): string | null;\n  ortVersion(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;\n  ortVersion(optionalEncoding?: any): string | Uint8Array | null {\n    const offset = this.bb!.__offset(this.bb_pos, 4);\n    return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;\n  }\n\n  model(obj?: Model): Model | null {\n    const offset = this.bb!.__offset(this.bb_pos, 6);\n    return offset ? (obj || new Model()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null;\n  }\n\n  kernelTypeStrResolver(obj?: KernelTypeStrResolver): KernelTypeStrResolver | null {\n    const offset = this.bb!.__offset(this.bb_pos, 10);\n    return offset\n      ? (obj || new KernelTypeStrResolver()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!)\n      : null;\n  }\n\n  static startInferenceSession(builder: flatbuffers.Builder) {\n    builder.startObject(4);\n  }\n\n  static addOrtVersion(builder: flatbuffers.Builder, ortVersionOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(0, ortVersionOffset, 0);\n  }\n\n  static addModel(builder: flatbuffers.Builder, modelOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(1, modelOffset, 0);\n  }\n\n  static addKernelTypeStrResolver(builder: flatbuffers.Builder, kernelTypeStrResolverOffset: flatbuffers.Offset) {\n    builder.addFieldOffset(3, kernelTypeStrResolverOffset, 0);\n  }\n\n  static endInferenceSession(builder: flatbuffers.Builder): flatbuffers.Offset {\n    const offset = builder.endObject();\n    return offset;\n  }\n\n  static finishInferenceSessionBuffer(builder: flatbuffers.Builder, offset: flatbuffers.Offset) {\n    builder.finish(offset, 'ORTM');\n  }\n\n  static finishSizePrefixedInferenceSessionBuffer(builder: flatbuffers.Builder, offset: flatbuffers.Offset) {\n    builder.finish(offset, 'ORTM', true);\n  }\n}\n", "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nexport { ArgType } from './fbs/arg-type.js';\nexport { ArgTypeAndIndex } from './fbs/arg-type-and-index.js';\nexport { Attribute } from './fbs/attribute.js';\nexport { AttributeType } from './fbs/attribute-type.js';\nexport { DeprecatedKernelCreateInfos } from './fbs/deprecated-kernel-create-infos.js';\nexport { DeprecatedNodeIndexAndKernelDefHash } from './fbs/deprecated-node-index-and-kernel-def-hash.js';\nexport { DeprecatedSessionState } from './fbs/deprecated-session-state.js';\nexport { DeprecatedSubGraphSessionState } from './fbs/deprecated-sub-graph-session-state.js';\nexport { Dimension } from './fbs/dimension.js';\nexport { DimensionValue } from './fbs/dimension-value.js';\nexport { DimensionValueType } from './fbs/dimension-value-type.js';\nexport { EdgeEnd } from './fbs/edge-end.js';\nexport { Graph } from './fbs/graph.js';\nexport { InferenceSession } from './fbs/inference-session.js';\nexport { KernelTypeStrArgsEntry } from './fbs/kernel-type-str-args-entry.js';\nexport { KernelTypeStrResolver } from './fbs/kernel-type-str-resolver.js';\nexport { MapType } from './fbs/map-type.js';\nexport { Model } from './fbs/model.js';\nexport { Node } from './fbs/node.js';\nexport { NodeEdge } from './fbs/node-edge.js';\nexport { NodeType } from './fbs/node-type.js';\nexport { NodesToOptimizeIndices } from './fbs/nodes-to-optimize-indices.js';\nexport { OpIdKernelTypeStrArgsEntry } from './fbs/op-id-kernel-type-str-args-entry.js';\nexport { OperatorSetId } from './fbs/operator-set-id.js';\nexport { RuntimeOptimizationRecord } from './fbs/runtime-optimization-record.js';\nexport { RuntimeOptimizationRecordContainerEntry } from './fbs/runtime-optimization-record-container-entry.js';\nexport { RuntimeOptimizations } from './fbs/runtime-optimizations.js';\nexport { SequenceType } from './fbs/sequence-type.js';\nexport { Shape } from './fbs/shape.js';\nexport { SparseTensor } from './fbs/sparse-tensor.js';\nexport { StringStringEntry } from './fbs/string-string-entry.js';\nexport { Tensor } from './fbs/tensor.js';\nexport { TensorDataType } from './fbs/tensor-data-type.js';\nexport { TensorTypeAndShape } from './fbs/tensor-type-and-shape.js';\nexport { TypeInfo } from './fbs/type-info.js';\nexport { TypeInfoValue } from './fbs/type-info-value.js';\nexport { ValueInfo } from './fbs/value-info.js';\n", "export * from './onnxruntime/fbs';\n", "\"use strict\";\r\nmodule.exports = asPromise;\r\n\r\n/**\r\n * Callback as used by {@link util.asPromise}.\r\n * @typedef asPromiseCallback\r\n * @type {function}\r\n * @param {Error|null} error Error, if any\r\n * @param {...*} params Additional arguments\r\n * @returns {undefined}\r\n */\r\n\r\n/**\r\n * Returns a promise from a node-style callback function.\r\n * @memberof util\r\n * @param {asPromiseCallback} fn Function to call\r\n * @param {*} ctx Function context\r\n * @param {...*} params Function arguments\r\n * @returns {Promise<*>} Promisified function\r\n */\r\nfunction asPromise(fn, ctx/*, varargs */) {\r\n    var params  = new Array(arguments.length - 1),\r\n        offset  = 0,\r\n        index   = 2,\r\n        pending = true;\r\n    while (index < arguments.length)\r\n        params[offset++] = arguments[index++];\r\n    return new Promise(function executor(resolve, reject) {\r\n        params[offset] = function callback(err/*, varargs */) {\r\n            if (pending) {\r\n                pending = false;\r\n                if (err)\r\n                    reject(err);\r\n                else {\r\n                    var params = new Array(arguments.length - 1),\r\n                        offset = 0;\r\n                    while (offset < params.length)\r\n                        params[offset++] = arguments[offset];\r\n                    resolve.apply(null, params);\r\n                }\r\n            }\r\n        };\r\n        try {\r\n            fn.apply(ctx || null, params);\r\n        } catch (err) {\r\n            if (pending) {\r\n                pending = false;\r\n                reject(err);\r\n            }\r\n        }\r\n    });\r\n}\r\n", "\"use strict\";\r\n\r\n/**\r\n * A minimal base64 implementation for number arrays.\r\n * @memberof util\r\n * @namespace\r\n */\r\nvar base64 = exports;\r\n\r\n/**\r\n * Calculates the byte length of a base64 encoded string.\r\n * @param {string} string Base64 encoded string\r\n * @returns {number} Byte length\r\n */\r\nbase64.length = function length(string) {\r\n    var p = string.length;\r\n    if (!p)\r\n        return 0;\r\n    var n = 0;\r\n    while (--p % 4 > 1 && string.charAt(p) === \"=\")\r\n        ++n;\r\n    return Math.ceil(string.length * 3) / 4 - n;\r\n};\r\n\r\n// Base64 encoding table\r\nvar b64 = new Array(64);\r\n\r\n// Base64 decoding table\r\nvar s64 = new Array(123);\r\n\r\n// 65..90, 97..122, 48..57, 43, 47\r\nfor (var i = 0; i < 64;)\r\n    s64[b64[i] = i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i - 59 | 43] = i++;\r\n\r\n/**\r\n * Encodes a buffer to a base64 encoded string.\r\n * @param {Uint8Array} buffer Source buffer\r\n * @param {number} start Source start\r\n * @param {number} end Source end\r\n * @returns {string} Base64 encoded string\r\n */\r\nbase64.encode = function encode(buffer, start, end) {\r\n    var parts = null,\r\n        chunk = [];\r\n    var i = 0, // output index\r\n        j = 0, // goto index\r\n        t;     // temporary\r\n    while (start < end) {\r\n        var b = buffer[start++];\r\n        switch (j) {\r\n            case 0:\r\n                chunk[i++] = b64[b >> 2];\r\n                t = (b & 3) << 4;\r\n                j = 1;\r\n                break;\r\n            case 1:\r\n                chunk[i++] = b64[t | b >> 4];\r\n                t = (b & 15) << 2;\r\n                j = 2;\r\n                break;\r\n            case 2:\r\n                chunk[i++] = b64[t | b >> 6];\r\n                chunk[i++] = b64[b & 63];\r\n                j = 0;\r\n                break;\r\n        }\r\n        if (i > 8191) {\r\n            (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));\r\n            i = 0;\r\n        }\r\n    }\r\n    if (j) {\r\n        chunk[i++] = b64[t];\r\n        chunk[i++] = 61;\r\n        if (j === 1)\r\n            chunk[i++] = 61;\r\n    }\r\n    if (parts) {\r\n        if (i)\r\n            parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));\r\n        return parts.join(\"\");\r\n    }\r\n    return String.fromCharCode.apply(String, chunk.slice(0, i));\r\n};\r\n\r\nvar invalidEncoding = \"invalid encoding\";\r\n\r\n/**\r\n * Decodes a base64 encoded string to a buffer.\r\n * @param {string} string Source string\r\n * @param {Uint8Array} buffer Destination buffer\r\n * @param {number} offset Destination offset\r\n * @returns {number} Number of bytes written\r\n * @throws {Error} If encoding is invalid\r\n */\r\nbase64.decode = function decode(string, buffer, offset) {\r\n    var start = offset;\r\n    var j = 0, // goto index\r\n        t;     // temporary\r\n    for (var i = 0; i < string.length;) {\r\n        var c = string.charCodeAt(i++);\r\n        if (c === 61 && j > 1)\r\n            break;\r\n        if ((c = s64[c]) === undefined)\r\n            throw Error(invalidEncoding);\r\n        switch (j) {\r\n            case 0:\r\n                t = c;\r\n                j = 1;\r\n                break;\r\n            case 1:\r\n                buffer[offset++] = t << 2 | (c & 48) >> 4;\r\n                t = c;\r\n                j = 2;\r\n                break;\r\n            case 2:\r\n                buffer[offset++] = (t & 15) << 4 | (c & 60) >> 2;\r\n                t = c;\r\n                j = 3;\r\n                break;\r\n            case 3:\r\n                buffer[offset++] = (t & 3) << 6 | c;\r\n                j = 0;\r\n                break;\r\n        }\r\n    }\r\n    if (j === 1)\r\n        throw Error(invalidEncoding);\r\n    return offset - start;\r\n};\r\n\r\n/**\r\n * Tests if the specified string appears to be base64 encoded.\r\n * @param {string} string String to test\r\n * @returns {boolean} `true` if probably base64 encoded, otherwise false\r\n */\r\nbase64.test = function test(string) {\r\n    return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(string);\r\n};\r\n", "\"use strict\";\r\nmodule.exports = EventEmitter;\r\n\r\n/**\r\n * Constructs a new event emitter instance.\r\n * @classdesc A minimal event emitter.\r\n * @memberof util\r\n * @constructor\r\n */\r\nfunction EventEmitter() {\r\n\r\n    /**\r\n     * Registered listeners.\r\n     * @type {Object.<string,*>}\r\n     * @private\r\n     */\r\n    this._listeners = Object.create(null);\r\n}\r\n\r\n/**\r\n * Event listener as used by {@link util.EventEmitter}.\r\n * @typedef EventEmitterListener\r\n * @type {function}\r\n * @param {...*} args Arguments\r\n * @returns {undefined}\r\n */\r\n\r\n/**\r\n * Registers an event listener.\r\n * @param {string} evt Event name\r\n * @param {EventEmitterListener} fn Listener\r\n * @param {*} [ctx] Listener context\r\n * @returns {this} `this`\r\n */\r\nEventEmitter.prototype.on = function on(evt, fn, ctx) {\r\n    (this._listeners[evt] || (this._listeners[evt] = [])).push({\r\n        fn  : fn,\r\n        ctx : ctx || this\r\n    });\r\n    return this;\r\n};\r\n\r\n/**\r\n * Removes an event listener or any matching listeners if arguments are omitted.\r\n * @param {string} [evt] Event name. Removes all listeners if omitted.\r\n * @param {EventEmitterListener} [fn] Listener to remove. Removes all listeners of `evt` if omitted.\r\n * @returns {this} `this`\r\n */\r\nEventEmitter.prototype.off = function off(evt, fn) {\r\n    if (evt === undefined)\r\n        this._listeners = Object.create(null);\r\n    else {\r\n        if (fn === undefined)\r\n            this._listeners[evt] = [];\r\n        else {\r\n            var listeners = this._listeners[evt];\r\n            if (!listeners)\r\n                return this;\r\n            for (var i = 0; i < listeners.length;)\r\n                if (listeners[i].fn === fn)\r\n                    listeners.splice(i, 1);\r\n                else\r\n                    ++i;\r\n        }\r\n    }\r\n    return this;\r\n};\r\n\r\n/**\r\n * Emits an event by calling its listeners with the specified arguments.\r\n * @param {string} evt Event name\r\n * @param {...*} args Arguments\r\n * @returns {this} `this`\r\n */\r\nEventEmitter.prototype.emit = function emit(evt) {\r\n    var listeners = this._listeners[evt];\r\n    if (listeners) {\r\n        var args = [],\r\n            i = 1;\r\n        for (; i < arguments.length;)\r\n            args.push(arguments[i++]);\r\n        for (i = 0; i < listeners.length;)\r\n            listeners[i].fn.apply(listeners[i++].ctx, args);\r\n    }\r\n    return this;\r\n};\r\n", "\"use strict\";\r\n\r\nmodule.exports = factory(factory);\r\n\r\n/**\r\n * Reads / writes floats / doubles from / to buffers.\r\n * @name util.float\r\n * @namespace\r\n */\r\n\r\n/**\r\n * Writes a 32 bit float to a buffer using little endian byte order.\r\n * @name util.float.writeFloatLE\r\n * @function\r\n * @param {number} val Value to write\r\n * @param {Uint8Array} buf Target buffer\r\n * @param {number} pos Target buffer offset\r\n * @returns {undefined}\r\n */\r\n\r\n/**\r\n * Writes a 32 bit float to a buffer using big endian byte order.\r\n * @name util.float.writeFloatBE\r\n * @function\r\n * @param {number} val Value to write\r\n * @param {Uint8Array} buf Target buffer\r\n * @param {number} pos Target buffer offset\r\n * @returns {undefined}\r\n */\r\n\r\n/**\r\n * Reads a 32 bit float from a buffer using little endian byte order.\r\n * @name util.float.readFloatLE\r\n * @function\r\n * @param {Uint8Array} buf Source buffer\r\n * @param {number} pos Source buffer offset\r\n * @returns {number} Value read\r\n */\r\n\r\n/**\r\n * Reads a 32 bit float from a buffer using big endian byte order.\r\n * @name util.float.readFloatBE\r\n * @function\r\n * @param {Uint8Array} buf Source buffer\r\n * @param {number} pos Source buffer offset\r\n * @returns {number} Value read\r\n */\r\n\r\n/**\r\n * Writes a 64 bit double to a buffer using little endian byte order.\r\n * @name util.float.writeDoubleLE\r\n * @function\r\n * @param {number} val Value to write\r\n * @param {Uint8Array} buf Target buffer\r\n * @param {number} pos Target buffer offset\r\n * @returns {undefined}\r\n */\r\n\r\n/**\r\n * Writes a 64 bit double to a buffer using big endian byte order.\r\n * @name util.float.writeDoubleBE\r\n * @function\r\n * @param {number} val Value to write\r\n * @param {Uint8Array} buf Target buffer\r\n * @param {number} pos Target buffer offset\r\n * @returns {undefined}\r\n */\r\n\r\n/**\r\n * Reads a 64 bit double from a buffer using little endian byte order.\r\n * @name util.float.readDoubleLE\r\n * @function\r\n * @param {Uint8Array} buf Source buffer\r\n * @param {number} pos Source buffer offset\r\n * @returns {number} Value read\r\n */\r\n\r\n/**\r\n * Reads a 64 bit double from a buffer using big endian byte order.\r\n * @name util.float.readDoubleBE\r\n * @function\r\n * @param {Uint8Array} buf Source buffer\r\n * @param {number} pos Source buffer offset\r\n * @returns {number} Value read\r\n */\r\n\r\n// Factory function for the purpose of node-based testing in modified global environments\r\nfunction factory(exports) {\r\n\r\n    // float: typed array\r\n    if (typeof Float32Array !== \"undefined\") (function() {\r\n\r\n        var f32 = new Float32Array([ -0 ]),\r\n            f8b = new Uint8Array(f32.buffer),\r\n            le  = f8b[3] === 128;\r\n\r\n        function writeFloat_f32_cpy(val, buf, pos) {\r\n            f32[0] = val;\r\n            buf[pos    ] = f8b[0];\r\n            buf[pos + 1] = f8b[1];\r\n            buf[pos + 2] = f8b[2];\r\n            buf[pos + 3] = f8b[3];\r\n        }\r\n\r\n        function writeFloat_f32_rev(val, buf, pos) {\r\n            f32[0] = val;\r\n            buf[pos    ] = f8b[3];\r\n            buf[pos + 1] = f8b[2];\r\n            buf[pos + 2] = f8b[1];\r\n            buf[pos + 3] = f8b[0];\r\n        }\r\n\r\n        /* istanbul ignore next */\r\n        exports.writeFloatLE = le ? writeFloat_f32_cpy : writeFloat_f32_rev;\r\n        /* istanbul ignore next */\r\n        exports.writeFloatBE = le ? writeFloat_f32_rev : writeFloat_f32_cpy;\r\n\r\n        function readFloat_f32_cpy(buf, pos) {\r\n            f8b[0] = buf[pos    ];\r\n            f8b[1] = buf[pos + 1];\r\n            f8b[2] = buf[pos + 2];\r\n            f8b[3] = buf[pos + 3];\r\n            return f32[0];\r\n        }\r\n\r\n        function readFloat_f32_rev(buf, pos) {\r\n            f8b[3] = buf[pos    ];\r\n            f8b[2] = buf[pos + 1];\r\n            f8b[1] = buf[pos + 2];\r\n            f8b[0] = buf[pos + 3];\r\n            return f32[0];\r\n        }\r\n\r\n        /* istanbul ignore next */\r\n        exports.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev;\r\n        /* istanbul ignore next */\r\n        exports.readFloatBE = le ? readFloat_f32_rev : readFloat_f32_cpy;\r\n\r\n    // float: ieee754\r\n    })(); else (function() {\r\n\r\n        function writeFloat_ieee754(writeUint, val, buf, pos) {\r\n            var sign = val < 0 ? 1 : 0;\r\n            if (sign)\r\n                val = -val;\r\n            if (val === 0)\r\n                writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos);\r\n            else if (isNaN(val))\r\n                writeUint(2143289344, buf, pos);\r\n            else if (val > 3.4028234663852886e+38) // +-Infinity\r\n                writeUint((sign << 31 | 2139095040) >>> 0, buf, pos);\r\n            else if (val < 1.1754943508222875e-38) // denormal\r\n                writeUint((sign << 31 | Math.round(val / 1.401298464324817e-45)) >>> 0, buf, pos);\r\n            else {\r\n                var exponent = Math.floor(Math.log(val) / Math.LN2),\r\n                    mantissa = Math.round(val * Math.pow(2, -exponent) * 8388608) & 8388607;\r\n                writeUint((sign << 31 | exponent + 127 << 23 | mantissa) >>> 0, buf, pos);\r\n            }\r\n        }\r\n\r\n        exports.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);\r\n        exports.writeFloatBE = writeFloat_ieee754.bind(null, writeUintBE);\r\n\r\n        function readFloat_ieee754(readUint, buf, pos) {\r\n            var uint = readUint(buf, pos),\r\n                sign = (uint >> 31) * 2 + 1,\r\n                exponent = uint >>> 23 & 255,\r\n                mantissa = uint & 8388607;\r\n            return exponent === 255\r\n                ? mantissa\r\n                ? NaN\r\n                : sign * Infinity\r\n                : exponent === 0 // denormal\r\n                ? sign * 1.401298464324817e-45 * mantissa\r\n                : sign * Math.pow(2, exponent - 150) * (mantissa + 8388608);\r\n        }\r\n\r\n        exports.readFloatLE = readFloat_ieee754.bind(null, readUintLE);\r\n        exports.readFloatBE = readFloat_ieee754.bind(null, readUintBE);\r\n\r\n    })();\r\n\r\n    // double: typed array\r\n    if (typeof Float64Array !== \"undefined\") (function() {\r\n\r\n        var f64 = new Float64Array([-0]),\r\n            f8b = new Uint8Array(f64.buffer),\r\n            le  = f8b[7] === 128;\r\n\r\n        function writeDouble_f64_cpy(val, buf, pos) {\r\n            f64[0] = val;\r\n            buf[pos    ] = f8b[0];\r\n            buf[pos + 1] = f8b[1];\r\n            buf[pos + 2] = f8b[2];\r\n            buf[pos + 3] = f8b[3];\r\n            buf[pos + 4] = f8b[4];\r\n            buf[pos + 5] = f8b[5];\r\n            buf[pos + 6] = f8b[6];\r\n            buf[pos + 7] = f8b[7];\r\n        }\r\n\r\n        function writeDouble_f64_rev(val, buf, pos) {\r\n            f64[0] = val;\r\n            buf[pos    ] = f8b[7];\r\n            buf[pos + 1] = f8b[6];\r\n            buf[pos + 2] = f8b[5];\r\n            buf[pos + 3] = f8b[4];\r\n            buf[pos + 4] = f8b[3];\r\n            buf[pos + 5] = f8b[2];\r\n            buf[pos + 6] = f8b[1];\r\n            buf[pos + 7] = f8b[0];\r\n        }\r\n\r\n        /* istanbul ignore next */\r\n        exports.writeDoubleLE = le ? writeDouble_f64_cpy : writeDouble_f64_rev;\r\n        /* istanbul ignore next */\r\n        exports.writeDoubleBE = le ? writeDouble_f64_rev : writeDouble_f64_cpy;\r\n\r\n        function readDouble_f64_cpy(buf, pos) {\r\n            f8b[0] = buf[pos    ];\r\n            f8b[1] = buf[pos + 1];\r\n            f8b[2] = buf[pos + 2];\r\n            f8b[3] = buf[pos + 3];\r\n            f8b[4] = buf[pos + 4];\r\n            f8b[5] = buf[pos + 5];\r\n            f8b[6] = buf[pos + 6];\r\n            f8b[7] = buf[pos + 7];\r\n            return f64[0];\r\n        }\r\n\r\n        function readDouble_f64_rev(buf, pos) {\r\n            f8b[7] = buf[pos    ];\r\n            f8b[6] = buf[pos + 1];\r\n            f8b[5] = buf[pos + 2];\r\n            f8b[4] = buf[pos + 3];\r\n            f8b[3] = buf[pos + 4];\r\n            f8b[2] = buf[pos + 5];\r\n            f8b[1] = buf[pos + 6];\r\n            f8b[0] = buf[pos + 7];\r\n            return f64[0];\r\n        }\r\n\r\n        /* istanbul ignore next */\r\n        exports.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;\r\n        /* istanbul ignore next */\r\n        exports.readDoubleBE = le ? readDouble_f64_rev : readDouble_f64_cpy;\r\n\r\n    // double: ieee754\r\n    })(); else (function() {\r\n\r\n        function writeDouble_ieee754(writeUint, off0, off1, val, buf, pos) {\r\n            var sign = val < 0 ? 1 : 0;\r\n            if (sign)\r\n                val = -val;\r\n            if (val === 0) {\r\n                writeUint(0, buf, pos + off0);\r\n                writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos + off1);\r\n            } else if (isNaN(val)) {\r\n                writeUint(0, buf, pos + off0);\r\n                writeUint(2146959360, buf, pos + off1);\r\n            } else if (val > 1.7976931348623157e+308) { // +-Infinity\r\n                writeUint(0, buf, pos + off0);\r\n                writeUint((sign << 31 | 2146435072) >>> 0, buf, pos + off1);\r\n            } else {\r\n                var mantissa;\r\n                if (val < 2.2250738585072014e-308) { // denormal\r\n                    mantissa = val / 5e-324;\r\n                    writeUint(mantissa >>> 0, buf, pos + off0);\r\n                    writeUint((sign << 31 | mantissa / 4294967296) >>> 0, buf, pos + off1);\r\n                } else {\r\n                    var exponent = Math.floor(Math.log(val) / Math.LN2);\r\n                    if (exponent === 1024)\r\n                        exponent = 1023;\r\n                    mantissa = val * Math.pow(2, -exponent);\r\n                    writeUint(mantissa * 4503599627370496 >>> 0, buf, pos + off0);\r\n                    writeUint((sign << 31 | exponent + 1023 << 20 | mantissa * 1048576 & 1048575) >>> 0, buf, pos + off1);\r\n                }\r\n            }\r\n        }\r\n\r\n        exports.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);\r\n        exports.writeDoubleBE = writeDouble_ieee754.bind(null, writeUintBE, 4, 0);\r\n\r\n        function readDouble_ieee754(readUint, off0, off1, buf, pos) {\r\n            var lo = readUint(buf, pos + off0),\r\n                hi = readUint(buf, pos + off1);\r\n            var sign = (hi >> 31) * 2 + 1,\r\n                exponent = hi >>> 20 & 2047,\r\n                mantissa = 4294967296 * (hi & 1048575) + lo;\r\n            return exponent === 2047\r\n                ? mantissa\r\n                ? NaN\r\n                : sign * Infinity\r\n                : exponent === 0 // denormal\r\n                ? sign * 5e-324 * mantissa\r\n                : sign * Math.pow(2, exponent - 1075) * (mantissa + 4503599627370496);\r\n        }\r\n\r\n        exports.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4);\r\n        exports.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 4, 0);\r\n\r\n    })();\r\n\r\n    return exports;\r\n}\r\n\r\n// uint helpers\r\n\r\nfunction writeUintLE(val, buf, pos) {\r\n    buf[pos    ] =  val        & 255;\r\n    buf[pos + 1] =  val >>> 8  & 255;\r\n    buf[pos + 2] =  val >>> 16 & 255;\r\n    buf[pos + 3] =  val >>> 24;\r\n}\r\n\r\nfunction writeUintBE(val, buf, pos) {\r\n    buf[pos    ] =  val >>> 24;\r\n    buf[pos + 1] =  val >>> 16 & 255;\r\n    buf[pos + 2] =  val >>> 8  & 255;\r\n    buf[pos + 3] =  val        & 255;\r\n}\r\n\r\nfunction readUintLE(buf, pos) {\r\n    return (buf[pos    ]\r\n          | buf[pos + 1] << 8\r\n          | buf[pos + 2] << 16\r\n          | buf[pos + 3] << 24) >>> 0;\r\n}\r\n\r\nfunction readUintBE(buf, pos) {\r\n    return (buf[pos    ] << 24\r\n          | buf[pos + 1] << 16\r\n          | buf[pos + 2] << 8\r\n          | buf[pos + 3]) >>> 0;\r\n}\r\n", "\"use strict\";\r\nmodule.exports = inquire;\r\n\r\n/**\r\n * Requires a module only if available.\r\n * @memberof util\r\n * @param {string} moduleName Module to require\r\n * @returns {?Object} Required module if available and not empty, otherwise `null`\r\n * @deprecated Legacy optional require helper. Will be removed in a future release.\r\n */\r\nfunction inquire(moduleName) {\r\n  try {\r\n    if (typeof require !== \"function\") {\r\n      return null;\r\n    }\r\n    var mod = require(moduleName);\r\n    if (mod && (mod.length || Object.keys(mod).length)) return mod;\r\n    return null;\r\n  } catch (err) {\r\n    // ignore\r\n    return null;\r\n  }\r\n}\r\n\r\n/*\r\n// maybe worth a shot to prevent renaming issues:\r\n// see: https://github.com/webpack/webpack/blob/master/lib/dependencies/CommonJsRequireDependencyParserPlugin.js\r\n// triggers on:\r\n// - expression require.cache\r\n// - expression require (???)\r\n// - call require\r\n// - call require:commonjs:item\r\n// - call require:commonjs:context\r\n\r\nObject.defineProperty(Function.prototype, \"__self\", { get: function() { return this; } });\r\nvar r = require.__self;\r\ndelete Function.prototype.__self;\r\n*/\r\n", "\"use strict\";\r\n\r\n/**\r\n * A minimal UTF8 implementation for number arrays.\r\n * @memberof util\r\n * @namespace\r\n */\r\nvar utf8 = exports,\r\n    replacementChar = \"\\ufffd\";\r\n\r\n/**\r\n * Calculates the UTF8 byte length of a string.\r\n * @param {string} string String\r\n * @returns {number} Byte length\r\n */\r\nutf8.length = function utf8_length(string) {\r\n    var len = 0,\r\n        c = 0;\r\n    for (var i = 0; i < string.length; ++i) {\r\n        c = string.charCodeAt(i);\r\n        if (c < 128)\r\n            len += 1;\r\n        else if (c < 2048)\r\n            len += 2;\r\n        else if ((c & 0xFC00) === 0xD800 && (string.charCodeAt(i + 1) & 0xFC00) === 0xDC00) {\r\n            ++i;\r\n            len += 4;\r\n        } else\r\n            len += 3;\r\n    }\r\n    return len;\r\n};\r\n\r\n/**\r\n * Reads UTF8 bytes as a string.\r\n * @param {Uint8Array} buffer Source buffer\r\n * @param {number} start Source start\r\n * @param {number} end Source end\r\n * @returns {string} String read\r\n */\r\nutf8.read = function utf8_read(buffer, start, end) {\r\n    if (end - start < 1) {\r\n        return \"\";\r\n    }\r\n\r\n    var str = \"\";\r\n    for (var i = start; i < end;) {\r\n        var t = buffer[i++];\r\n        if (t <= 0x7F) {\r\n            str += String.fromCharCode(t);\r\n        } else if (t >= 0xC0 && t < 0xE0) {\r\n            var c2 = (t & 0x1F) << 6 | buffer[i++] & 0x3F;\r\n            str += c2 >= 0x80 ? String.fromCharCode(c2) : replacementChar;\r\n        } else if (t >= 0xE0 && t < 0xF0) {\r\n            var c3 = (t & 0xF) << 12 | (buffer[i++] & 0x3F) << 6 | buffer[i++] & 0x3F;\r\n            str += c3 >= 0x800 ? String.fromCharCode(c3) : replacementChar;\r\n        } else if (t >= 0xF0) {\r\n            var t2 = (t & 7) << 18 | (buffer[i++] & 0x3F) << 12 | (buffer[i++] & 0x3F) << 6 | buffer[i++] & 0x3F;\r\n            if (t2 < 0x10000 || t2 > 0x10FFFF)\r\n                str += replacementChar;\r\n            else {\r\n                t2 -= 0x10000;\r\n                str += String.fromCharCode(0xD800 + (t2 >> 10));\r\n                str += String.fromCharCode(0xDC00 + (t2 & 0x3FF));\r\n            }\r\n        }\r\n    }\r\n\r\n    return str;\r\n};\r\n\r\n/**\r\n * Writes a string as UTF8 bytes.\r\n * @param {string} string Source string\r\n * @param {Uint8Array} buffer Destination buffer\r\n * @param {number} offset Destination offset\r\n * @returns {number} Bytes written\r\n */\r\nutf8.write = function utf8_write(string, buffer, offset) {\r\n    var start = offset,\r\n        c1, // character 1\r\n        c2; // character 2\r\n    for (var i = 0; i < string.length; ++i) {\r\n        c1 = string.charCodeAt(i);\r\n        if (c1 < 128) {\r\n            buffer[offset++] = c1;\r\n        } else if (c1 < 2048) {\r\n            buffer[offset++] = c1 >> 6       | 192;\r\n            buffer[offset++] = c1       & 63 | 128;\r\n        } else if ((c1 & 0xFC00) === 0xD800 && ((c2 = string.charCodeAt(i + 1)) & 0xFC00) === 0xDC00) {\r\n            c1 = 0x10000 + ((c1 & 0x03FF) << 10) + (c2 & 0x03FF);\r\n            ++i;\r\n            buffer[offset++] = c1 >> 18      | 240;\r\n            buffer[offset++] = c1 >> 12 & 63 | 128;\r\n            buffer[offset++] = c1 >> 6  & 63 | 128;\r\n            buffer[offset++] = c1       & 63 | 128;\r\n        } else {\r\n            buffer[offset++] = c1 >> 12      | 224;\r\n            buffer[offset++] = c1 >> 6  & 63 | 128;\r\n            buffer[offset++] = c1       & 63 | 128;\r\n        }\r\n    }\r\n    return offset - start;\r\n};\r\n", "\"use strict\";\r\nmodule.exports = pool;\r\n\r\n/**\r\n * An allocator as used by {@link util.pool}.\r\n * @typedef PoolAllocator\r\n * @type {function}\r\n * @param {number} size Buffer size\r\n * @returns {Uint8Array} Buffer\r\n */\r\n\r\n/**\r\n * A slicer as used by {@link util.pool}.\r\n * @typedef PoolSlicer\r\n * @type {function}\r\n * @param {number} start Start offset\r\n * @param {number} end End offset\r\n * @returns {Uint8Array} Buffer slice\r\n * @this {Uint8Array}\r\n */\r\n\r\n/**\r\n * A general purpose buffer pool.\r\n * @memberof util\r\n * @function\r\n * @param {PoolAllocator} alloc Allocator\r\n * @param {PoolSlicer} slice Slicer\r\n * @param {number} [size=8192] Slab size\r\n * @returns {PoolAllocator} Pooled allocator\r\n */\r\nfunction pool(alloc, slice, size) {\r\n    var SIZE   = size || 8192;\r\n    var MAX    = SIZE >>> 1;\r\n    var slab   = null;\r\n    var offset = SIZE;\r\n    return function pool_alloc(size) {\r\n        if (size < 1 || size > MAX)\r\n            return alloc(size);\r\n        if (offset + size > SIZE) {\r\n            slab = alloc(SIZE);\r\n            offset = 0;\r\n        }\r\n        var buf = slice.call(slab, offset, offset += size);\r\n        if (offset & 7) // align to 32 bit\r\n            offset = (offset | 7) + 1;\r\n        return buf;\r\n    };\r\n}\r\n", "\"use strict\";\nmodule.exports = LongBits;\n\nvar util = require(\"../util/minimal\");\n\n/**\n * Constructs new long bits.\n * @classdesc Helper class for working with the low and high bits of a 64 bit value.\n * @memberof util\n * @constructor\n * @param {number} lo Low 32 bits, unsigned\n * @param {number} hi High 32 bits, unsigned\n */\nfunction LongBits(lo, hi) {\n\n    // note that the casts below are theoretically unnecessary as of today, but older statically\n    // generated converter code might still call the ctor with signed 32bits. kept for compat.\n\n    /**\n     * Low bits.\n     * @type {number}\n     */\n    this.lo = lo >>> 0;\n\n    /**\n     * High bits.\n     * @type {number}\n     */\n    this.hi = hi >>> 0;\n}\n\n/**\n * Zero bits.\n * @memberof util.LongBits\n * @type {util.LongBits}\n */\nvar zero = LongBits.zero = new LongBits(0, 0);\n\nzero.toNumber = function() { return 0; };\nzero.zzEncode = zero.zzDecode = function() { return this; };\nzero.length = function() { return 1; };\n\n/**\n * Zero hash.\n * @memberof util.LongBits\n * @type {string}\n */\nvar zeroHash = LongBits.zeroHash = \"\\0\\0\\0\\0\\0\\0\\0\\0\";\n\n/**\n * Constructs new long bits from the specified number.\n * @param {number} value Value\n * @returns {util.LongBits} Instance\n */\nLongBits.fromNumber = function fromNumber(value) {\n    if (value === 0)\n        return zero;\n    var sign = value < 0;\n    if (sign)\n        value = -value;\n    var lo = value >>> 0,\n        hi = (value - lo) / 4294967296 >>> 0;\n    if (sign) {\n        hi = ~hi >>> 0;\n        lo = ~lo >>> 0;\n        if (++lo > 4294967295) {\n            lo = 0;\n            if (++hi > 4294967295)\n                hi = 0;\n        }\n    }\n    return new LongBits(lo, hi);\n};\n\n/**\n * Constructs new long bits from a number, long or string.\n * @param {Long|number|string} value Value\n * @returns {util.LongBits} Instance\n */\nLongBits.from = function from(value) {\n    if (typeof value === \"number\")\n        return LongBits.fromNumber(value);\n    if (util.isString(value)) {\n        /* istanbul ignore else */\n        if (util.Long)\n            value = util.Long.fromString(value);\n        else\n            return LongBits.fromNumber(parseInt(value, 10));\n    }\n    return value.low || value.high ? new LongBits(value.low >>> 0, value.high >>> 0) : zero;\n};\n\n/**\n * Converts this long bits to a possibly unsafe JavaScript number.\n * @param {boolean} [unsigned=false] Whether unsigned or not\n * @returns {number} Possibly unsafe number\n */\nLongBits.prototype.toNumber = function toNumber(unsigned) {\n    if (!unsigned && this.hi >>> 31) {\n        var lo = ~this.lo + 1 >>> 0,\n            hi = ~this.hi     >>> 0;\n        if (!lo)\n            hi = hi + 1 >>> 0;\n        return -(lo + hi * 4294967296);\n    }\n    return this.lo + this.hi * 4294967296;\n};\n\n/**\n * Converts this long bits to a long.\n * @param {boolean} [unsigned=false] Whether unsigned or not\n * @returns {Long} Long\n */\nLongBits.prototype.toLong = function toLong(unsigned) {\n    return util.Long\n        ? new util.Long(this.lo | 0, this.hi | 0, Boolean(unsigned))\n        /* istanbul ignore next */\n        : { low: this.lo | 0, high: this.hi | 0, unsigned: Boolean(unsigned) };\n};\n\nvar charCodeAt = String.prototype.charCodeAt;\n\n/**\n * Constructs new long bits from the specified 8 characters long hash.\n * @param {string} hash Hash\n * @returns {util.LongBits} Bits\n */\nLongBits.fromHash = function fromHash(hash) {\n    if (hash === zeroHash)\n        return zero;\n    return new LongBits(\n        ( charCodeAt.call(hash, 0)\n        | charCodeAt.call(hash, 1) << 8\n        | charCodeAt.call(hash, 2) << 16\n        | charCodeAt.call(hash, 3) << 24) >>> 0\n    ,\n        ( charCodeAt.call(hash, 4)\n        | charCodeAt.call(hash, 5) << 8\n        | charCodeAt.call(hash, 6) << 16\n        | charCodeAt.call(hash, 7) << 24) >>> 0\n    );\n};\n\n/**\n * Converts this long bits to a 8 characters long hash.\n * @returns {string} Hash\n */\nLongBits.prototype.toHash = function toHash() {\n    return String.fromCharCode(\n        this.lo        & 255,\n        this.lo >>> 8  & 255,\n        this.lo >>> 16 & 255,\n        this.lo >>> 24      ,\n        this.hi        & 255,\n        this.hi >>> 8  & 255,\n        this.hi >>> 16 & 255,\n        this.hi >>> 24\n    );\n};\n\n/**\n * Zig-zag encodes this long bits.\n * @returns {util.LongBits} `this`\n */\nLongBits.prototype.zzEncode = function zzEncode() {\n    var mask =   this.hi >> 31;\n    this.hi  = ((this.hi << 1 | this.lo >>> 31) ^ mask) >>> 0;\n    this.lo  = ( this.lo << 1                   ^ mask) >>> 0;\n    return this;\n};\n\n/**\n * Zig-zag decodes this long bits.\n * @returns {util.LongBits} `this`\n */\nLongBits.prototype.zzDecode = function zzDecode() {\n    var mask = -(this.lo & 1);\n    this.lo  = ((this.lo >>> 1 | this.hi << 31) ^ mask) >>> 0;\n    this.hi  = ( this.hi >>> 1                  ^ mask) >>> 0;\n    return this;\n};\n\n/**\n * Calculates the length of this longbits when encoded as a varint.\n * @returns {number} Length\n */\nLongBits.prototype.length = function length() {\n    var part0 =  this.lo,\n        part1 = (this.lo >>> 28 | this.hi << 4) >>> 0,\n        part2 =  this.hi >>> 24;\n    return part2 === 0\n         ? part1 === 0\n           ? part0 < 16384\n             ? part0 < 128 ? 1 : 2\n             : part0 < 2097152 ? 3 : 4\n           : part1 < 16384\n             ? part1 < 128 ? 5 : 6\n             : part1 < 2097152 ? 7 : 8\n         : part2 < 128 ? 9 : 10;\n};\n", "// GENERATED FILE. DO NOT EDIT.\n(function (global, factory) {\n  function preferDefault(exports) {\n    return exports.default || exports;\n  }\n  if (typeof define === \"function\" && define.amd) {\n    define([], function () {\n      var exports = {};\n      factory(exports);\n      return preferDefault(exports);\n    });\n  } else if (typeof exports === \"object\") {\n    factory(exports);\n    if (typeof module === \"object\") module.exports = preferDefault(exports);\n  } else {\n    (function () {\n      var exports = {};\n      factory(exports);\n      global.Long = preferDefault(exports);\n    })();\n  }\n})(\n  typeof globalThis !== \"undefined\"\n    ? globalThis\n    : typeof self !== \"undefined\"\n      ? self\n      : this,\n  function (_exports) {\n    \"use strict\";\n\n    Object.defineProperty(_exports, \"__esModule\", {\n      value: true,\n    });\n    _exports.default = void 0;\n    /**\n     * @license\n     * Copyright 2009 The Closure Library Authors\n     * Copyright 2020 Daniel Wirtz / The long.js Authors.\n     *\n     * Licensed under the Apache License, Version 2.0 (the \"License\");\n     * you may not use this file except in compliance with the License.\n     * You may obtain a copy of the License at\n     *\n     *     http://www.apache.org/licenses/LICENSE-2.0\n     *\n     * Unless required by applicable law or agreed to in writing, software\n     * distributed under the License is distributed on an \"AS IS\" BASIS,\n     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n     * See the License for the specific language governing permissions and\n     * limitations under the License.\n     *\n     * SPDX-License-Identifier: Apache-2.0\n     */\n\n    // WebAssembly optimizations to do native i64 multiplication and divide\n    var wasm = null;\n    try {\n      wasm = new WebAssembly.Instance(\n        new WebAssembly.Module(\n          new Uint8Array([\n            // \\0asm\n            0, 97, 115, 109,\n            // version 1\n            1, 0, 0, 0,\n            // section \"type\"\n            1, 13, 2,\n            // 0, () => i32\n            96, 0, 1, 127,\n            // 1, (i32, i32, i32, i32) => i32\n            96, 4, 127, 127, 127, 127, 1, 127,\n            // section \"function\"\n            3, 7, 6,\n            // 0, type 0\n            0,\n            // 1, type 1\n            1,\n            // 2, type 1\n            1,\n            // 3, type 1\n            1,\n            // 4, type 1\n            1,\n            // 5, type 1\n            1,\n            // section \"global\"\n            6, 6, 1,\n            // 0, \"high\", mutable i32\n            127, 1, 65, 0, 11,\n            // section \"export\"\n            7, 50, 6,\n            // 0, \"mul\"\n            3, 109, 117, 108, 0, 1,\n            // 1, \"div_s\"\n            5, 100, 105, 118, 95, 115, 0, 2,\n            // 2, \"div_u\"\n            5, 100, 105, 118, 95, 117, 0, 3,\n            // 3, \"rem_s\"\n            5, 114, 101, 109, 95, 115, 0, 4,\n            // 4, \"rem_u\"\n            5, 114, 101, 109, 95, 117, 0, 5,\n            // 5, \"get_high\"\n            8, 103, 101, 116, 95, 104, 105, 103, 104, 0, 0,\n            // section \"code\"\n            10, 191, 1, 6,\n            // 0, \"get_high\"\n            4, 0, 35, 0, 11,\n            // 1, \"mul\"\n            36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173,\n            32, 3, 173, 66, 32, 134, 132, 126, 34, 4, 66, 32, 135, 167, 36, 0,\n            32, 4, 167, 11,\n            // 2, \"div_s\"\n            36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173,\n            32, 3, 173, 66, 32, 134, 132, 127, 34, 4, 66, 32, 135, 167, 36, 0,\n            32, 4, 167, 11,\n            // 3, \"div_u\"\n            36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173,\n            32, 3, 173, 66, 32, 134, 132, 128, 34, 4, 66, 32, 135, 167, 36, 0,\n            32, 4, 167, 11,\n            // 4, \"rem_s\"\n            36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173,\n            32, 3, 173, 66, 32, 134, 132, 129, 34, 4, 66, 32, 135, 167, 36, 0,\n            32, 4, 167, 11,\n            // 5, \"rem_u\"\n            36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173,\n            32, 3, 173, 66, 32, 134, 132, 130, 34, 4, 66, 32, 135, 167, 36, 0,\n            32, 4, 167, 11,\n          ]),\n        ),\n        {},\n      ).exports;\n    } catch {\n      // no wasm support :(\n    }\n\n    /**\n     * Constructs a 64 bit two's-complement integer, given its low and high 32 bit values as *signed* integers.\n     *  See the from* functions below for more convenient ways of constructing Longs.\n     * @exports Long\n     * @class A Long class for representing a 64 bit two's-complement integer value.\n     * @param {number} low The low (signed) 32 bits of the long\n     * @param {number} high The high (signed) 32 bits of the long\n     * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n     * @constructor\n     */\n    function Long(low, high, unsigned) {\n      /**\n       * The low 32 bits as a signed value.\n       * @type {number}\n       */\n      this.low = low | 0;\n\n      /**\n       * The high 32 bits as a signed value.\n       * @type {number}\n       */\n      this.high = high | 0;\n\n      /**\n       * Whether unsigned or not.\n       * @type {boolean}\n       */\n      this.unsigned = !!unsigned;\n    }\n\n    // The internal representation of a long is the two given signed, 32-bit values.\n    // We use 32-bit pieces because these are the size of integers on which\n    // Javascript performs bit-operations.  For operations like addition and\n    // multiplication, we split each number into 16 bit pieces, which can easily be\n    // multiplied within Javascript's floating-point representation without overflow\n    // or change in sign.\n    //\n    // In the algorithms below, we frequently reduce the negative case to the\n    // positive case by negating the input(s) and then post-processing the result.\n    // Note that we must ALWAYS check specially whether those values are MIN_VALUE\n    // (-2^63) because -MIN_VALUE == MIN_VALUE (since 2^63 cannot be represented as\n    // a positive number, it overflows back into a negative).  Not handling this\n    // case would often result in infinite recursion.\n    //\n    // Common constant values ZERO, ONE, NEG_ONE, etc. are defined below the from*\n    // methods on which they depend.\n\n    /**\n     * An indicator used to reliably determine if an object is a Long or not.\n     * @type {boolean}\n     * @const\n     * @private\n     */\n    Long.prototype.__isLong__;\n    Object.defineProperty(Long.prototype, \"__isLong__\", {\n      value: true,\n    });\n\n    /**\n     * @function\n     * @param {*} obj Object\n     * @returns {boolean}\n     * @inner\n     */\n    function isLong(obj) {\n      return (obj && obj[\"__isLong__\"]) === true;\n    }\n\n    /**\n     * @function\n     * @param {*} value number\n     * @returns {number}\n     * @inner\n     */\n    function ctz32(value) {\n      var c = Math.clz32(value & -value);\n      return value ? 31 - c : c;\n    }\n\n    /**\n     * Tests if the specified object is a Long.\n     * @function\n     * @param {*} obj Object\n     * @returns {boolean}\n     */\n    Long.isLong = isLong;\n\n    /**\n     * A cache of the Long representations of small integer values.\n     * @type {!Object}\n     * @inner\n     */\n    var INT_CACHE = {};\n\n    /**\n     * A cache of the Long representations of small unsigned integer values.\n     * @type {!Object}\n     * @inner\n     */\n    var UINT_CACHE = {};\n\n    /**\n     * @param {number} value\n     * @param {boolean=} unsigned\n     * @returns {!Long}\n     * @inner\n     */\n    function fromInt(value, unsigned) {\n      var obj, cachedObj, cache;\n      if (unsigned) {\n        value >>>= 0;\n        if ((cache = 0 <= value && value < 256)) {\n          cachedObj = UINT_CACHE[value];\n          if (cachedObj) return cachedObj;\n        }\n        obj = fromBits(value, 0, true);\n        if (cache) UINT_CACHE[value] = obj;\n        return obj;\n      } else {\n        value |= 0;\n        if ((cache = -128 <= value && value < 128)) {\n          cachedObj = INT_CACHE[value];\n          if (cachedObj) return cachedObj;\n        }\n        obj = fromBits(value, value < 0 ? -1 : 0, false);\n        if (cache) INT_CACHE[value] = obj;\n        return obj;\n      }\n    }\n\n    /**\n     * Returns a Long representing the given 32 bit integer value.\n     * @function\n     * @param {number} value The 32 bit integer in question\n     * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n     * @returns {!Long} The corresponding Long value\n     */\n    Long.fromInt = fromInt;\n\n    /**\n     * @param {number} value\n     * @param {boolean=} unsigned\n     * @returns {!Long}\n     * @inner\n     */\n    function fromNumber(value, unsigned) {\n      if (isNaN(value)) return unsigned ? UZERO : ZERO;\n      if (unsigned) {\n        if (value < 0) return UZERO;\n        if (value >= TWO_PWR_64_DBL) return MAX_UNSIGNED_VALUE;\n      } else {\n        if (value <= -TWO_PWR_63_DBL) return MIN_VALUE;\n        if (value + 1 >= TWO_PWR_63_DBL) return MAX_VALUE;\n      }\n      if (value < 0) return fromNumber(-value, unsigned).neg();\n      return fromBits(\n        value % TWO_PWR_32_DBL | 0,\n        (value / TWO_PWR_32_DBL) | 0,\n        unsigned,\n      );\n    }\n\n    /**\n     * Returns a Long representing the given value, provided that it is a finite number. Otherwise, zero is returned.\n     * @function\n     * @param {number} value The number in question\n     * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n     * @returns {!Long} The corresponding Long value\n     */\n    Long.fromNumber = fromNumber;\n\n    /**\n     * @param {number} lowBits\n     * @param {number} highBits\n     * @param {boolean=} unsigned\n     * @returns {!Long}\n     * @inner\n     */\n    function fromBits(lowBits, highBits, unsigned) {\n      return new Long(lowBits, highBits, unsigned);\n    }\n\n    /**\n     * Returns a Long representing the 64 bit integer that comes by concatenating the given low and high bits. Each is\n     *  assumed to use 32 bits.\n     * @function\n     * @param {number} lowBits The low 32 bits\n     * @param {number} highBits The high 32 bits\n     * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n     * @returns {!Long} The corresponding Long value\n     */\n    Long.fromBits = fromBits;\n\n    /**\n     * @function\n     * @param {number} base\n     * @param {number} exponent\n     * @returns {number}\n     * @inner\n     */\n    var pow_dbl = Math.pow; // Used 4 times (4*8 to 15+4)\n\n    /**\n     * @param {string} str\n     * @param {(boolean|number)=} unsigned\n     * @param {number=} radix\n     * @returns {!Long}\n     * @inner\n     */\n    function fromString(str, unsigned, radix) {\n      if (str.length === 0) throw Error(\"empty string\");\n      if (typeof unsigned === \"number\") {\n        // For goog.math.long compatibility\n        radix = unsigned;\n        unsigned = false;\n      } else {\n        unsigned = !!unsigned;\n      }\n      if (\n        str === \"NaN\" ||\n        str === \"Infinity\" ||\n        str === \"+Infinity\" ||\n        str === \"-Infinity\"\n      )\n        return unsigned ? UZERO : ZERO;\n      radix = radix || 10;\n      if (radix < 2 || 36 < radix) throw RangeError(\"radix\");\n      var p;\n      if ((p = str.indexOf(\"-\")) > 0) throw Error(\"interior hyphen\");\n      else if (p === 0) {\n        return fromString(str.substring(1), unsigned, radix).neg();\n      }\n\n      // Do several (8) digits each time through the loop, so as to\n      // minimize the calls to the very expensive emulated div.\n      var radixToPower = fromNumber(pow_dbl(radix, 8));\n      var result = ZERO;\n      for (var i = 0; i < str.length; i += 8) {\n        var size = Math.min(8, str.length - i),\n          value = parseInt(str.substring(i, i + size), radix);\n        if (size < 8) {\n          var power = fromNumber(pow_dbl(radix, size));\n          result = result.mul(power).add(fromNumber(value));\n        } else {\n          result = result.mul(radixToPower);\n          result = result.add(fromNumber(value));\n        }\n      }\n      result.unsigned = unsigned;\n      return result;\n    }\n\n    /**\n     * Returns a Long representation of the given string, written using the specified radix.\n     * @function\n     * @param {string} str The textual representation of the Long\n     * @param {(boolean|number)=} unsigned Whether unsigned or not, defaults to signed\n     * @param {number=} radix The radix in which the text is written (2-36), defaults to 10\n     * @returns {!Long} The corresponding Long value\n     */\n    Long.fromString = fromString;\n\n    /**\n     * @function\n     * @param {!Long|number|string|!{low: number, high: number, unsigned: boolean}} val\n     * @param {boolean=} unsigned\n     * @returns {!Long}\n     * @inner\n     */\n    function fromValue(val, unsigned) {\n      if (typeof val === \"number\") return fromNumber(val, unsigned);\n      if (typeof val === \"string\") return fromString(val, unsigned);\n      // Throws for non-objects, converts non-instanceof Long:\n      return fromBits(\n        val.low,\n        val.high,\n        typeof unsigned === \"boolean\" ? unsigned : val.unsigned,\n      );\n    }\n\n    /**\n     * Converts the specified value to a Long using the appropriate from* function for its type.\n     * @function\n     * @param {!Long|number|bigint|string|!{low: number, high: number, unsigned: boolean}} val Value\n     * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n     * @returns {!Long}\n     */\n    Long.fromValue = fromValue;\n\n    // NOTE: the compiler should inline these constant values below and then remove these variables, so there should be\n    // no runtime penalty for these.\n\n    /**\n     * @type {number}\n     * @const\n     * @inner\n     */\n    var TWO_PWR_16_DBL = 1 << 16;\n\n    /**\n     * @type {number}\n     * @const\n     * @inner\n     */\n    var TWO_PWR_24_DBL = 1 << 24;\n\n    /**\n     * @type {number}\n     * @const\n     * @inner\n     */\n    var TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL;\n\n    /**\n     * @type {number}\n     * @const\n     * @inner\n     */\n    var TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL;\n\n    /**\n     * @type {number}\n     * @const\n     * @inner\n     */\n    var TWO_PWR_63_DBL = TWO_PWR_64_DBL / 2;\n\n    /**\n     * @type {!Long}\n     * @const\n     * @inner\n     */\n    var TWO_PWR_24 = fromInt(TWO_PWR_24_DBL);\n\n    /**\n     * @type {!Long}\n     * @inner\n     */\n    var ZERO = fromInt(0);\n\n    /**\n     * Signed zero.\n     * @type {!Long}\n     */\n    Long.ZERO = ZERO;\n\n    /**\n     * @type {!Long}\n     * @inner\n     */\n    var UZERO = fromInt(0, true);\n\n    /**\n     * Unsigned zero.\n     * @type {!Long}\n     */\n    Long.UZERO = UZERO;\n\n    /**\n     * @type {!Long}\n     * @inner\n     */\n    var ONE = fromInt(1);\n\n    /**\n     * Signed one.\n     * @type {!Long}\n     */\n    Long.ONE = ONE;\n\n    /**\n     * @type {!Long}\n     * @inner\n     */\n    var UONE = fromInt(1, true);\n\n    /**\n     * Unsigned one.\n     * @type {!Long}\n     */\n    Long.UONE = UONE;\n\n    /**\n     * @type {!Long}\n     * @inner\n     */\n    var NEG_ONE = fromInt(-1);\n\n    /**\n     * Signed negative one.\n     * @type {!Long}\n     */\n    Long.NEG_ONE = NEG_ONE;\n\n    /**\n     * @type {!Long}\n     * @inner\n     */\n    var MAX_VALUE = fromBits(0xffffffff | 0, 0x7fffffff | 0, false);\n\n    /**\n     * Maximum signed value.\n     * @type {!Long}\n     */\n    Long.MAX_VALUE = MAX_VALUE;\n\n    /**\n     * @type {!Long}\n     * @inner\n     */\n    var MAX_UNSIGNED_VALUE = fromBits(0xffffffff | 0, 0xffffffff | 0, true);\n\n    /**\n     * Maximum unsigned value.\n     * @type {!Long}\n     */\n    Long.MAX_UNSIGNED_VALUE = MAX_UNSIGNED_VALUE;\n\n    /**\n     * @type {!Long}\n     * @inner\n     */\n    var MIN_VALUE = fromBits(0, 0x80000000 | 0, false);\n\n    /**\n     * Minimum signed value.\n     * @type {!Long}\n     */\n    Long.MIN_VALUE = MIN_VALUE;\n\n    /**\n     * @alias Long.prototype\n     * @inner\n     */\n    var LongPrototype = Long.prototype;\n\n    /**\n     * Converts the Long to a 32 bit integer, assuming it is a 32 bit integer.\n     * @this {!Long}\n     * @returns {number}\n     */\n    LongPrototype.toInt = function toInt() {\n      return this.unsigned ? this.low >>> 0 : this.low;\n    };\n\n    /**\n     * Converts the Long to a the nearest floating-point representation of this value (double, 53 bit mantissa).\n     * @this {!Long}\n     * @returns {number}\n     */\n    LongPrototype.toNumber = function toNumber() {\n      if (this.unsigned)\n        return (this.high >>> 0) * TWO_PWR_32_DBL + (this.low >>> 0);\n      return this.high * TWO_PWR_32_DBL + (this.low >>> 0);\n    };\n\n    /**\n     * Converts the Long to a string written in the specified radix.\n     * @this {!Long}\n     * @param {number=} radix Radix (2-36), defaults to 10\n     * @returns {string}\n     * @override\n     * @throws {RangeError} If `radix` is out of range\n     */\n    LongPrototype.toString = function toString(radix) {\n      radix = radix || 10;\n      if (radix < 2 || 36 < radix) throw RangeError(\"radix\");\n      if (this.isZero()) return \"0\";\n      if (this.isNegative()) {\n        // Unsigned Longs are never negative\n        if (this.eq(MIN_VALUE)) {\n          // We need to change the Long value before it can be negated, so we remove\n          // the bottom-most digit in this base and then recurse to do the rest.\n          var radixLong = fromNumber(radix),\n            div = this.div(radixLong),\n            rem1 = div.mul(radixLong).sub(this);\n          return div.toString(radix) + rem1.toInt().toString(radix);\n        } else return \"-\" + this.neg().toString(radix);\n      }\n\n      // Do several (6) digits each time through the loop, so as to\n      // minimize the calls to the very expensive emulated div.\n      var radixToPower = fromNumber(pow_dbl(radix, 6), this.unsigned),\n        rem = this;\n      var result = \"\";\n      while (true) {\n        var remDiv = rem.div(radixToPower),\n          intval = rem.sub(remDiv.mul(radixToPower)).toInt() >>> 0,\n          digits = intval.toString(radix);\n        rem = remDiv;\n        if (rem.isZero()) return digits + result;\n        else {\n          while (digits.length < 6) digits = \"0\" + digits;\n          result = \"\" + digits + result;\n        }\n      }\n    };\n\n    /**\n     * Gets the high 32 bits as a signed integer.\n     * @this {!Long}\n     * @returns {number} Signed high bits\n     */\n    LongPrototype.getHighBits = function getHighBits() {\n      return this.high;\n    };\n\n    /**\n     * Gets the high 32 bits as an unsigned integer.\n     * @this {!Long}\n     * @returns {number} Unsigned high bits\n     */\n    LongPrototype.getHighBitsUnsigned = function getHighBitsUnsigned() {\n      return this.high >>> 0;\n    };\n\n    /**\n     * Gets the low 32 bits as a signed integer.\n     * @this {!Long}\n     * @returns {number} Signed low bits\n     */\n    LongPrototype.getLowBits = function getLowBits() {\n      return this.low;\n    };\n\n    /**\n     * Gets the low 32 bits as an unsigned integer.\n     * @this {!Long}\n     * @returns {number} Unsigned low bits\n     */\n    LongPrototype.getLowBitsUnsigned = function getLowBitsUnsigned() {\n      return this.low >>> 0;\n    };\n\n    /**\n     * Gets the number of bits needed to represent the absolute value of this Long.\n     * @this {!Long}\n     * @returns {number}\n     */\n    LongPrototype.getNumBitsAbs = function getNumBitsAbs() {\n      if (this.isNegative())\n        // Unsigned Longs are never negative\n        return this.eq(MIN_VALUE) ? 64 : this.neg().getNumBitsAbs();\n      var val = this.high != 0 ? this.high : this.low;\n      for (var bit = 31; bit > 0; bit--) if ((val & (1 << bit)) != 0) break;\n      return this.high != 0 ? bit + 33 : bit + 1;\n    };\n\n    /**\n     * Tests if this Long can be safely represented as a JavaScript number.\n     * @this {!Long}\n     * @returns {boolean}\n     */\n    LongPrototype.isSafeInteger = function isSafeInteger() {\n      // 2^53-1 is the maximum safe value\n      var top11Bits = this.high >> 21;\n      // [0, 2^53-1]\n      if (!top11Bits) return true;\n      // > 2^53-1\n      if (this.unsigned) return false;\n      // [-2^53, -1] except -2^53\n      return top11Bits === -1 && !(this.low === 0 && this.high === -0x200000);\n    };\n\n    /**\n     * Tests if this Long's value equals zero.\n     * @this {!Long}\n     * @returns {boolean}\n     */\n    LongPrototype.isZero = function isZero() {\n      return this.high === 0 && this.low === 0;\n    };\n\n    /**\n     * Tests if this Long's value equals zero. This is an alias of {@link Long#isZero}.\n     * @returns {boolean}\n     */\n    LongPrototype.eqz = LongPrototype.isZero;\n\n    /**\n     * Tests if this Long's value is negative.\n     * @this {!Long}\n     * @returns {boolean}\n     */\n    LongPrototype.isNegative = function isNegative() {\n      return !this.unsigned && this.high < 0;\n    };\n\n    /**\n     * Tests if this Long's value is positive or zero.\n     * @this {!Long}\n     * @returns {boolean}\n     */\n    LongPrototype.isPositive = function isPositive() {\n      return this.unsigned || this.high >= 0;\n    };\n\n    /**\n     * Tests if this Long's value is odd.\n     * @this {!Long}\n     * @returns {boolean}\n     */\n    LongPrototype.isOdd = function isOdd() {\n      return (this.low & 1) === 1;\n    };\n\n    /**\n     * Tests if this Long's value is even.\n     * @this {!Long}\n     * @returns {boolean}\n     */\n    LongPrototype.isEven = function isEven() {\n      return (this.low & 1) === 0;\n    };\n\n    /**\n     * Tests if this Long's value equals the specified's.\n     * @this {!Long}\n     * @param {!Long|number|bigint|string} other Other value\n     * @returns {boolean}\n     */\n    LongPrototype.equals = function equals(other) {\n      if (!isLong(other)) other = fromValue(other);\n      if (\n        this.unsigned !== other.unsigned &&\n        this.high >>> 31 === 1 &&\n        other.high >>> 31 === 1\n      )\n        return false;\n      return this.high === other.high && this.low === other.low;\n    };\n\n    /**\n     * Tests if this Long's value equals the specified's. This is an alias of {@link Long#equals}.\n     * @function\n     * @param {!Long|number|bigint|string} other Other value\n     * @returns {boolean}\n     */\n    LongPrototype.eq = LongPrototype.equals;\n\n    /**\n     * Tests if this Long's value differs from the specified's.\n     * @this {!Long}\n     * @param {!Long|number|bigint|string} other Other value\n     * @returns {boolean}\n     */\n    LongPrototype.notEquals = function notEquals(other) {\n      return !this.eq(/* validates */ other);\n    };\n\n    /**\n     * Tests if this Long's value differs from the specified's. This is an alias of {@link Long#notEquals}.\n     * @function\n     * @param {!Long|number|bigint|string} other Other value\n     * @returns {boolean}\n     */\n    LongPrototype.neq = LongPrototype.notEquals;\n\n    /**\n     * Tests if this Long's value differs from the specified's. This is an alias of {@link Long#notEquals}.\n     * @function\n     * @param {!Long|number|bigint|string} other Other value\n     * @returns {boolean}\n     */\n    LongPrototype.ne = LongPrototype.notEquals;\n\n    /**\n     * Tests if this Long's value is less than the specified's.\n     * @this {!Long}\n     * @param {!Long|number|bigint|string} other Other value\n     * @returns {boolean}\n     */\n    LongPrototype.lessThan = function lessThan(other) {\n      return this.comp(/* validates */ other) < 0;\n    };\n\n    /**\n     * Tests if this Long's value is less than the specified's. This is an alias of {@link Long#lessThan}.\n     * @function\n     * @param {!Long|number|bigint|string} other Other value\n     * @returns {boolean}\n     */\n    LongPrototype.lt = LongPrototype.lessThan;\n\n    /**\n     * Tests if this Long's value is less than or equal the specified's.\n     * @this {!Long}\n     * @param {!Long|number|bigint|string} other Other value\n     * @returns {boolean}\n     */\n    LongPrototype.lessThanOrEqual = function lessThanOrEqual(other) {\n      return this.comp(/* validates */ other) <= 0;\n    };\n\n    /**\n     * Tests if this Long's value is less than or equal the specified's. This is an alias of {@link Long#lessThanOrEqual}.\n     * @function\n     * @param {!Long|number|bigint|string} other Other value\n     * @returns {boolean}\n     */\n    LongPrototype.lte = LongPrototype.lessThanOrEqual;\n\n    /**\n     * Tests if this Long's value is less than or equal the specified's. This is an alias of {@link Long#lessThanOrEqual}.\n     * @function\n     * @param {!Long|number|bigint|string} other Other value\n     * @returns {boolean}\n     */\n    LongPrototype.le = LongPrototype.lessThanOrEqual;\n\n    /**\n     * Tests if this Long's value is greater than the specified's.\n     * @this {!Long}\n     * @param {!Long|number|bigint|string} other Other value\n     * @returns {boolean}\n     */\n    LongPrototype.greaterThan = function greaterThan(other) {\n      return this.comp(/* validates */ other) > 0;\n    };\n\n    /**\n     * Tests if this Long's value is greater than the specified's. This is an alias of {@link Long#greaterThan}.\n     * @function\n     * @param {!Long|number|bigint|string} other Other value\n     * @returns {boolean}\n     */\n    LongPrototype.gt = LongPrototype.greaterThan;\n\n    /**\n     * Tests if this Long's value is greater than or equal the specified's.\n     * @this {!Long}\n     * @param {!Long|number|bigint|string} other Other value\n     * @returns {boolean}\n     */\n    LongPrototype.greaterThanOrEqual = function greaterThanOrEqual(other) {\n      return this.comp(/* validates */ other) >= 0;\n    };\n\n    /**\n     * Tests if this Long's value is greater than or equal the specified's. This is an alias of {@link Long#greaterThanOrEqual}.\n     * @function\n     * @param {!Long|number|bigint|string} other Other value\n     * @returns {boolean}\n     */\n    LongPrototype.gte = LongPrototype.greaterThanOrEqual;\n\n    /**\n     * Tests if this Long's value is greater than or equal the specified's. This is an alias of {@link Long#greaterThanOrEqual}.\n     * @function\n     * @param {!Long|number|bigint|string} other Other value\n     * @returns {boolean}\n     */\n    LongPrototype.ge = LongPrototype.greaterThanOrEqual;\n\n    /**\n     * Compares this Long's value with the specified's.\n     * @this {!Long}\n     * @param {!Long|number|bigint|string} other Other value\n     * @returns {number} 0 if they are the same, 1 if the this is greater and -1\n     *  if the given one is greater\n     */\n    LongPrototype.compare = function compare(other) {\n      if (!isLong(other)) other = fromValue(other);\n      if (this.eq(other)) return 0;\n      var thisNeg = this.isNegative(),\n        otherNeg = other.isNegative();\n      if (thisNeg && !otherNeg) return -1;\n      if (!thisNeg && otherNeg) return 1;\n      // At this point the sign bits are the same\n      if (!this.unsigned) return this.sub(other).isNegative() ? -1 : 1;\n      // Both are positive if at least one is unsigned\n      return other.high >>> 0 > this.high >>> 0 ||\n        (other.high === this.high && other.low >>> 0 > this.low >>> 0)\n        ? -1\n        : 1;\n    };\n\n    /**\n     * Compares this Long's value with the specified's. This is an alias of {@link Long#compare}.\n     * @function\n     * @param {!Long|number|bigint|string} other Other value\n     * @returns {number} 0 if they are the same, 1 if the this is greater and -1\n     *  if the given one is greater\n     */\n    LongPrototype.comp = LongPrototype.compare;\n\n    /**\n     * Negates this Long's value.\n     * @this {!Long}\n     * @returns {!Long} Negated Long\n     */\n    LongPrototype.negate = function negate() {\n      if (!this.unsigned && this.eq(MIN_VALUE)) return MIN_VALUE;\n      return this.not().add(ONE);\n    };\n\n    /**\n     * Negates this Long's value. This is an alias of {@link Long#negate}.\n     * @function\n     * @returns {!Long} Negated Long\n     */\n    LongPrototype.neg = LongPrototype.negate;\n\n    /**\n     * Returns the sum of this and the specified Long.\n     * @this {!Long}\n     * @param {!Long|number|bigint|string} addend Addend\n     * @returns {!Long} Sum\n     */\n    LongPrototype.add = function add(addend) {\n      if (!isLong(addend)) addend = fromValue(addend);\n\n      // Divide each number into 4 chunks of 16 bits, and then sum the chunks.\n\n      var a48 = this.high >>> 16;\n      var a32 = this.high & 0xffff;\n      var a16 = this.low >>> 16;\n      var a00 = this.low & 0xffff;\n      var b48 = addend.high >>> 16;\n      var b32 = addend.high & 0xffff;\n      var b16 = addend.low >>> 16;\n      var b00 = addend.low & 0xffff;\n      var c48 = 0,\n        c32 = 0,\n        c16 = 0,\n        c00 = 0;\n      c00 += a00 + b00;\n      c16 += c00 >>> 16;\n      c00 &= 0xffff;\n      c16 += a16 + b16;\n      c32 += c16 >>> 16;\n      c16 &= 0xffff;\n      c32 += a32 + b32;\n      c48 += c32 >>> 16;\n      c32 &= 0xffff;\n      c48 += a48 + b48;\n      c48 &= 0xffff;\n      return fromBits((c16 << 16) | c00, (c48 << 16) | c32, this.unsigned);\n    };\n\n    /**\n     * Returns the difference of this and the specified Long.\n     * @this {!Long}\n     * @param {!Long|number|bigint|string} subtrahend Subtrahend\n     * @returns {!Long} Difference\n     */\n    LongPrototype.subtract = function subtract(subtrahend) {\n      if (!isLong(subtrahend)) subtrahend = fromValue(subtrahend);\n      return this.add(subtrahend.neg());\n    };\n\n    /**\n     * Returns the difference of this and the specified Long. This is an alias of {@link Long#subtract}.\n     * @function\n     * @param {!Long|number|bigint|string} subtrahend Subtrahend\n     * @returns {!Long} Difference\n     */\n    LongPrototype.sub = LongPrototype.subtract;\n\n    /**\n     * Returns the product of this and the specified Long.\n     * @this {!Long}\n     * @param {!Long|number|bigint|string} multiplier Multiplier\n     * @returns {!Long} Product\n     */\n    LongPrototype.multiply = function multiply(multiplier) {\n      if (this.isZero()) return this;\n      if (!isLong(multiplier)) multiplier = fromValue(multiplier);\n\n      // use wasm support if present\n      if (wasm) {\n        var low = wasm[\"mul\"](\n          this.low,\n          this.high,\n          multiplier.low,\n          multiplier.high,\n        );\n        return fromBits(low, wasm[\"get_high\"](), this.unsigned);\n      }\n      if (multiplier.isZero()) return this.unsigned ? UZERO : ZERO;\n      if (this.eq(MIN_VALUE)) return multiplier.isOdd() ? MIN_VALUE : ZERO;\n      if (multiplier.eq(MIN_VALUE)) return this.isOdd() ? MIN_VALUE : ZERO;\n      if (this.isNegative()) {\n        if (multiplier.isNegative()) return this.neg().mul(multiplier.neg());\n        else return this.neg().mul(multiplier).neg();\n      } else if (multiplier.isNegative())\n        return this.mul(multiplier.neg()).neg();\n\n      // If both longs are small, use float multiplication\n      if (this.lt(TWO_PWR_24) && multiplier.lt(TWO_PWR_24))\n        return fromNumber(\n          this.toNumber() * multiplier.toNumber(),\n          this.unsigned,\n        );\n\n      // Divide each long into 4 chunks of 16 bits, and then add up 4x4 products.\n      // We can skip products that would overflow.\n\n      var a48 = this.high >>> 16;\n      var a32 = this.high & 0xffff;\n      var a16 = this.low >>> 16;\n      var a00 = this.low & 0xffff;\n      var b48 = multiplier.high >>> 16;\n      var b32 = multiplier.high & 0xffff;\n      var b16 = multiplier.low >>> 16;\n      var b00 = multiplier.low & 0xffff;\n      var c48 = 0,\n        c32 = 0,\n        c16 = 0,\n        c00 = 0;\n      c00 += a00 * b00;\n      c16 += c00 >>> 16;\n      c00 &= 0xffff;\n      c16 += a16 * b00;\n      c32 += c16 >>> 16;\n      c16 &= 0xffff;\n      c16 += a00 * b16;\n      c32 += c16 >>> 16;\n      c16 &= 0xffff;\n      c32 += a32 * b00;\n      c48 += c32 >>> 16;\n      c32 &= 0xffff;\n      c32 += a16 * b16;\n      c48 += c32 >>> 16;\n      c32 &= 0xffff;\n      c32 += a00 * b32;\n      c48 += c32 >>> 16;\n      c32 &= 0xffff;\n      c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48;\n      c48 &= 0xffff;\n      return fromBits((c16 << 16) | c00, (c48 << 16) | c32, this.unsigned);\n    };\n\n    /**\n     * Returns the product of this and the specified Long. This is an alias of {@link Long#multiply}.\n     * @function\n     * @param {!Long|number|bigint|string} multiplier Multiplier\n     * @returns {!Long} Product\n     */\n    LongPrototype.mul = LongPrototype.multiply;\n\n    /**\n     * Returns this Long divided by the specified. The result is signed if this Long is signed or\n     *  unsigned if this Long is unsigned.\n     * @this {!Long}\n     * @param {!Long|number|bigint|string} divisor Divisor\n     * @returns {!Long} Quotient\n     */\n    LongPrototype.divide = function divide(divisor) {\n      if (!isLong(divisor)) divisor = fromValue(divisor);\n      if (divisor.isZero()) throw Error(\"division by zero\");\n\n      // use wasm support if present\n      if (wasm) {\n        // guard against signed division overflow: the largest\n        // negative number / -1 would be 1 larger than the largest\n        // positive number, due to two's complement.\n        if (\n          !this.unsigned &&\n          this.high === -0x80000000 &&\n          divisor.low === -1 &&\n          divisor.high === -1\n        ) {\n          // be consistent with non-wasm code path\n          return this;\n        }\n        var low = (this.unsigned ? wasm[\"div_u\"] : wasm[\"div_s\"])(\n          this.low,\n          this.high,\n          divisor.low,\n          divisor.high,\n        );\n        return fromBits(low, wasm[\"get_high\"](), this.unsigned);\n      }\n      if (this.isZero()) return this.unsigned ? UZERO : ZERO;\n      var approx, rem, res;\n      if (!this.unsigned) {\n        // This section is only relevant for signed longs and is derived from the\n        // closure library as a whole.\n        if (this.eq(MIN_VALUE)) {\n          if (divisor.eq(ONE) || divisor.eq(NEG_ONE))\n            return MIN_VALUE; // recall that -MIN_VALUE == MIN_VALUE\n          else if (divisor.eq(MIN_VALUE)) return ONE;\n          else {\n            // At this point, we have |other| >= 2, so |this/other| < |MIN_VALUE|.\n            var halfThis = this.shr(1);\n            approx = halfThis.div(divisor).shl(1);\n            if (approx.eq(ZERO)) {\n              return divisor.isNegative() ? ONE : NEG_ONE;\n            } else {\n              rem = this.sub(divisor.mul(approx));\n              res = approx.add(rem.div(divisor));\n              return res;\n            }\n          }\n        } else if (divisor.eq(MIN_VALUE)) return this.unsigned ? UZERO : ZERO;\n        if (this.isNegative()) {\n          if (divisor.isNegative()) return this.neg().div(divisor.neg());\n          return this.neg().div(divisor).neg();\n        } else if (divisor.isNegative()) return this.div(divisor.neg()).neg();\n        res = ZERO;\n      } else {\n        // The algorithm below has not been made for unsigned longs. It's therefore\n        // required to take special care of the MSB prior to running it.\n        if (!divisor.unsigned) divisor = divisor.toUnsigned();\n        if (divisor.gt(this)) return UZERO;\n        if (divisor.gt(this.shru(1)))\n          // 15 >>> 1 = 7 ; with divisor = 8 ; true\n          return UONE;\n        res = UZERO;\n      }\n\n      // Repeat the following until the remainder is less than other:  find a\n      // floating-point that approximates remainder / other *from below*, add this\n      // into the result, and subtract it from the remainder.  It is critical that\n      // the approximate value is less than or equal to the real value so that the\n      // remainder never becomes negative.\n      rem = this;\n      while (rem.gte(divisor)) {\n        // Approximate the result of division. This may be a little greater or\n        // smaller than the actual value.\n        approx = Math.max(1, Math.floor(rem.toNumber() / divisor.toNumber()));\n\n        // We will tweak the approximate result by changing it in the 48-th digit or\n        // the smallest non-fractional digit, whichever is larger.\n        var log2 = Math.ceil(Math.log(approx) / Math.LN2),\n          delta = log2 <= 48 ? 1 : pow_dbl(2, log2 - 48),\n          // Decrease the approximation until it is smaller than the remainder.  Note\n          // that if it is too large, the product overflows and is negative.\n          approxRes = fromNumber(approx),\n          approxRem = approxRes.mul(divisor);\n        while (approxRem.isNegative() || approxRem.gt(rem)) {\n          approx -= delta;\n          approxRes = fromNumber(approx, this.unsigned);\n          approxRem = approxRes.mul(divisor);\n        }\n\n        // We know the answer can't be zero... and actually, zero would cause\n        // infinite recursion since we would make no progress.\n        if (approxRes.isZero()) approxRes = ONE;\n        res = res.add(approxRes);\n        rem = rem.sub(approxRem);\n      }\n      return res;\n    };\n\n    /**\n     * Returns this Long divided by the specified. This is an alias of {@link Long#divide}.\n     * @function\n     * @param {!Long|number|bigint|string} divisor Divisor\n     * @returns {!Long} Quotient\n     */\n    LongPrototype.div = LongPrototype.divide;\n\n    /**\n     * Returns this Long modulo the specified.\n     * @this {!Long}\n     * @param {!Long|number|bigint|string} divisor Divisor\n     * @returns {!Long} Remainder\n     */\n    LongPrototype.modulo = function modulo(divisor) {\n      if (!isLong(divisor)) divisor = fromValue(divisor);\n\n      // use wasm support if present\n      if (wasm) {\n        var low = (this.unsigned ? wasm[\"rem_u\"] : wasm[\"rem_s\"])(\n          this.low,\n          this.high,\n          divisor.low,\n          divisor.high,\n        );\n        return fromBits(low, wasm[\"get_high\"](), this.unsigned);\n      }\n      return this.sub(this.div(divisor).mul(divisor));\n    };\n\n    /**\n     * Returns this Long modulo the specified. This is an alias of {@link Long#modulo}.\n     * @function\n     * @param {!Long|number|bigint|string} divisor Divisor\n     * @returns {!Long} Remainder\n     */\n    LongPrototype.mod = LongPrototype.modulo;\n\n    /**\n     * Returns this Long modulo the specified. This is an alias of {@link Long#modulo}.\n     * @function\n     * @param {!Long|number|bigint|string} divisor Divisor\n     * @returns {!Long} Remainder\n     */\n    LongPrototype.rem = LongPrototype.modulo;\n\n    /**\n     * Returns the bitwise NOT of this Long.\n     * @this {!Long}\n     * @returns {!Long}\n     */\n    LongPrototype.not = function not() {\n      return fromBits(~this.low, ~this.high, this.unsigned);\n    };\n\n    /**\n     * Returns count leading zeros of this Long.\n     * @this {!Long}\n     * @returns {!number}\n     */\n    LongPrototype.countLeadingZeros = function countLeadingZeros() {\n      return this.high ? Math.clz32(this.high) : Math.clz32(this.low) + 32;\n    };\n\n    /**\n     * Returns count leading zeros. This is an alias of {@link Long#countLeadingZeros}.\n     * @function\n     * @param {!Long}\n     * @returns {!number}\n     */\n    LongPrototype.clz = LongPrototype.countLeadingZeros;\n\n    /**\n     * Returns count trailing zeros of this Long.\n     * @this {!Long}\n     * @returns {!number}\n     */\n    LongPrototype.countTrailingZeros = function countTrailingZeros() {\n      return this.low ? ctz32(this.low) : ctz32(this.high) + 32;\n    };\n\n    /**\n     * Returns count trailing zeros. This is an alias of {@link Long#countTrailingZeros}.\n     * @function\n     * @param {!Long}\n     * @returns {!number}\n     */\n    LongPrototype.ctz = LongPrototype.countTrailingZeros;\n\n    /**\n     * Returns the bitwise AND of this Long and the specified.\n     * @this {!Long}\n     * @param {!Long|number|bigint|string} other Other Long\n     * @returns {!Long}\n     */\n    LongPrototype.and = function and(other) {\n      if (!isLong(other)) other = fromValue(other);\n      return fromBits(\n        this.low & other.low,\n        this.high & other.high,\n        this.unsigned,\n      );\n    };\n\n    /**\n     * Returns the bitwise OR of this Long and the specified.\n     * @this {!Long}\n     * @param {!Long|number|bigint|string} other Other Long\n     * @returns {!Long}\n     */\n    LongPrototype.or = function or(other) {\n      if (!isLong(other)) other = fromValue(other);\n      return fromBits(\n        this.low | other.low,\n        this.high | other.high,\n        this.unsigned,\n      );\n    };\n\n    /**\n     * Returns the bitwise XOR of this Long and the given one.\n     * @this {!Long}\n     * @param {!Long|number|bigint|string} other Other Long\n     * @returns {!Long}\n     */\n    LongPrototype.xor = function xor(other) {\n      if (!isLong(other)) other = fromValue(other);\n      return fromBits(\n        this.low ^ other.low,\n        this.high ^ other.high,\n        this.unsigned,\n      );\n    };\n\n    /**\n     * Returns this Long with bits shifted to the left by the given amount.\n     * @this {!Long}\n     * @param {number|!Long} numBits Number of bits\n     * @returns {!Long} Shifted Long\n     */\n    LongPrototype.shiftLeft = function shiftLeft(numBits) {\n      if (isLong(numBits)) numBits = numBits.toInt();\n      if ((numBits &= 63) === 0) return this;\n      else if (numBits < 32)\n        return fromBits(\n          this.low << numBits,\n          (this.high << numBits) | (this.low >>> (32 - numBits)),\n          this.unsigned,\n        );\n      else return fromBits(0, this.low << (numBits - 32), this.unsigned);\n    };\n\n    /**\n     * Returns this Long with bits shifted to the left by the given amount. This is an alias of {@link Long#shiftLeft}.\n     * @function\n     * @param {number|!Long} numBits Number of bits\n     * @returns {!Long} Shifted Long\n     */\n    LongPrototype.shl = LongPrototype.shiftLeft;\n\n    /**\n     * Returns this Long with bits arithmetically shifted to the right by the given amount.\n     * @this {!Long}\n     * @param {number|!Long} numBits Number of bits\n     * @returns {!Long} Shifted Long\n     */\n    LongPrototype.shiftRight = function shiftRight(numBits) {\n      if (isLong(numBits)) numBits = numBits.toInt();\n      if ((numBits &= 63) === 0) return this;\n      else if (numBits < 32)\n        return fromBits(\n          (this.low >>> numBits) | (this.high << (32 - numBits)),\n          this.high >> numBits,\n          this.unsigned,\n        );\n      else\n        return fromBits(\n          this.high >> (numBits - 32),\n          this.high >= 0 ? 0 : -1,\n          this.unsigned,\n        );\n    };\n\n    /**\n     * Returns this Long with bits arithmetically shifted to the right by the given amount. This is an alias of {@link Long#shiftRight}.\n     * @function\n     * @param {number|!Long} numBits Number of bits\n     * @returns {!Long} Shifted Long\n     */\n    LongPrototype.shr = LongPrototype.shiftRight;\n\n    /**\n     * Returns this Long with bits logically shifted to the right by the given amount.\n     * @this {!Long}\n     * @param {number|!Long} numBits Number of bits\n     * @returns {!Long} Shifted Long\n     */\n    LongPrototype.shiftRightUnsigned = function shiftRightUnsigned(numBits) {\n      if (isLong(numBits)) numBits = numBits.toInt();\n      if ((numBits &= 63) === 0) return this;\n      if (numBits < 32)\n        return fromBits(\n          (this.low >>> numBits) | (this.high << (32 - numBits)),\n          this.high >>> numBits,\n          this.unsigned,\n        );\n      if (numBits === 32) return fromBits(this.high, 0, this.unsigned);\n      return fromBits(this.high >>> (numBits - 32), 0, this.unsigned);\n    };\n\n    /**\n     * Returns this Long with bits logically shifted to the right by the given amount. This is an alias of {@link Long#shiftRightUnsigned}.\n     * @function\n     * @param {number|!Long} numBits Number of bits\n     * @returns {!Long} Shifted Long\n     */\n    LongPrototype.shru = LongPrototype.shiftRightUnsigned;\n\n    /**\n     * Returns this Long with bits logically shifted to the right by the given amount. This is an alias of {@link Long#shiftRightUnsigned}.\n     * @function\n     * @param {number|!Long} numBits Number of bits\n     * @returns {!Long} Shifted Long\n     */\n    LongPrototype.shr_u = LongPrototype.shiftRightUnsigned;\n\n    /**\n     * Returns this Long with bits rotated to the left by the given amount.\n     * @this {!Long}\n     * @param {number|!Long} numBits Number of bits\n     * @returns {!Long} Rotated Long\n     */\n    LongPrototype.rotateLeft = function rotateLeft(numBits) {\n      var b;\n      if (isLong(numBits)) numBits = numBits.toInt();\n      if ((numBits &= 63) === 0) return this;\n      if (numBits === 32) return fromBits(this.high, this.low, this.unsigned);\n      if (numBits < 32) {\n        b = 32 - numBits;\n        return fromBits(\n          (this.low << numBits) | (this.high >>> b),\n          (this.high << numBits) | (this.low >>> b),\n          this.unsigned,\n        );\n      }\n      numBits -= 32;\n      b = 32 - numBits;\n      return fromBits(\n        (this.high << numBits) | (this.low >>> b),\n        (this.low << numBits) | (this.high >>> b),\n        this.unsigned,\n      );\n    };\n    /**\n     * Returns this Long with bits rotated to the left by the given amount. This is an alias of {@link Long#rotateLeft}.\n     * @function\n     * @param {number|!Long} numBits Number of bits\n     * @returns {!Long} Rotated Long\n     */\n    LongPrototype.rotl = LongPrototype.rotateLeft;\n\n    /**\n     * Returns this Long with bits rotated to the right by the given amount.\n     * @this {!Long}\n     * @param {number|!Long} numBits Number of bits\n     * @returns {!Long} Rotated Long\n     */\n    LongPrototype.rotateRight = function rotateRight(numBits) {\n      var b;\n      if (isLong(numBits)) numBits = numBits.toInt();\n      if ((numBits &= 63) === 0) return this;\n      if (numBits === 32) return fromBits(this.high, this.low, this.unsigned);\n      if (numBits < 32) {\n        b = 32 - numBits;\n        return fromBits(\n          (this.high << b) | (this.low >>> numBits),\n          (this.low << b) | (this.high >>> numBits),\n          this.unsigned,\n        );\n      }\n      numBits -= 32;\n      b = 32 - numBits;\n      return fromBits(\n        (this.low << b) | (this.high >>> numBits),\n        (this.high << b) | (this.low >>> numBits),\n        this.unsigned,\n      );\n    };\n    /**\n     * Returns this Long with bits rotated to the right by the given amount. This is an alias of {@link Long#rotateRight}.\n     * @function\n     * @param {number|!Long} numBits Number of bits\n     * @returns {!Long} Rotated Long\n     */\n    LongPrototype.rotr = LongPrototype.rotateRight;\n\n    /**\n     * Converts this Long to signed.\n     * @this {!Long}\n     * @returns {!Long} Signed long\n     */\n    LongPrototype.toSigned = function toSigned() {\n      if (!this.unsigned) return this;\n      return fromBits(this.low, this.high, false);\n    };\n\n    /**\n     * Converts this Long to unsigned.\n     * @this {!Long}\n     * @returns {!Long} Unsigned long\n     */\n    LongPrototype.toUnsigned = function toUnsigned() {\n      if (this.unsigned) return this;\n      return fromBits(this.low, this.high, true);\n    };\n\n    /**\n     * Converts this Long to its byte representation.\n     * @param {boolean=} le Whether little or big endian, defaults to big endian\n     * @this {!Long}\n     * @returns {!Array.<number>} Byte representation\n     */\n    LongPrototype.toBytes = function toBytes(le) {\n      return le ? this.toBytesLE() : this.toBytesBE();\n    };\n\n    /**\n     * Converts this Long to its little endian byte representation.\n     * @this {!Long}\n     * @returns {!Array.<number>} Little endian byte representation\n     */\n    LongPrototype.toBytesLE = function toBytesLE() {\n      var hi = this.high,\n        lo = this.low;\n      return [\n        lo & 0xff,\n        (lo >>> 8) & 0xff,\n        (lo >>> 16) & 0xff,\n        lo >>> 24,\n        hi & 0xff,\n        (hi >>> 8) & 0xff,\n        (hi >>> 16) & 0xff,\n        hi >>> 24,\n      ];\n    };\n\n    /**\n     * Converts this Long to its big endian byte representation.\n     * @this {!Long}\n     * @returns {!Array.<number>} Big endian byte representation\n     */\n    LongPrototype.toBytesBE = function toBytesBE() {\n      var hi = this.high,\n        lo = this.low;\n      return [\n        hi >>> 24,\n        (hi >>> 16) & 0xff,\n        (hi >>> 8) & 0xff,\n        hi & 0xff,\n        lo >>> 24,\n        (lo >>> 16) & 0xff,\n        (lo >>> 8) & 0xff,\n        lo & 0xff,\n      ];\n    };\n\n    /**\n     * Creates a Long from its byte representation.\n     * @param {!Array.<number>} bytes Byte representation\n     * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n     * @param {boolean=} le Whether little or big endian, defaults to big endian\n     * @returns {Long} The corresponding Long value\n     */\n    Long.fromBytes = function fromBytes(bytes, unsigned, le) {\n      return le\n        ? Long.fromBytesLE(bytes, unsigned)\n        : Long.fromBytesBE(bytes, unsigned);\n    };\n\n    /**\n     * Creates a Long from its little endian byte representation.\n     * @param {!Array.<number>} bytes Little endian byte representation\n     * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n     * @returns {Long} The corresponding Long value\n     */\n    Long.fromBytesLE = function fromBytesLE(bytes, unsigned) {\n      return new Long(\n        bytes[0] | (bytes[1] << 8) | (bytes[2] << 16) | (bytes[3] << 24),\n        bytes[4] | (bytes[5] << 8) | (bytes[6] << 16) | (bytes[7] << 24),\n        unsigned,\n      );\n    };\n\n    /**\n     * Creates a Long from its big endian byte representation.\n     * @param {!Array.<number>} bytes Big endian byte representation\n     * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n     * @returns {Long} The corresponding Long value\n     */\n    Long.fromBytesBE = function fromBytesBE(bytes, unsigned) {\n      return new Long(\n        (bytes[4] << 24) | (bytes[5] << 16) | (bytes[6] << 8) | bytes[7],\n        (bytes[0] << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3],\n        unsigned,\n      );\n    };\n\n    // Support conversion to/from BigInt where available\n    if (typeof BigInt === \"function\") {\n      /**\n       * Returns a Long representing the given big integer.\n       * @function\n       * @param {number} value The big integer value\n       * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n       * @returns {!Long} The corresponding Long value\n       */\n      Long.fromBigInt = function fromBigInt(value, unsigned) {\n        var lowBits = Number(BigInt.asIntN(32, value));\n        var highBits = Number(BigInt.asIntN(32, value >> BigInt(32)));\n        return fromBits(lowBits, highBits, unsigned);\n      };\n\n      // Override\n      Long.fromValue = function fromValueWithBigInt(value, unsigned) {\n        if (typeof value === \"bigint\") return Long.fromBigInt(value, unsigned);\n        return fromValue(value, unsigned);\n      };\n\n      /**\n       * Converts the Long to its big integer representation.\n       * @this {!Long}\n       * @returns {bigint}\n       */\n      LongPrototype.toBigInt = function toBigInt() {\n        var lowBigInt = BigInt(this.low >>> 0);\n        var highBigInt = BigInt(this.unsigned ? this.high >>> 0 : this.high);\n        return (highBigInt << BigInt(32)) | lowBigInt;\n      };\n    }\n    var _default = (_exports.default = Long);\n  },\n);\n", "\"use strict\";\nvar util = exports;\n\n// used to return a Promise where callback is omitted\nutil.asPromise = require(\"@protobufjs/aspromise\");\n\n// converts to / from base64 encoded strings\nutil.base64 = require(\"@protobufjs/base64\");\n\n// base class of rpc.Service\nutil.EventEmitter = require(\"@protobufjs/eventemitter\");\n\n// float handling accross browsers\nutil.float = require(\"@protobufjs/float\");\n\n// requires modules optionally and hides the call from bundlers\nutil.inquire = require(\"@protobufjs/inquire\");\n\n// converts to / from utf8 encoded strings\nutil.utf8 = require(\"@protobufjs/utf8\");\n\n// provides a node-like buffer pool in the browser\nutil.pool = require(\"@protobufjs/pool\");\n\n// utility to work with the low and high bits of a 64 bit value\nutil.LongBits = require(\"./longbits\");\n\n/**\n * Tests if the specified key can affect object prototypes.\n * @memberof util\n * @param {string} key Key to test\n * @returns {boolean} `true` if the key is unsafe\n */\nfunction isUnsafeProperty(key) {\n    return key === \"__proto__\" || key === \"prototype\" || key === \"constructor\";\n}\n\nutil.isUnsafeProperty = isUnsafeProperty;\n\n/**\n * Whether running within node or not.\n * @memberof util\n * @type {boolean}\n */\nutil.isNode = Boolean(typeof global !== \"undefined\"\n                   && global\n                   && global.process\n                   && global.process.versions\n                   && global.process.versions.node);\n\n/**\n * Global object reference.\n * @memberof util\n * @type {Object}\n */\nutil.global = util.isNode && global\n           || typeof window !== \"undefined\" && window\n           || typeof self   !== \"undefined\" && self\n           || this; // eslint-disable-line no-invalid-this\n\n/**\n * An immuable empty array.\n * @memberof util\n * @type {Array.<*>}\n * @const\n */\nutil.emptyArray = Object.freeze ? Object.freeze([]) : /* istanbul ignore next */ []; // used on prototypes\n\n/**\n * An immutable empty object.\n * @type {Object}\n * @const\n */\nutil.emptyObject = Object.freeze ? Object.freeze({}) : /* istanbul ignore next */ {}; // used on prototypes\n\n/**\n * Tests if the specified value is an integer.\n * @function\n * @param {*} value Value to test\n * @returns {boolean} `true` if the value is an integer\n */\nutil.isInteger = Number.isInteger || /* istanbul ignore next */ function isInteger(value) {\n    return typeof value === \"number\" && isFinite(value) && Math.floor(value) === value;\n};\n\n/**\n * Tests if the specified value is a string.\n * @param {*} value Value to test\n * @returns {boolean} `true` if the value is a string\n */\nutil.isString = function isString(value) {\n    return typeof value === \"string\" || value instanceof String;\n};\n\n/**\n * Tests if the specified value is a non-null object.\n * @param {*} value Value to test\n * @returns {boolean} `true` if the value is a non-null object\n */\nutil.isObject = function isObject(value) {\n    return value && typeof value === \"object\";\n};\n\n/**\n * Checks if a property on a message is considered to be present.\n * This is an alias of {@link util.isSet}.\n * @function\n * @param {Object} obj Plain object or message instance\n * @param {string} prop Property name\n * @returns {boolean} `true` if considered to be present, otherwise `false`\n */\nutil.isset =\n\n/**\n * Checks if a property on a message is considered to be present.\n * @param {Object} obj Plain object or message instance\n * @param {string} prop Property name\n * @returns {boolean} `true` if considered to be present, otherwise `false`\n */\nutil.isSet = function isSet(obj, prop) {\n    var value = obj[prop];\n    if (value != null && Object.hasOwnProperty.call(obj, prop)) // eslint-disable-line eqeqeq\n        return typeof value !== \"object\" || (Array.isArray(value) ? value.length : Object.keys(value).length) > 0;\n    return false;\n};\n\n/**\n * Any compatible Buffer instance.\n * This is a minimal stand-alone definition of a Buffer instance. The actual type is that exported by node's typings.\n * @interface Buffer\n * @extends Uint8Array\n */\n\n/**\n * Node's Buffer class if available.\n * @type {Constructor<Buffer>}\n */\nutil.Buffer = (function() {\n    try {\n        var Buffer = util.global.Buffer;\n        // refuse to use non-node buffers if not explicitly assigned (perf reasons):\n        return Buffer.prototype.utf8Write ? Buffer : /* istanbul ignore next */ null;\n    } catch (e) {\n        /* istanbul ignore next */\n        return null;\n    }\n})();\n\n// Internal alias of or polyfull for Buffer.from.\nutil._Buffer_from = null;\n\n// Internal alias of or polyfill for Buffer.allocUnsafe.\nutil._Buffer_allocUnsafe = null;\n\n/**\n * Creates a new buffer of whatever type supported by the environment.\n * @param {number|number[]} [sizeOrArray=0] Buffer size or number array\n * @returns {Uint8Array|Buffer} Buffer\n */\nutil.newBuffer = function newBuffer(sizeOrArray) {\n    /* istanbul ignore next */\n    return typeof sizeOrArray === \"number\"\n        ? util.Buffer\n            ? util._Buffer_allocUnsafe(sizeOrArray)\n            : new util.Array(sizeOrArray)\n        : util.Buffer\n            ? util._Buffer_from(sizeOrArray)\n            : typeof Uint8Array === \"undefined\"\n                ? sizeOrArray\n                : new Uint8Array(sizeOrArray);\n};\n\n/**\n * Array implementation used in the browser. `Uint8Array` if supported, otherwise `Array`.\n * @type {Constructor<Uint8Array>}\n */\nutil.Array = typeof Uint8Array !== \"undefined\" ? Uint8Array /* istanbul ignore next */ : Array;\n\n/**\n * Any compatible Long instance.\n * This is a minimal stand-alone definition of a Long instance. The actual type is that exported by long.js.\n * @interface Long\n * @property {number} low Low bits\n * @property {number} high High bits\n * @property {boolean} unsigned Whether unsigned or not\n */\n\n/**\n * Long.js's Long class if available.\n * @type {Constructor<Long>}\n */\nutil.Long = /* istanbul ignore next */ util.global.dcodeIO && /* istanbul ignore next */ util.global.dcodeIO.Long\n         || /* istanbul ignore next */ util.global.Long\n         || (function() {\n                try {\n                    var Long = require(\"long\");\n                    return Long && Long.isLong ? Long : null;\n                } catch (e) {\n                    /* istanbul ignore next */\n                    return null;\n                }\n            })();\n\n/**\n * Regular expression used to verify 2 bit (`bool`) map keys.\n * @type {RegExp}\n * @const\n */\nutil.key2Re = /^true|false|0|1$/;\n\n/**\n * Regular expression used to verify 32 bit (`int32` etc.) map keys.\n * @type {RegExp}\n * @const\n */\nutil.key32Re = /^-?(?:0|[1-9][0-9]*)$/;\n\n/**\n * Regular expression used to verify 64 bit (`int64` etc.) map keys.\n * @type {RegExp}\n * @const\n */\nutil.key64Re = /^(?:[\\\\x00-\\\\xff]{8}|-?(?:0|[1-9][0-9]*))$/;\n\n/**\n * Converts a number or long to an 8 characters long hash string.\n * @param {Long|number} value Value to convert\n * @returns {string} Hash\n */\nutil.longToHash = function longToHash(value) {\n    return value\n        ? util.LongBits.from(value).toHash()\n        : util.LongBits.zeroHash;\n};\n\n/**\n * Converts an 8 characters long hash string to a long or number.\n * @param {string} hash Hash\n * @param {boolean} [unsigned=false] Whether unsigned or not\n * @returns {Long|number} Original value\n */\nutil.longFromHash = function longFromHash(hash, unsigned) {\n    var bits = util.LongBits.fromHash(hash);\n    if (util.Long)\n        return util.Long.fromBits(bits.lo, bits.hi, unsigned);\n    return bits.toNumber(Boolean(unsigned));\n};\n\n/**\n * Merges the properties of the source object into the destination object.\n * @memberof util\n * @param {Object.<string,*>} dst Destination object\n * @param {...(Object.<string,*>|boolean)} src Source objects, optionally followed by an `ifNotSet` flag\n * @returns {Object.<string,*>} Destination object\n */\nfunction merge(dst) { // used by converters\n    var ifNotSet = typeof arguments[arguments.length - 1] === \"boolean\",\n        limit = ifNotSet ? arguments.length - 1 : arguments.length;\n    ifNotSet = ifNotSet && arguments[arguments.length - 1];\n    for (var a = 1; a < limit; ++a) {\n        var src = arguments[a];\n        if (!src)\n            continue;\n        for (var keys = Object.keys(src), i = 0; i < keys.length; ++i)\n            if (!isUnsafeProperty(keys[i]) && (dst[keys[i]] === undefined || !ifNotSet))\n                dst[keys[i]] = src[keys[i]];\n    }\n    return dst;\n}\n\nutil.merge = merge;\n\n/**\n * Schema declaration nesting limit.\n * @memberof util\n * @type {number}\n */\nutil.nestingLimit = 32; // protoc: MaxMessageDeclarationNestingDepth\n\n/**\n * Recursion limit.\n * @memberof util\n * @type {number}\n */\nutil.recursionLimit = 100; // protoc: CodedInputStream::default_recursion_limit_\n\n/**\n * Makes a property safe for assignment as an own property.\n * @memberof util\n * @param {Object.<string,*>} obj Object\n * @param {string} key Property key\n * @returns {undefined}\n */\nutil.makeProp = function makeProp(obj, key) {\n    Object.defineProperty(obj, key, {\n        enumerable: true,\n        configurable: true,\n        writable: true\n    });\n};\n\n/**\n * Converts the first character of a string to lower case.\n * @param {string} str String to convert\n * @returns {string} Converted string\n */\nutil.lcFirst = function lcFirst(str) {\n    return str.charAt(0).toLowerCase() + str.substring(1);\n};\n\n/**\n * Creates a custom error constructor.\n * @memberof util\n * @param {string} name Error name\n * @returns {Constructor<Error>} Custom error constructor\n */\nfunction newError(name) {\n\n    function CustomError(message, properties) {\n\n        if (!(this instanceof CustomError))\n            return new CustomError(message, properties);\n\n        // Error.call(this, message);\n        // ^ just returns a new error instance because the ctor can be called as a function\n\n        Object.defineProperty(this, \"message\", { get: function() { return message; } });\n\n        /* istanbul ignore next */\n        if (Error.captureStackTrace) // node\n            Error.captureStackTrace(this, CustomError);\n        else\n            Object.defineProperty(this, \"stack\", { value: new Error().stack || \"\" });\n\n        if (properties)\n            merge(this, properties);\n    }\n\n    CustomError.prototype = Object.create(Error.prototype, {\n        constructor: {\n            value: CustomError,\n            writable: true,\n            enumerable: false,\n            configurable: true,\n        },\n        name: {\n            get: function get() { return name; },\n            set: undefined,\n            enumerable: false,\n            // configurable: false would accurately preserve the behavior of\n            // the original, but I'm guessing that was not intentional.\n            // For an actual error subclass, this property would\n            // be configurable.\n            configurable: true,\n        },\n        toString: {\n            value: function value() { return this.name + \": \" + this.message; },\n            writable: true,\n            enumerable: false,\n            configurable: true,\n        },\n    });\n\n    return CustomError;\n}\n\nutil.newError = newError;\n\n/**\n * Constructs a new protocol error.\n * @classdesc Error subclass indicating a protocol specifc error.\n * @memberof util\n * @extends Error\n * @template T extends Message<T>\n * @constructor\n * @param {string} message Error message\n * @param {Object.<string,*>} [properties] Additional properties\n * @example\n * try {\n *     MyMessage.decode(someBuffer); // throws if required fields are missing\n * } catch (e) {\n *     if (e instanceof ProtocolError && e.instance)\n *         console.log(\"decoded so far: \" + JSON.stringify(e.instance));\n * }\n */\nutil.ProtocolError = newError(\"ProtocolError\");\n\n/**\n * So far decoded message instance.\n * @name util.ProtocolError#instance\n * @type {Message<T>}\n */\n\n/**\n * A OneOf getter as returned by {@link util.oneOfGetter}.\n * @typedef OneOfGetter\n * @type {function}\n * @returns {string|undefined} Set field name, if any\n */\n\n/**\n * Builds a getter for a oneof's present field name.\n * @param {string[]} fieldNames Field names\n * @returns {OneOfGetter} Unbound getter\n */\nutil.oneOfGetter = function getOneOf(fieldNames) {\n    var fieldMap = {};\n    for (var i = 0; i < fieldNames.length; ++i)\n        fieldMap[fieldNames[i]] = 1;\n\n    /**\n     * @returns {string|undefined} Set field name, if any\n     * @this Object\n     * @ignore\n     */\n    return function() { // eslint-disable-line consistent-return\n        for (var keys = Object.keys(this), i = keys.length - 1; i > -1; --i)\n            if (fieldMap[keys[i]] === 1 && this[keys[i]] !== undefined && this[keys[i]] !== null)\n                return keys[i];\n    };\n};\n\n/**\n * A OneOf setter as returned by {@link util.oneOfSetter}.\n * @typedef OneOfSetter\n * @type {function}\n * @param {string|undefined} value Field name\n * @returns {undefined}\n */\n\n/**\n * Builds a setter for a oneof's present field name.\n * @param {string[]} fieldNames Field names\n * @returns {OneOfSetter} Unbound setter\n */\nutil.oneOfSetter = function setOneOf(fieldNames) {\n\n    /**\n     * @param {string} name Field name\n     * @returns {undefined}\n     * @this Object\n     * @ignore\n     */\n    return function(name) {\n        for (var i = 0; i < fieldNames.length; ++i)\n            if (fieldNames[i] !== name)\n                delete this[fieldNames[i]];\n    };\n};\n\n/**\n * Default conversion options used for {@link Message#toJSON} implementations.\n *\n * These options are close to proto3's JSON mapping with the exception that internal types like Any are handled just like messages. More precisely:\n *\n * - Longs become strings\n * - Enums become string keys\n * - Bytes become base64 encoded strings\n * - (Sub-)Messages become plain objects\n * - Maps become plain objects with all string keys\n * - Repeated fields become arrays\n * - NaN and Infinity for float and double fields become strings\n *\n * @type {IConversionOptions}\n * @see https://developers.google.com/protocol-buffers/docs/proto3?hl=en#json\n */\nutil.toJSONOptions = {\n    longs: String,\n    enums: String,\n    bytes: String,\n    json: true\n};\n\n// Sets up buffer utility according to the environment (called in index-minimal)\nutil._configure = function() {\n    var Buffer = util.Buffer;\n    /* istanbul ignore if */\n    if (!Buffer) {\n        util._Buffer_from = util._Buffer_allocUnsafe = null;\n        return;\n    }\n    // because node 4.x buffers are incompatible & immutable\n    // see: https://github.com/dcodeIO/protobuf.js/pull/665\n    util._Buffer_from = Buffer.from !== Uint8Array.from && Buffer.from ||\n        /* istanbul ignore next */\n        function Buffer_from(value, encoding) {\n            return new Buffer(value, encoding);\n        };\n    util._Buffer_allocUnsafe = Buffer.allocUnsafe ||\n        /* istanbul ignore next */\n        function Buffer_allocUnsafe(size) {\n            return new Buffer(size);\n        };\n};\n", "\"use strict\";\nmodule.exports = Writer;\n\nvar util      = require(\"./util/minimal\");\n\nvar BufferWriter; // cyclic\n\nvar LongBits  = util.LongBits,\n    base64    = util.base64,\n    utf8      = util.utf8;\n\n/**\n * Constructs a new writer operation instance.\n * @classdesc Scheduled writer operation.\n * @constructor\n * @param {function(*, Uint8Array, number)} fn Function to call\n * @param {number} len Value byte length\n * @param {*} val Value to write\n * @ignore\n */\nfunction Op(fn, len, val) {\n\n    /**\n     * Function to call.\n     * @type {function(Uint8Array, number, *)}\n     */\n    this.fn = fn;\n\n    /**\n     * Value byte length.\n     * @type {number}\n     */\n    this.len = len;\n\n    /**\n     * Next operation.\n     * @type {Writer.Op|undefined}\n     */\n    this.next = undefined;\n\n    /**\n     * Value to write.\n     * @type {*}\n     */\n    this.val = val; // type varies\n}\n\n/* istanbul ignore next */\nfunction noop() {} // eslint-disable-line no-empty-function\n\n/**\n * Constructs a new writer state instance.\n * @classdesc Copied writer state.\n * @memberof Writer\n * @constructor\n * @param {Writer} writer Writer to copy state from\n * @ignore\n */\nfunction State(writer) {\n\n    /**\n     * Current head.\n     * @type {Writer.Op}\n     */\n    this.head = writer.head;\n\n    /**\n     * Current tail.\n     * @type {Writer.Op}\n     */\n    this.tail = writer.tail;\n\n    /**\n     * Current buffer length.\n     * @type {number}\n     */\n    this.len = writer.len;\n\n    /**\n     * Next state.\n     * @type {State|null}\n     */\n    this.next = writer.states;\n}\n\n/**\n * Constructs a new writer instance.\n * @classdesc Wire format writer using `Uint8Array` if available, otherwise `Array`.\n * @constructor\n */\nfunction Writer() {\n\n    /**\n     * Current length.\n     * @type {number}\n     */\n    this.len = 0;\n\n    /**\n     * Operations head.\n     * @type {Object}\n     */\n    this.head = new Op(noop, 0, 0);\n\n    /**\n     * Operations tail\n     * @type {Object}\n     */\n    this.tail = this.head;\n\n    /**\n     * Linked forked states.\n     * @type {Object|null}\n     */\n    this.states = null;\n\n    // When a value is written, the writer calculates its byte length and puts it into a linked\n    // list of operations to perform when finish() is called. This both allows us to allocate\n    // buffers of the exact required size and reduces the amount of work we have to do compared\n    // to first calculating over objects and then encoding over objects. In our case, the encoding\n    // part is just a linked list walk calling operations with already prepared values.\n}\n\nvar create = function create() {\n    return util.Buffer\n        ? function create_buffer_setup() {\n            return (Writer.create = function create_buffer() {\n                return new BufferWriter();\n            })();\n        }\n        /* istanbul ignore next */\n        : function create_array() {\n            return new Writer();\n        };\n};\n\n/**\n * Creates a new writer.\n * @function\n * @returns {BufferWriter|Writer} A {@link BufferWriter} when Buffers are supported, otherwise a {@link Writer}\n */\nWriter.create = create();\n\n/**\n * Allocates a buffer of the specified size.\n * @param {number} size Buffer size\n * @returns {Uint8Array} Buffer\n */\nWriter.alloc = function alloc(size) {\n    return new util.Array(size);\n};\n\n// Use Uint8Array buffer pool in the browser, just like node does with buffers\n/* istanbul ignore else */\nif (util.Array !== Array)\n    Writer.alloc = util.pool(Writer.alloc, util.Array.prototype.subarray);\n\n/**\n * Pushes a new operation to the queue.\n * @param {function(Uint8Array, number, *)} fn Function to call\n * @param {number} len Value byte length\n * @param {number} val Value to write\n * @returns {Writer} `this`\n * @private\n */\nWriter.prototype._push = function push(fn, len, val) {\n    this.tail = this.tail.next = new Op(fn, len, val);\n    this.len += len;\n    return this;\n};\n\nfunction writeByte(val, buf, pos) {\n    buf[pos] = val & 255;\n}\n\nfunction writeVarint32(val, buf, pos) {\n    while (val > 127) {\n        buf[pos++] = val & 127 | 128;\n        val >>>= 7;\n    }\n    buf[pos] = val;\n}\n\n/**\n * Constructs a new varint writer operation instance.\n * @classdesc Scheduled varint writer operation.\n * @extends Op\n * @constructor\n * @param {number} len Value byte length\n * @param {number} val Value to write\n * @ignore\n */\nfunction VarintOp(len, val) {\n    this.len = len;\n    this.next = undefined;\n    this.val = val;\n}\n\nVarintOp.prototype = Object.create(Op.prototype);\nVarintOp.prototype.fn = writeVarint32;\n\n/**\n * Writes an unsigned 32 bit value as a varint.\n * @param {number} value Value to write\n * @returns {Writer} `this`\n */\nWriter.prototype.uint32 = function write_uint32(value) {\n    // here, the call to this.push has been inlined and a varint specific Op subclass is used.\n    // uint32 is by far the most frequently used operation and benefits significantly from this.\n    this.len += (this.tail = this.tail.next = new VarintOp(\n        (value = value >>> 0)\n                < 128       ? 1\n        : value < 16384     ? 2\n        : value < 2097152   ? 3\n        : value < 268435456 ? 4\n        :                     5,\n    value)).len;\n    return this;\n};\n\n/**\n * Writes a signed 32 bit value as a varint.\n * @function\n * @param {number} value Value to write\n * @returns {Writer} `this`\n */\nWriter.prototype.int32 = function write_int32(value) {\n    return (value |= 0) < 0\n        ? this._push(writeVarint64, 10, LongBits.fromNumber(value)) // 10 bytes per spec\n        : this.uint32(value);\n};\n\n/**\n * Writes a 32 bit value as a varint, zig-zag encoded.\n * @param {number} value Value to write\n * @returns {Writer} `this`\n */\nWriter.prototype.sint32 = function write_sint32(value) {\n    return this.uint32((value << 1 ^ value >> 31) >>> 0);\n};\n\nfunction writeVarint64(val, buf, pos) {\n    var lo = val.lo,\n        hi = val.hi;\n    while (hi) {\n        buf[pos++] = lo & 127 | 128;\n        lo = (lo >>> 7 | hi << 25) >>> 0;\n        hi >>>= 7;\n    }\n    while (lo > 127) {\n        buf[pos++] = lo & 127 | 128;\n        lo = lo >>> 7;\n    }\n    buf[pos++] = lo;\n}\n\n/**\n * Writes an unsigned 64 bit value as a varint.\n * @param {Long|number|string} value Value to write\n * @returns {Writer} `this`\n * @throws {TypeError} If `value` is a string and no long library is present.\n */\nWriter.prototype.uint64 = function write_uint64(value) {\n    var bits = LongBits.from(value);\n    return this._push(writeVarint64, bits.length(), bits);\n};\n\n/**\n * Writes a signed 64 bit value as a varint.\n * @function\n * @param {Long|number|string} value Value to write\n * @returns {Writer} `this`\n * @throws {TypeError} If `value` is a string and no long library is present.\n */\nWriter.prototype.int64 = Writer.prototype.uint64;\n\n/**\n * Writes a signed 64 bit value as a varint, zig-zag encoded.\n * @param {Long|number|string} value Value to write\n * @returns {Writer} `this`\n * @throws {TypeError} If `value` is a string and no long library is present.\n */\nWriter.prototype.sint64 = function write_sint64(value) {\n    var bits = LongBits.from(value).zzEncode();\n    return this._push(writeVarint64, bits.length(), bits);\n};\n\n/**\n * Writes a boolish value as a varint.\n * @param {boolean} value Value to write\n * @returns {Writer} `this`\n */\nWriter.prototype.bool = function write_bool(value) {\n    return this._push(writeByte, 1, value ? 1 : 0);\n};\n\nfunction writeFixed32(val, buf, pos) {\n    buf[pos    ] =  val         & 255;\n    buf[pos + 1] =  val >>> 8   & 255;\n    buf[pos + 2] =  val >>> 16  & 255;\n    buf[pos + 3] =  val >>> 24;\n}\n\n/**\n * Writes an unsigned 32 bit value as fixed 32 bits.\n * @param {number} value Value to write\n * @returns {Writer} `this`\n */\nWriter.prototype.fixed32 = function write_fixed32(value) {\n    return this._push(writeFixed32, 4, value >>> 0);\n};\n\n/**\n * Writes a signed 32 bit value as fixed 32 bits.\n * @function\n * @param {number} value Value to write\n * @returns {Writer} `this`\n */\nWriter.prototype.sfixed32 = Writer.prototype.fixed32;\n\n/**\n * Writes an unsigned 64 bit value as fixed 64 bits.\n * @param {Long|number|string} value Value to write\n * @returns {Writer} `this`\n * @throws {TypeError} If `value` is a string and no long library is present.\n */\nWriter.prototype.fixed64 = function write_fixed64(value) {\n    var bits = LongBits.from(value);\n    return this._push(writeFixed32, 4, bits.lo)._push(writeFixed32, 4, bits.hi);\n};\n\n/**\n * Writes a signed 64 bit value as fixed 64 bits.\n * @function\n * @param {Long|number|string} value Value to write\n * @returns {Writer} `this`\n * @throws {TypeError} If `value` is a string and no long library is present.\n */\nWriter.prototype.sfixed64 = Writer.prototype.fixed64;\n\n/**\n * Writes a float (32 bit).\n * @function\n * @param {number} value Value to write\n * @returns {Writer} `this`\n */\nWriter.prototype.float = function write_float(value) {\n    return this._push(util.float.writeFloatLE, 4, value);\n};\n\n/**\n * Writes a double (64 bit float).\n * @function\n * @param {number} value Value to write\n * @returns {Writer} `this`\n */\nWriter.prototype.double = function write_double(value) {\n    return this._push(util.float.writeDoubleLE, 8, value);\n};\n\nvar writeBytes = util.Array.prototype.set\n    ? function writeBytes_set(val, buf, pos) {\n        buf.set(val, pos); // also works for plain array values\n    }\n    /* istanbul ignore next */\n    : function writeBytes_for(val, buf, pos) {\n        for (var i = 0; i < val.length; ++i)\n            buf[pos + i] = val[i];\n    };\n\n/**\n * Writes a sequence of bytes.\n * @param {Uint8Array|string} value Buffer or base64 encoded string to write\n * @returns {Writer} `this`\n */\nWriter.prototype.bytes = function write_bytes(value) {\n    var len = value.length >>> 0;\n    if (!len)\n        return this._push(writeByte, 1, 0);\n    if (util.isString(value)) {\n        var buf = Writer.alloc(len = base64.length(value));\n        base64.decode(value, buf, 0);\n        value = buf;\n    }\n    return this.uint32(len)._push(writeBytes, len, value);\n};\n\n/**\n * Writes a string.\n * @param {string} value Value to write\n * @returns {Writer} `this`\n */\nWriter.prototype.string = function write_string(value) {\n    var len = utf8.length(value);\n    return len\n        ? this.uint32(len)._push(utf8.write, len, value)\n        : this._push(writeByte, 1, 0);\n};\n\n/**\n * Forks this writer's state by pushing it to a stack.\n * Calling {@link Writer#reset|reset} or {@link Writer#ldelim|ldelim} resets the writer to the previous state.\n * @returns {Writer} `this`\n */\nWriter.prototype.fork = function fork() {\n    this.states = new State(this);\n    this.head = this.tail = new Op(noop, 0, 0);\n    this.len = 0;\n    return this;\n};\n\n/**\n * Resets this instance to the last state.\n * @returns {Writer} `this`\n */\nWriter.prototype.reset = function reset() {\n    if (this.states) {\n        this.head   = this.states.head;\n        this.tail   = this.states.tail;\n        this.len    = this.states.len;\n        this.states = this.states.next;\n    } else {\n        this.head = this.tail = new Op(noop, 0, 0);\n        this.len  = 0;\n    }\n    return this;\n};\n\n/**\n * Resets to the last state and appends the fork state's current write length as a varint followed by its operations.\n * @returns {Writer} `this`\n */\nWriter.prototype.ldelim = function ldelim() {\n    var head = this.head,\n        tail = this.tail,\n        len  = this.len;\n    this.reset().uint32(len);\n    if (len) {\n        this.tail.next = head.next; // skip noop\n        this.tail = tail;\n        this.len += len;\n    }\n    return this;\n};\n\n/**\n * Finishes the write operation.\n * @returns {Uint8Array} Finished buffer\n */\nWriter.prototype.finish = function finish() {\n    var head = this.head.next, // skip noop\n        buf  = this.constructor.alloc(this.len),\n        pos  = 0;\n    while (head) {\n        head.fn(head.val, buf, pos);\n        pos += head.len;\n        head = head.next;\n    }\n    // this.head = this.tail = null;\n    return buf;\n};\n\nWriter._configure = function(BufferWriter_) {\n    BufferWriter = BufferWriter_;\n    Writer.create = create();\n    BufferWriter._configure();\n};\n", "\"use strict\";\nmodule.exports = BufferWriter;\n\n// extends Writer\nvar Writer = require(\"./writer\");\n(BufferWriter.prototype = Object.create(Writer.prototype)).constructor = BufferWriter;\n\nvar util = require(\"./util/minimal\");\n\n/**\n * Constructs a new buffer writer instance.\n * @classdesc Wire format writer using node buffers.\n * @extends Writer\n * @constructor\n */\nfunction BufferWriter() {\n    Writer.call(this);\n}\n\nBufferWriter._configure = function () {\n    /**\n     * Allocates a buffer of the specified size.\n     * @function\n     * @param {number} size Buffer size\n     * @returns {Buffer} Buffer\n     */\n    BufferWriter.alloc = util._Buffer_allocUnsafe;\n\n    BufferWriter.writeBytesBuffer = util.Buffer && util.Buffer.prototype instanceof Uint8Array && util.Buffer.prototype.set.name === \"set\"\n        ? function writeBytesBuffer_set(val, buf, pos) {\n          buf.set(val, pos); // faster than copy (requires node >= 4 where Buffers extend Uint8Array and set is properly inherited)\n          // also works for plain array values\n        }\n        /* istanbul ignore next */\n        : function writeBytesBuffer_copy(val, buf, pos) {\n          if (val.copy) // Buffer values\n            val.copy(buf, pos, 0, val.length);\n          else for (var i = 0; i < val.length;) // plain array values\n            buf[pos++] = val[i++];\n        };\n};\n\n\n/**\n * @override\n */\nBufferWriter.prototype.bytes = function write_bytes_buffer(value) {\n    if (util.isString(value))\n        value = util._Buffer_from(value, \"base64\");\n    var len = value.length >>> 0;\n    this.uint32(len);\n    if (len)\n        this._push(BufferWriter.writeBytesBuffer, len, value);\n    return this;\n};\n\nfunction writeStringBuffer(val, buf, pos) {\n    if (val.length < 40) // plain js is faster for short strings (probably due to redundant assertions)\n        util.utf8.write(val, buf, pos);\n    else if (buf.utf8Write)\n        buf.utf8Write(val, pos);\n    else\n        buf.write(val, pos);\n}\n\n/**\n * @override\n */\nBufferWriter.prototype.string = function write_string_buffer(value) {\n    var len = util.Buffer.byteLength(value);\n    this.uint32(len);\n    if (len)\n        this._push(writeStringBuffer, len, value);\n    return this;\n};\n\n\n/**\n * Finishes the write operation.\n * @name BufferWriter#finish\n * @function\n * @returns {Buffer} Finished buffer\n */\n\nBufferWriter._configure();\n", "\"use strict\";\nmodule.exports = Reader;\n\nvar util      = require(\"./util/minimal\");\n\nvar BufferReader; // cyclic\n\nvar LongBits  = util.LongBits,\n    utf8      = util.utf8;\n\n/* istanbul ignore next */\nfunction indexOutOfRange(reader, writeLength) {\n    return RangeError(\"index out of range: \" + reader.pos + \" + \" + (writeLength || 1) + \" > \" + reader.len);\n}\n\n/**\n * Constructs a new reader instance using the specified buffer.\n * @classdesc Wire format reader using `Uint8Array` if available, otherwise `Array`.\n * @constructor\n * @param {Uint8Array} buffer Buffer to read from\n */\nfunction Reader(buffer) {\n\n    /**\n     * Read buffer.\n     * @type {Uint8Array}\n     */\n    this.buf = buffer;\n\n    /**\n     * Read buffer position.\n     * @type {number}\n     */\n    this.pos = 0;\n\n    /**\n     * Read buffer length.\n     * @type {number}\n     */\n    this.len = buffer.length;\n}\n\nvar create_array = typeof Uint8Array !== \"undefined\"\n    ? function create_typed_array(buffer) {\n        if (buffer instanceof Uint8Array || Array.isArray(buffer))\n            return new Reader(buffer);\n        throw Error(\"illegal buffer\");\n    }\n    /* istanbul ignore next */\n    : function create_array(buffer) {\n        if (Array.isArray(buffer))\n            return new Reader(buffer);\n        throw Error(\"illegal buffer\");\n    };\n\nvar create = function create() {\n    return util.Buffer\n        ? function create_buffer_setup(buffer) {\n            return (Reader.create = function create_buffer(buffer) {\n                return util.Buffer.isBuffer(buffer)\n                    ? new BufferReader(buffer)\n                    /* istanbul ignore next */\n                    : create_array(buffer);\n            })(buffer);\n        }\n        /* istanbul ignore next */\n        : create_array;\n};\n\n/**\n * Creates a new reader using the specified buffer.\n * @function\n * @param {Uint8Array|Buffer} buffer Buffer to read from\n * @returns {Reader|BufferReader} A {@link BufferReader} if `buffer` is a Buffer, otherwise a {@link Reader}\n * @throws {Error} If `buffer` is not a valid buffer\n */\nReader.create = create();\n\nReader.prototype._slice = util.Array.prototype.subarray || /* istanbul ignore next */ util.Array.prototype.slice;\n\n/**\n * Reads a varint as an unsigned 32 bit value.\n * @function\n * @returns {number} Value read\n */\nReader.prototype.uint32 = (function read_uint32_setup() {\n    var value = 4294967295; // optimizer type-hint, tends to deopt otherwise (?!)\n    return function read_uint32() {\n        value = (         this.buf[this.pos] & 127       ) >>> 0; if (this.buf[this.pos++] < 128) return value;\n        value = (value | (this.buf[this.pos] & 127) <<  7) >>> 0; if (this.buf[this.pos++] < 128) return value;\n        value = (value | (this.buf[this.pos] & 127) << 14) >>> 0; if (this.buf[this.pos++] < 128) return value;\n        value = (value | (this.buf[this.pos] & 127) << 21) >>> 0; if (this.buf[this.pos++] < 128) return value;\n        value = (value | (this.buf[this.pos] &  15) << 28) >>> 0; if (this.buf[this.pos++] < 128) return value;\n\n        /* istanbul ignore if */\n        if ((this.pos += 5) > this.len) {\n            this.pos = this.len;\n            throw indexOutOfRange(this, 10);\n        }\n        return value;\n    };\n})();\n\n/**\n * Reads a varint as a signed 32 bit value.\n * @returns {number} Value read\n */\nReader.prototype.int32 = function read_int32() {\n    return this.uint32() | 0;\n};\n\n/**\n * Reads a zig-zag encoded varint as a signed 32 bit value.\n * @returns {number} Value read\n */\nReader.prototype.sint32 = function read_sint32() {\n    var value = this.uint32();\n    return value >>> 1 ^ -(value & 1) | 0;\n};\n\n/* eslint-disable no-invalid-this */\n\nfunction readLongVarint() {\n    // tends to deopt with local vars for octet etc.\n    var bits = new LongBits(0, 0);\n    var i = 0;\n    if (this.len - this.pos > 4) { // fast route (lo)\n        for (; i < 4; ++i) {\n            // 1st..4th\n            bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;\n            if (this.buf[this.pos++] < 128)\n                return bits;\n        }\n        // 5th\n        bits.lo = (bits.lo | (this.buf[this.pos] & 127) << 28) >>> 0;\n        bits.hi = (bits.hi | (this.buf[this.pos] & 127) >>  4) >>> 0;\n        if (this.buf[this.pos++] < 128)\n            return bits;\n        i = 0;\n    } else {\n        for (; i < 3; ++i) {\n            /* istanbul ignore if */\n            if (this.pos >= this.len)\n                throw indexOutOfRange(this);\n            // 1st..3th\n            bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;\n            if (this.buf[this.pos++] < 128)\n                return bits;\n        }\n        // 4th\n        bits.lo = (bits.lo | (this.buf[this.pos++] & 127) << i * 7) >>> 0;\n        return bits;\n    }\n    if (this.len - this.pos > 4) { // fast route (hi)\n        for (; i < 5; ++i) {\n            // 6th..10th\n            bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;\n            if (this.buf[this.pos++] < 128)\n                return bits;\n        }\n    } else {\n        for (; i < 5; ++i) {\n            /* istanbul ignore if */\n            if (this.pos >= this.len)\n                throw indexOutOfRange(this);\n            // 6th..10th\n            bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;\n            if (this.buf[this.pos++] < 128)\n                return bits;\n        }\n    }\n    /* istanbul ignore next */\n    throw Error(\"invalid varint encoding\");\n}\n\n/* eslint-enable no-invalid-this */\n\n/**\n * Reads a varint as a signed 64 bit value.\n * @name Reader#int64\n * @function\n * @returns {Long} Value read\n */\n\n/**\n * Reads a varint as an unsigned 64 bit value.\n * @name Reader#uint64\n * @function\n * @returns {Long} Value read\n */\n\n/**\n * Reads a zig-zag encoded varint as a signed 64 bit value.\n * @name Reader#sint64\n * @function\n * @returns {Long} Value read\n */\n\n/**\n * Reads a varint as a boolean.\n * @returns {boolean} Value read\n */\nReader.prototype.bool = function read_bool() {\n    return this.uint32() !== 0;\n};\n\nfunction readFixed32_end(buf, end) { // note that this uses `end`, not `pos`\n    return (buf[end - 4]\n          | buf[end - 3] << 8\n          | buf[end - 2] << 16\n          | buf[end - 1] << 24) >>> 0;\n}\n\n/**\n * Reads fixed 32 bits as an unsigned 32 bit integer.\n * @returns {number} Value read\n */\nReader.prototype.fixed32 = function read_fixed32() {\n\n    /* istanbul ignore if */\n    if (this.pos + 4 > this.len)\n        throw indexOutOfRange(this, 4);\n\n    return readFixed32_end(this.buf, this.pos += 4);\n};\n\n/**\n * Reads fixed 32 bits as a signed 32 bit integer.\n * @returns {number} Value read\n */\nReader.prototype.sfixed32 = function read_sfixed32() {\n\n    /* istanbul ignore if */\n    if (this.pos + 4 > this.len)\n        throw indexOutOfRange(this, 4);\n\n    return readFixed32_end(this.buf, this.pos += 4) | 0;\n};\n\n/* eslint-disable no-invalid-this */\n\nfunction readFixed64(/* this: Reader */) {\n\n    /* istanbul ignore if */\n    if (this.pos + 8 > this.len)\n        throw indexOutOfRange(this, 8);\n\n    return new LongBits(readFixed32_end(this.buf, this.pos += 4), readFixed32_end(this.buf, this.pos += 4));\n}\n\n/* eslint-enable no-invalid-this */\n\n/**\n * Reads fixed 64 bits.\n * @name Reader#fixed64\n * @function\n * @returns {Long} Value read\n */\n\n/**\n * Reads zig-zag encoded fixed 64 bits.\n * @name Reader#sfixed64\n * @function\n * @returns {Long} Value read\n */\n\n/**\n * Reads a float (32 bit) as a number.\n * @function\n * @returns {number} Value read\n */\nReader.prototype.float = function read_float() {\n\n    /* istanbul ignore if */\n    if (this.pos + 4 > this.len)\n        throw indexOutOfRange(this, 4);\n\n    var value = util.float.readFloatLE(this.buf, this.pos);\n    this.pos += 4;\n    return value;\n};\n\n/**\n * Reads a double (64 bit float) as a number.\n * @function\n * @returns {number} Value read\n */\nReader.prototype.double = function read_double() {\n\n    /* istanbul ignore if */\n    if (this.pos + 8 > this.len)\n        throw indexOutOfRange(this, 4);\n\n    var value = util.float.readDoubleLE(this.buf, this.pos);\n    this.pos += 8;\n    return value;\n};\n\n/**\n * Reads a sequence of bytes preceeded by its length as a varint.\n * @returns {Uint8Array} Value read\n */\nReader.prototype.bytes = function read_bytes() {\n    var length = this.uint32(),\n        start  = this.pos,\n        end    = this.pos + length;\n\n    /* istanbul ignore if */\n    if (end > this.len)\n        throw indexOutOfRange(this, length);\n\n    this.pos += length;\n    if (Array.isArray(this.buf)) // plain array\n        return this.buf.slice(start, end);\n\n    if (start === end) { // fix for IE 10/Win8 and others' subarray returning array of size 1\n        var nativeBuffer = util.Buffer;\n        return nativeBuffer\n            ? nativeBuffer.alloc(0)\n            : new this.buf.constructor(0);\n    }\n    return this._slice.call(this.buf, start, end);\n};\n\n/**\n * Reads a string preceeded by its byte length as a varint.\n * @returns {string} Value read\n */\nReader.prototype.string = function read_string() {\n    var bytes = this.bytes();\n    return utf8.read(bytes, 0, bytes.length);\n};\n\n/**\n * Skips the specified number of bytes if specified, otherwise skips a varint.\n * @param {number} [length] Length if known, otherwise a varint is assumed\n * @returns {Reader} `this`\n */\nReader.prototype.skip = function skip(length) {\n    if (typeof length === \"number\") {\n        /* istanbul ignore if */\n        if (this.pos + length > this.len)\n            throw indexOutOfRange(this, length);\n        this.pos += length;\n    } else {\n        do {\n            /* istanbul ignore if */\n            if (this.pos >= this.len)\n                throw indexOutOfRange(this);\n        } while (this.buf[this.pos++] & 128);\n    }\n    return this;\n};\n\n/**\n * Recursion limit.\n * @type {number}\n */\nReader.recursionLimit = util.recursionLimit;\n\n/**\n * Skips the next element of the specified wire type.\n * @param {number} wireType Wire type received\n * @param {number} [depth] Depth of recursion to control nested calls; 0 if omitted\n * @returns {Reader} `this`\n */\nReader.prototype.skipType = function(wireType, depth) {\n    if (depth === undefined) depth = 0;\n    if (depth > Reader.recursionLimit)\n        throw Error(\"maximum nesting depth exceeded\");\n    switch (wireType) {\n        case 0:\n            this.skip();\n            break;\n        case 1:\n            this.skip(8);\n            break;\n        case 2:\n            this.skip(this.uint32());\n            break;\n        case 3:\n            while ((wireType = this.uint32() & 7) !== 4) {\n                this.skipType(wireType, depth + 1);\n            }\n            break;\n        case 5:\n            this.skip(4);\n            break;\n\n        /* istanbul ignore next */\n        default:\n            throw Error(\"invalid wire type \" + wireType + \" at offset \" + this.pos);\n    }\n    return this;\n};\n\nReader._configure = function(BufferReader_) {\n    BufferReader = BufferReader_;\n    Reader.create = create();\n    BufferReader._configure();\n\n    var fn = util.Long ? \"toLong\" : /* istanbul ignore next */ \"toNumber\";\n    util.merge(Reader.prototype, {\n\n        int64: function read_int64() {\n            return readLongVarint.call(this)[fn](false);\n        },\n\n        uint64: function read_uint64() {\n            return readLongVarint.call(this)[fn](true);\n        },\n\n        sint64: function read_sint64() {\n            return readLongVarint.call(this).zzDecode()[fn](false);\n        },\n\n        fixed64: function read_fixed64() {\n            return readFixed64.call(this)[fn](true);\n        },\n\n        sfixed64: function read_sfixed64() {\n            return readFixed64.call(this)[fn](false);\n        }\n\n    });\n};\n", "\"use strict\";\nmodule.exports = BufferReader;\n\n// extends Reader\nvar Reader = require(\"./reader\");\n(BufferReader.prototype = Object.create(Reader.prototype)).constructor = BufferReader;\n\nvar util = require(\"./util/minimal\");\n\n/**\n * Constructs a new buffer reader instance.\n * @classdesc Wire format reader using node buffers.\n * @extends Reader\n * @constructor\n * @param {Buffer} buffer Buffer to read from\n */\nfunction BufferReader(buffer) {\n    Reader.call(this, buffer);\n\n    /**\n     * Read buffer.\n     * @name BufferReader#buf\n     * @type {Buffer}\n     */\n}\n\nBufferReader._configure = function () {\n    /* istanbul ignore else */\n    if (util.Buffer)\n        BufferReader.prototype._slice = util.Buffer.prototype.slice;\n};\n\n\n/**\n * @override\n */\nBufferReader.prototype.string = function read_string_buffer() {\n    var len = this.uint32(); // modifies pos\n    return this.buf.utf8Slice\n        ? this.buf.utf8Slice(this.pos, this.pos = Math.min(this.pos + len, this.len))\n        : this.buf.toString(\"utf-8\", this.pos, this.pos = Math.min(this.pos + len, this.len));\n};\n\n/**\n * Reads a sequence of bytes preceeded by its length as a varint.\n * @name BufferReader#bytes\n * @function\n * @returns {Buffer} Value read\n */\n\nBufferReader._configure();\n", "\"use strict\";\nmodule.exports = Service;\n\nvar util = require(\"../util/minimal\");\n\n// Extends EventEmitter\n(Service.prototype = Object.create(util.EventEmitter.prototype)).constructor = Service;\n\n/**\n * A service method callback as used by {@link rpc.ServiceMethod|ServiceMethod}.\n *\n * Differs from {@link RPCImplCallback} in that it is an actual callback of a service method which may not return `response = null`.\n * @typedef rpc.ServiceMethodCallback\n * @template TRes extends Message<TRes>\n * @type {function}\n * @param {Error|null} error Error, if any\n * @param {TRes} [response] Response message\n * @returns {undefined}\n */\n\n/**\n * A service method part of a {@link rpc.Service} as created by {@link Service.create}.\n * @typedef rpc.ServiceMethod\n * @template TReq extends Message<TReq>\n * @template TRes extends Message<TRes>\n * @type {function}\n * @param {TReq|Properties<TReq>} request Request message or plain object\n * @param {rpc.ServiceMethodCallback<TRes>} [callback] Node-style callback called with the error, if any, and the response message\n * @returns {Promise<Message<TRes>>} Promise if `callback` has been omitted, otherwise `undefined`\n */\n\n/**\n * Constructs a new RPC service instance.\n * @classdesc An RPC service as returned by {@link Service#create}.\n * @exports rpc.Service\n * @extends util.EventEmitter\n * @constructor\n * @param {RPCImpl} rpcImpl RPC implementation\n * @param {boolean} [requestDelimited=false] Whether requests are length-delimited\n * @param {boolean} [responseDelimited=false] Whether responses are length-delimited\n */\nfunction Service(rpcImpl, requestDelimited, responseDelimited) {\n\n    if (typeof rpcImpl !== \"function\")\n        throw TypeError(\"rpcImpl must be a function\");\n\n    util.EventEmitter.call(this);\n\n    /**\n     * RPC implementation. Becomes `null` once the service is ended.\n     * @type {RPCImpl|null}\n     */\n    this.rpcImpl = rpcImpl;\n\n    /**\n     * Whether requests are length-delimited.\n     * @type {boolean}\n     */\n    this.requestDelimited = Boolean(requestDelimited);\n\n    /**\n     * Whether responses are length-delimited.\n     * @type {boolean}\n     */\n    this.responseDelimited = Boolean(responseDelimited);\n}\n\n/**\n * Calls a service method through {@link rpc.Service#rpcImpl|rpcImpl}.\n * @param {Method|rpc.ServiceMethod<TReq,TRes>} method Reflected or static method\n * @param {Constructor<TReq>} requestCtor Request constructor\n * @param {Constructor<TRes>} responseCtor Response constructor\n * @param {TReq|Properties<TReq>} request Request message or plain object\n * @param {rpc.ServiceMethodCallback<TRes>} callback Service callback\n * @returns {undefined}\n * @template TReq extends Message<TReq>\n * @template TRes extends Message<TRes>\n */\nService.prototype.rpcCall = function rpcCall(method, requestCtor, responseCtor, request, callback) {\n\n    if (!request)\n        throw TypeError(\"request must be specified\");\n\n    var self = this;\n    if (!callback)\n        return util.asPromise(rpcCall, self, method, requestCtor, responseCtor, request);\n\n    if (!self.rpcImpl) {\n        setTimeout(function() { callback(Error(\"already ended\")); }, 0);\n        return undefined;\n    }\n\n    try {\n        return self.rpcImpl(\n            method,\n            requestCtor[self.requestDelimited ? \"encodeDelimited\" : \"encode\"](request).finish(),\n            function rpcCallback(err, response) {\n\n                if (err) {\n                    self.emit(\"error\", err, method);\n                    return callback(err);\n                }\n\n                if (response === null) {\n                    self.end(/* endedByRPC */ true);\n                    return undefined;\n                }\n\n                if (!(response instanceof responseCtor)) {\n                    try {\n                        response = responseCtor[self.responseDelimited ? \"decodeDelimited\" : \"decode\"](response);\n                    } catch (err) {\n                        self.emit(\"error\", err, method);\n                        return callback(err);\n                    }\n                }\n\n                self.emit(\"data\", response, method);\n                return callback(null, response);\n            }\n        );\n    } catch (err) {\n        self.emit(\"error\", err, method);\n        setTimeout(function() { callback(err); }, 0);\n        return undefined;\n    }\n};\n\n/**\n * Ends this service and emits the `end` event.\n * @param {boolean} [endedByRPC=false] Whether the service has been ended by the RPC implementation.\n * @returns {rpc.Service} `this`\n */\nService.prototype.end = function end(endedByRPC) {\n    if (this.rpcImpl) {\n        if (!endedByRPC) // signal end to rpcImpl\n            this.rpcImpl(null, null, null);\n        this.rpcImpl = null;\n        this.emit(\"end\").off();\n    }\n    return this;\n};\n", "\"use strict\";\n\n/**\n * Streaming RPC helpers.\n * @namespace\n */\nvar rpc = exports;\n\n/**\n * RPC implementation passed to {@link Service#create} performing a service request on network level, i.e. by utilizing http requests or websockets.\n * @typedef RPCImpl\n * @type {function}\n * @param {Method|rpc.ServiceMethod<Message<{}>,Message<{}>>} method Reflected or static method being called\n * @param {Uint8Array} requestData Request data\n * @param {RPCImplCallback} callback Callback function\n * @returns {undefined}\n * @example\n * function rpcImpl(method, requestData, callback) {\n *     if (protobuf.util.lcFirst(method.name) !== \"myMethod\") // compatible with static code\n *         throw Error(\"no such method\");\n *     asynchronouslyObtainAResponse(requestData, function(err, responseData) {\n *         callback(err, responseData);\n *     });\n * }\n */\n\n/**\n * Node-style callback as used by {@link RPCImpl}.\n * @typedef RPCImplCallback\n * @type {function}\n * @param {Error|null} error Error, if any, otherwise `null`\n * @param {Uint8Array|null} [response] Response data or `null` to signal end of stream, if there hasn't been an error\n * @returns {undefined}\n */\n\nrpc.Service = require(\"./rpc/service\");\n", "\"use strict\";\nmodule.exports = Object.create(null);\n\n/**\n * Named roots.\n * This is where pbjs stores generated structures (the option `-r, --root` specifies a name).\n * Can also be used manually to make roots available across modules.\n * @name roots\n * @type {Object.<string,Root>}\n * @example\n * // pbjs -r myroot -o compiled.js ...\n *\n * // in another module:\n * require(\"./compiled.js\");\n *\n * // in any subsequent module:\n * var root = protobuf.roots[\"myroot\"];\n */\n", "\"use strict\";\nvar protobuf = exports;\n\n/**\n * Build type, one of `\"full\"`, `\"light\"` or `\"minimal\"`.\n * @name build\n * @type {string}\n * @const\n */\nprotobuf.build = \"minimal\";\n\n// Serialization\nprotobuf.Writer       = require(\"./writer\");\nprotobuf.BufferWriter = require(\"./writer_buffer\");\nprotobuf.Reader       = require(\"./reader\");\nprotobuf.BufferReader = require(\"./reader_buffer\");\n\n// Utility\nprotobuf.util         = require(\"./util/minimal\");\nprotobuf.rpc          = require(\"./rpc\");\nprotobuf.roots        = require(\"./roots\");\nprotobuf.configure    = configure;\n\n/* istanbul ignore next */\n/**\n * Reconfigures the library according to the environment.\n * @returns {undefined}\n */\nfunction configure() {\n    protobuf.util._configure();\n    protobuf.Writer._configure(protobuf.BufferWriter);\n    protobuf.Reader._configure(protobuf.BufferReader);\n}\n\n// Set up buffer utility according to the environment\nconfigure();\n", "// minimal library entry point.\n\n\"use strict\";\nmodule.exports = require(\"./src/index-minimal\");\n", "/*eslint-disable block-scoped-var, id-length, no-control-regex, no-magic-numbers, no-prototype-builtins, no-redeclare, no-shadow, no-var, sort-vars*/\n'use strict';\n\nvar $protobuf = require('protobufjs/minimal');\n\n// Common aliases\nvar $Reader = $protobuf.Reader,\n  $Writer = $protobuf.Writer,\n  $util = $protobuf.util;\n\n// Exported root namespace\nvar $root = $protobuf.roots['default'] || ($protobuf.roots['default'] = {});\n\n$root.onnx = (function () {\n  /**\n   * Namespace onnx.\n   * @exports onnx\n   * @namespace\n   */\n  var onnx = {};\n\n  /**\n   * Version enum.\n   * @name onnx.Version\n   * @enum {number}\n   * @property {number} _START_VERSION=0 _START_VERSION value\n   * @property {number} IR_VERSION_2017_10_10=1 IR_VERSION_2017_10_10 value\n   * @property {number} IR_VERSION_2017_10_30=2 IR_VERSION_2017_10_30 value\n   * @property {number} IR_VERSION_2017_11_3=3 IR_VERSION_2017_11_3 value\n   * @property {number} IR_VERSION_2019_1_22=4 IR_VERSION_2019_1_22 value\n   * @property {number} IR_VERSION_2019_3_18=5 IR_VERSION_2019_3_18 value\n   * @property {number} IR_VERSION_2019_9_19=6 IR_VERSION_2019_9_19 value\n   * @property {number} IR_VERSION_2020_5_8=7 IR_VERSION_2020_5_8 value\n   * @property {number} IR_VERSION_2021_7_30=8 IR_VERSION_2021_7_30 value\n   * @property {number} IR_VERSION=9 IR_VERSION value\n   */\n  onnx.Version = (function () {\n    var valuesById = {},\n      values = Object.create(valuesById);\n    values[(valuesById[0] = '_START_VERSION')] = 0;\n    values[(valuesById[1] = 'IR_VERSION_2017_10_10')] = 1;\n    values[(valuesById[2] = 'IR_VERSION_2017_10_30')] = 2;\n    values[(valuesById[3] = 'IR_VERSION_2017_11_3')] = 3;\n    values[(valuesById[4] = 'IR_VERSION_2019_1_22')] = 4;\n    values[(valuesById[5] = 'IR_VERSION_2019_3_18')] = 5;\n    values[(valuesById[6] = 'IR_VERSION_2019_9_19')] = 6;\n    values[(valuesById[7] = 'IR_VERSION_2020_5_8')] = 7;\n    values[(valuesById[8] = 'IR_VERSION_2021_7_30')] = 8;\n    values[(valuesById[9] = 'IR_VERSION')] = 9;\n    return values;\n  })();\n\n  onnx.AttributeProto = (function () {\n    /**\n     * Properties of an AttributeProto.\n     * @memberof onnx\n     * @interface IAttributeProto\n     * @property {string|null} [name] AttributeProto name\n     * @property {string|null} [refAttrName] AttributeProto refAttrName\n     * @property {string|null} [docString] AttributeProto docString\n     * @property {onnx.AttributeProto.AttributeType|null} [type] AttributeProto type\n     * @property {number|null} [f] AttributeProto f\n     * @property {number|Long|null} [i] AttributeProto i\n     * @property {Uint8Array|null} [s] AttributeProto s\n     * @property {onnx.ITensorProto|null} [t] AttributeProto t\n     * @property {onnx.IGraphProto|null} [g] AttributeProto g\n     * @property {onnx.ISparseTensorProto|null} [sparseTensor] AttributeProto sparseTensor\n     * @property {onnx.ITypeProto|null} [tp] AttributeProto tp\n     * @property {Array.<number>|null} [floats] AttributeProto floats\n     * @property {Array.<number|Long>|null} [ints] AttributeProto ints\n     * @property {Array.<Uint8Array>|null} [strings] AttributeProto strings\n     * @property {Array.<onnx.ITensorProto>|null} [tensors] AttributeProto tensors\n     * @property {Array.<onnx.IGraphProto>|null} [graphs] AttributeProto graphs\n     * @property {Array.<onnx.ISparseTensorProto>|null} [sparseTensors] AttributeProto sparseTensors\n     * @property {Array.<onnx.ITypeProto>|null} [typeProtos] AttributeProto typeProtos\n     */\n\n    /**\n     * Constructs a new AttributeProto.\n     * @memberof onnx\n     * @classdesc Represents an AttributeProto.\n     * @implements IAttributeProto\n     * @constructor\n     * @param {onnx.IAttributeProto=} [properties] Properties to set\n     */\n    function AttributeProto(properties) {\n      this.floats = [];\n      this.ints = [];\n      this.strings = [];\n      this.tensors = [];\n      this.graphs = [];\n      this.sparseTensors = [];\n      this.typeProtos = [];\n      if (properties)\n        for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n          if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * AttributeProto name.\n     * @member {string} name\n     * @memberof onnx.AttributeProto\n     * @instance\n     */\n    AttributeProto.prototype.name = '';\n\n    /**\n     * AttributeProto refAttrName.\n     * @member {string} refAttrName\n     * @memberof onnx.AttributeProto\n     * @instance\n     */\n    AttributeProto.prototype.refAttrName = '';\n\n    /**\n     * AttributeProto docString.\n     * @member {string} docString\n     * @memberof onnx.AttributeProto\n     * @instance\n     */\n    AttributeProto.prototype.docString = '';\n\n    /**\n     * AttributeProto type.\n     * @member {onnx.AttributeProto.AttributeType} type\n     * @memberof onnx.AttributeProto\n     * @instance\n     */\n    AttributeProto.prototype.type = 0;\n\n    /**\n     * AttributeProto f.\n     * @member {number} f\n     * @memberof onnx.AttributeProto\n     * @instance\n     */\n    AttributeProto.prototype.f = 0;\n\n    /**\n     * AttributeProto i.\n     * @member {number|Long} i\n     * @memberof onnx.AttributeProto\n     * @instance\n     */\n    AttributeProto.prototype.i = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;\n\n    /**\n     * AttributeProto s.\n     * @member {Uint8Array} s\n     * @memberof onnx.AttributeProto\n     * @instance\n     */\n    AttributeProto.prototype.s = $util.newBuffer([]);\n\n    /**\n     * AttributeProto t.\n     * @member {onnx.ITensorProto|null|undefined} t\n     * @memberof onnx.AttributeProto\n     * @instance\n     */\n    AttributeProto.prototype.t = null;\n\n    /**\n     * AttributeProto g.\n     * @member {onnx.IGraphProto|null|undefined} g\n     * @memberof onnx.AttributeProto\n     * @instance\n     */\n    AttributeProto.prototype.g = null;\n\n    /**\n     * AttributeProto sparseTensor.\n     * @member {onnx.ISparseTensorProto|null|undefined} sparseTensor\n     * @memberof onnx.AttributeProto\n     * @instance\n     */\n    AttributeProto.prototype.sparseTensor = null;\n\n    /**\n     * AttributeProto tp.\n     * @member {onnx.ITypeProto|null|undefined} tp\n     * @memberof onnx.AttributeProto\n     * @instance\n     */\n    AttributeProto.prototype.tp = null;\n\n    /**\n     * AttributeProto floats.\n     * @member {Array.<number>} floats\n     * @memberof onnx.AttributeProto\n     * @instance\n     */\n    AttributeProto.prototype.floats = $util.emptyArray;\n\n    /**\n     * AttributeProto ints.\n     * @member {Array.<number|Long>} ints\n     * @memberof onnx.AttributeProto\n     * @instance\n     */\n    AttributeProto.prototype.ints = $util.emptyArray;\n\n    /**\n     * AttributeProto strings.\n     * @member {Array.<Uint8Array>} strings\n     * @memberof onnx.AttributeProto\n     * @instance\n     */\n    AttributeProto.prototype.strings = $util.emptyArray;\n\n    /**\n     * AttributeProto tensors.\n     * @member {Array.<onnx.ITensorProto>} tensors\n     * @memberof onnx.AttributeProto\n     * @instance\n     */\n    AttributeProto.prototype.tensors = $util.emptyArray;\n\n    /**\n     * AttributeProto graphs.\n     * @member {Array.<onnx.IGraphProto>} graphs\n     * @memberof onnx.AttributeProto\n     * @instance\n     */\n    AttributeProto.prototype.graphs = $util.emptyArray;\n\n    /**\n     * AttributeProto sparseTensors.\n     * @member {Array.<onnx.ISparseTensorProto>} sparseTensors\n     * @memberof onnx.AttributeProto\n     * @instance\n     */\n    AttributeProto.prototype.sparseTensors = $util.emptyArray;\n\n    /**\n     * AttributeProto typeProtos.\n     * @member {Array.<onnx.ITypeProto>} typeProtos\n     * @memberof onnx.AttributeProto\n     * @instance\n     */\n    AttributeProto.prototype.typeProtos = $util.emptyArray;\n\n    /**\n     * Creates a new AttributeProto instance using the specified properties.\n     * @function create\n     * @memberof onnx.AttributeProto\n     * @static\n     * @param {onnx.IAttributeProto=} [properties] Properties to set\n     * @returns {onnx.AttributeProto} AttributeProto instance\n     */\n    AttributeProto.create = function create(properties) {\n      return new AttributeProto(properties);\n    };\n\n    /**\n     * Encodes the specified AttributeProto message. Does not implicitly {@link onnx.AttributeProto.verify|verify} messages.\n     * @function encode\n     * @memberof onnx.AttributeProto\n     * @static\n     * @param {onnx.IAttributeProto} message AttributeProto message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    AttributeProto.encode = function encode(message, writer) {\n      if (!writer) writer = $Writer.create();\n      if (message.name != null && Object.hasOwnProperty.call(message, 'name'))\n        writer.uint32(/* id 1, wireType 2 =*/ 10).string(message.name);\n      if (message.f != null && Object.hasOwnProperty.call(message, 'f'))\n        writer.uint32(/* id 2, wireType 5 =*/ 21).float(message.f);\n      if (message.i != null && Object.hasOwnProperty.call(message, 'i'))\n        writer.uint32(/* id 3, wireType 0 =*/ 24).int64(message.i);\n      if (message.s != null && Object.hasOwnProperty.call(message, 's'))\n        writer.uint32(/* id 4, wireType 2 =*/ 34).bytes(message.s);\n      if (message.t != null && Object.hasOwnProperty.call(message, 't'))\n        $root.onnx.TensorProto.encode(message.t, writer.uint32(/* id 5, wireType 2 =*/ 42).fork()).ldelim();\n      if (message.g != null && Object.hasOwnProperty.call(message, 'g'))\n        $root.onnx.GraphProto.encode(message.g, writer.uint32(/* id 6, wireType 2 =*/ 50).fork()).ldelim();\n      if (message.floats != null && message.floats.length) {\n        writer.uint32(/* id 7, wireType 2 =*/ 58).fork();\n        for (var i = 0; i < message.floats.length; ++i) writer.float(message.floats[i]);\n        writer.ldelim();\n      }\n      if (message.ints != null && message.ints.length) {\n        writer.uint32(/* id 8, wireType 2 =*/ 66).fork();\n        for (var i = 0; i < message.ints.length; ++i) writer.int64(message.ints[i]);\n        writer.ldelim();\n      }\n      if (message.strings != null && message.strings.length)\n        for (var i = 0; i < message.strings.length; ++i)\n          writer.uint32(/* id 9, wireType 2 =*/ 74).bytes(message.strings[i]);\n      if (message.tensors != null && message.tensors.length)\n        for (var i = 0; i < message.tensors.length; ++i)\n          $root.onnx.TensorProto.encode(message.tensors[i], writer.uint32(/* id 10, wireType 2 =*/ 82).fork()).ldelim();\n      if (message.graphs != null && message.graphs.length)\n        for (var i = 0; i < message.graphs.length; ++i)\n          $root.onnx.GraphProto.encode(message.graphs[i], writer.uint32(/* id 11, wireType 2 =*/ 90).fork()).ldelim();\n      if (message.docString != null && Object.hasOwnProperty.call(message, 'docString'))\n        writer.uint32(/* id 13, wireType 2 =*/ 106).string(message.docString);\n      if (message.tp != null && Object.hasOwnProperty.call(message, 'tp'))\n        $root.onnx.TypeProto.encode(message.tp, writer.uint32(/* id 14, wireType 2 =*/ 114).fork()).ldelim();\n      if (message.typeProtos != null && message.typeProtos.length)\n        for (var i = 0; i < message.typeProtos.length; ++i)\n          $root.onnx.TypeProto.encode(\n            message.typeProtos[i],\n            writer.uint32(/* id 15, wireType 2 =*/ 122).fork(),\n          ).ldelim();\n      if (message.type != null && Object.hasOwnProperty.call(message, 'type'))\n        writer.uint32(/* id 20, wireType 0 =*/ 160).int32(message.type);\n      if (message.refAttrName != null && Object.hasOwnProperty.call(message, 'refAttrName'))\n        writer.uint32(/* id 21, wireType 2 =*/ 170).string(message.refAttrName);\n      if (message.sparseTensor != null && Object.hasOwnProperty.call(message, 'sparseTensor'))\n        $root.onnx.SparseTensorProto.encode(\n          message.sparseTensor,\n          writer.uint32(/* id 22, wireType 2 =*/ 178).fork(),\n        ).ldelim();\n      if (message.sparseTensors != null && message.sparseTensors.length)\n        for (var i = 0; i < message.sparseTensors.length; ++i)\n          $root.onnx.SparseTensorProto.encode(\n            message.sparseTensors[i],\n            writer.uint32(/* id 23, wireType 2 =*/ 186).fork(),\n          ).ldelim();\n      return writer;\n    };\n\n    /**\n     * Encodes the specified AttributeProto message, length delimited. Does not implicitly {@link onnx.AttributeProto.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof onnx.AttributeProto\n     * @static\n     * @param {onnx.IAttributeProto} message AttributeProto message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    AttributeProto.encodeDelimited = function encodeDelimited(message, writer) {\n      return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes an AttributeProto message from the specified reader or buffer.\n     * @function decode\n     * @memberof onnx.AttributeProto\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {onnx.AttributeProto} AttributeProto\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    AttributeProto.decode = function decode(reader, length) {\n      if (!(reader instanceof $Reader)) reader = $Reader.create(reader);\n      var end = length === undefined ? reader.len : reader.pos + length,\n        message = new $root.onnx.AttributeProto();\n      while (reader.pos < end) {\n        var tag = reader.uint32();\n        switch (tag >>> 3) {\n          case 1: {\n            message.name = reader.string();\n            break;\n          }\n          case 21: {\n            message.refAttrName = reader.string();\n            break;\n          }\n          case 13: {\n            message.docString = reader.string();\n            break;\n          }\n          case 20: {\n            message.type = reader.int32();\n            break;\n          }\n          case 2: {\n            message.f = reader.float();\n            break;\n          }\n          case 3: {\n            message.i = reader.int64();\n            break;\n          }\n          case 4: {\n            message.s = reader.bytes();\n            break;\n          }\n          case 5: {\n            message.t = $root.onnx.TensorProto.decode(reader, reader.uint32());\n            break;\n          }\n          case 6: {\n            message.g = $root.onnx.GraphProto.decode(reader, reader.uint32());\n            break;\n          }\n          case 22: {\n            message.sparseTensor = $root.onnx.SparseTensorProto.decode(reader, reader.uint32());\n            break;\n          }\n          case 14: {\n            message.tp = $root.onnx.TypeProto.decode(reader, reader.uint32());\n            break;\n          }\n          case 7: {\n            if (!(message.floats && message.floats.length)) message.floats = [];\n            if ((tag & 7) === 2) {\n              var end2 = reader.uint32() + reader.pos;\n              while (reader.pos < end2) message.floats.push(reader.float());\n            } else message.floats.push(reader.float());\n            break;\n          }\n          case 8: {\n            if (!(message.ints && message.ints.length)) message.ints = [];\n            if ((tag & 7) === 2) {\n              var end2 = reader.uint32() + reader.pos;\n              while (reader.pos < end2) message.ints.push(reader.int64());\n            } else message.ints.push(reader.int64());\n            break;\n          }\n          case 9: {\n            if (!(message.strings && message.strings.length)) message.strings = [];\n            message.strings.push(reader.bytes());\n            break;\n          }\n          case 10: {\n            if (!(message.tensors && message.tensors.length)) message.tensors = [];\n            message.tensors.push($root.onnx.TensorProto.decode(reader, reader.uint32()));\n            break;\n          }\n          case 11: {\n            if (!(message.graphs && message.graphs.length)) message.graphs = [];\n            message.graphs.push($root.onnx.GraphProto.decode(reader, reader.uint32()));\n            break;\n          }\n          case 23: {\n            if (!(message.sparseTensors && message.sparseTensors.length)) message.sparseTensors = [];\n            message.sparseTensors.push($root.onnx.SparseTensorProto.decode(reader, reader.uint32()));\n            break;\n          }\n          case 15: {\n            if (!(message.typeProtos && message.typeProtos.length)) message.typeProtos = [];\n            message.typeProtos.push($root.onnx.TypeProto.decode(reader, reader.uint32()));\n            break;\n          }\n          default:\n            reader.skipType(tag & 7);\n            break;\n        }\n      }\n      return message;\n    };\n\n    /**\n     * Decodes an AttributeProto message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof onnx.AttributeProto\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {onnx.AttributeProto} AttributeProto\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    AttributeProto.decodeDelimited = function decodeDelimited(reader) {\n      if (!(reader instanceof $Reader)) reader = new $Reader(reader);\n      return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies an AttributeProto message.\n     * @function verify\n     * @memberof onnx.AttributeProto\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    AttributeProto.verify = function verify(message) {\n      if (typeof message !== 'object' || message === null) return 'object expected';\n      if (message.name != null && message.hasOwnProperty('name'))\n        if (!$util.isString(message.name)) return 'name: string expected';\n      if (message.refAttrName != null && message.hasOwnProperty('refAttrName'))\n        if (!$util.isString(message.refAttrName)) return 'refAttrName: string expected';\n      if (message.docString != null && message.hasOwnProperty('docString'))\n        if (!$util.isString(message.docString)) return 'docString: string expected';\n      if (message.type != null && message.hasOwnProperty('type'))\n        switch (message.type) {\n          default:\n            return 'type: enum value expected';\n          case 0:\n          case 1:\n          case 2:\n          case 3:\n          case 4:\n          case 5:\n          case 11:\n          case 13:\n          case 6:\n          case 7:\n          case 8:\n          case 9:\n          case 10:\n          case 12:\n          case 14:\n            break;\n        }\n      if (message.f != null && message.hasOwnProperty('f'))\n        if (typeof message.f !== 'number') return 'f: number expected';\n      if (message.i != null && message.hasOwnProperty('i'))\n        if (\n          !$util.isInteger(message.i) &&\n          !(message.i && $util.isInteger(message.i.low) && $util.isInteger(message.i.high))\n        )\n          return 'i: integer|Long expected';\n      if (message.s != null && message.hasOwnProperty('s'))\n        if (!((message.s && typeof message.s.length === 'number') || $util.isString(message.s)))\n          return 's: buffer expected';\n      if (message.t != null && message.hasOwnProperty('t')) {\n        var error = $root.onnx.TensorProto.verify(message.t);\n        if (error) return 't.' + error;\n      }\n      if (message.g != null && message.hasOwnProperty('g')) {\n        var error = $root.onnx.GraphProto.verify(message.g);\n        if (error) return 'g.' + error;\n      }\n      if (message.sparseTensor != null && message.hasOwnProperty('sparseTensor')) {\n        var error = $root.onnx.SparseTensorProto.verify(message.sparseTensor);\n        if (error) return 'sparseTensor.' + error;\n      }\n      if (message.tp != null && message.hasOwnProperty('tp')) {\n        var error = $root.onnx.TypeProto.verify(message.tp);\n        if (error) return 'tp.' + error;\n      }\n      if (message.floats != null && message.hasOwnProperty('floats')) {\n        if (!Array.isArray(message.floats)) return 'floats: array expected';\n        for (var i = 0; i < message.floats.length; ++i)\n          if (typeof message.floats[i] !== 'number') return 'floats: number[] expected';\n      }\n      if (message.ints != null && message.hasOwnProperty('ints')) {\n        if (!Array.isArray(message.ints)) return 'ints: array expected';\n        for (var i = 0; i < message.ints.length; ++i)\n          if (\n            !$util.isInteger(message.ints[i]) &&\n            !(message.ints[i] && $util.isInteger(message.ints[i].low) && $util.isInteger(message.ints[i].high))\n          )\n            return 'ints: integer|Long[] expected';\n      }\n      if (message.strings != null && message.hasOwnProperty('strings')) {\n        if (!Array.isArray(message.strings)) return 'strings: array expected';\n        for (var i = 0; i < message.strings.length; ++i)\n          if (\n            !(\n              (message.strings[i] && typeof message.strings[i].length === 'number') ||\n              $util.isString(message.strings[i])\n            )\n          )\n            return 'strings: buffer[] expected';\n      }\n      if (message.tensors != null && message.hasOwnProperty('tensors')) {\n        if (!Array.isArray(message.tensors)) return 'tensors: array expected';\n        for (var i = 0; i < message.tensors.length; ++i) {\n          var error = $root.onnx.TensorProto.verify(message.tensors[i]);\n          if (error) return 'tensors.' + error;\n        }\n      }\n      if (message.graphs != null && message.hasOwnProperty('graphs')) {\n        if (!Array.isArray(message.graphs)) return 'graphs: array expected';\n        for (var i = 0; i < message.graphs.length; ++i) {\n          var error = $root.onnx.GraphProto.verify(message.graphs[i]);\n          if (error) return 'graphs.' + error;\n        }\n      }\n      if (message.sparseTensors != null && message.hasOwnProperty('sparseTensors')) {\n        if (!Array.isArray(message.sparseTensors)) return 'sparseTensors: array expected';\n        for (var i = 0; i < message.sparseTensors.length; ++i) {\n          var error = $root.onnx.SparseTensorProto.verify(message.sparseTensors[i]);\n          if (error) return 'sparseTensors.' + error;\n        }\n      }\n      if (message.typeProtos != null && message.hasOwnProperty('typeProtos')) {\n        if (!Array.isArray(message.typeProtos)) return 'typeProtos: array expected';\n        for (var i = 0; i < message.typeProtos.length; ++i) {\n          var error = $root.onnx.TypeProto.verify(message.typeProtos[i]);\n          if (error) return 'typeProtos.' + error;\n        }\n      }\n      return null;\n    };\n\n    /**\n     * Creates an AttributeProto message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof onnx.AttributeProto\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {onnx.AttributeProto} AttributeProto\n     */\n    AttributeProto.fromObject = function fromObject(object) {\n      if (object instanceof $root.onnx.AttributeProto) return object;\n      var message = new $root.onnx.AttributeProto();\n      if (object.name != null) message.name = String(object.name);\n      if (object.refAttrName != null) message.refAttrName = String(object.refAttrName);\n      if (object.docString != null) message.docString = String(object.docString);\n      switch (object.type) {\n        default:\n          if (typeof object.type === 'number') {\n            message.type = object.type;\n            break;\n          }\n          break;\n        case 'UNDEFINED':\n        case 0:\n          message.type = 0;\n          break;\n        case 'FLOAT':\n        case 1:\n          message.type = 1;\n          break;\n        case 'INT':\n        case 2:\n          message.type = 2;\n          break;\n        case 'STRING':\n        case 3:\n          message.type = 3;\n          break;\n        case 'TENSOR':\n        case 4:\n          message.type = 4;\n          break;\n        case 'GRAPH':\n        case 5:\n          message.type = 5;\n          break;\n        case 'SPARSE_TENSOR':\n        case 11:\n          message.type = 11;\n          break;\n        case 'TYPE_PROTO':\n        case 13:\n          message.type = 13;\n          break;\n        case 'FLOATS':\n        case 6:\n          message.type = 6;\n          break;\n        case 'INTS':\n        case 7:\n          message.type = 7;\n          break;\n        case 'STRINGS':\n        case 8:\n          message.type = 8;\n          break;\n        case 'TENSORS':\n        case 9:\n          message.type = 9;\n          break;\n        case 'GRAPHS':\n        case 10:\n          message.type = 10;\n          break;\n        case 'SPARSE_TENSORS':\n        case 12:\n          message.type = 12;\n          break;\n        case 'TYPE_PROTOS':\n        case 14:\n          message.type = 14;\n          break;\n      }\n      if (object.f != null) message.f = Number(object.f);\n      if (object.i != null)\n        if ($util.Long) (message.i = $util.Long.fromValue(object.i)).unsigned = false;\n        else if (typeof object.i === 'string') message.i = parseInt(object.i, 10);\n        else if (typeof object.i === 'number') message.i = object.i;\n        else if (typeof object.i === 'object')\n          message.i = new $util.LongBits(object.i.low >>> 0, object.i.high >>> 0).toNumber();\n      if (object.s != null)\n        if (typeof object.s === 'string')\n          $util.base64.decode(object.s, (message.s = $util.newBuffer($util.base64.length(object.s))), 0);\n        else if (object.s.length >= 0) message.s = object.s;\n      if (object.t != null) {\n        if (typeof object.t !== 'object') throw TypeError('.onnx.AttributeProto.t: object expected');\n        message.t = $root.onnx.TensorProto.fromObject(object.t);\n      }\n      if (object.g != null) {\n        if (typeof object.g !== 'object') throw TypeError('.onnx.AttributeProto.g: object expected');\n        message.g = $root.onnx.GraphProto.fromObject(object.g);\n      }\n      if (object.sparseTensor != null) {\n        if (typeof object.sparseTensor !== 'object')\n          throw TypeError('.onnx.AttributeProto.sparseTensor: object expected');\n        message.sparseTensor = $root.onnx.SparseTensorProto.fromObject(object.sparseTensor);\n      }\n      if (object.tp != null) {\n        if (typeof object.tp !== 'object') throw TypeError('.onnx.AttributeProto.tp: object expected');\n        message.tp = $root.onnx.TypeProto.fromObject(object.tp);\n      }\n      if (object.floats) {\n        if (!Array.isArray(object.floats)) throw TypeError('.onnx.AttributeProto.floats: array expected');\n        message.floats = [];\n        for (var i = 0; i < object.floats.length; ++i) message.floats[i] = Number(object.floats[i]);\n      }\n      if (object.ints) {\n        if (!Array.isArray(object.ints)) throw TypeError('.onnx.AttributeProto.ints: array expected');\n        message.ints = [];\n        for (var i = 0; i < object.ints.length; ++i)\n          if ($util.Long) (message.ints[i] = $util.Long.fromValue(object.ints[i])).unsigned = false;\n          else if (typeof object.ints[i] === 'string') message.ints[i] = parseInt(object.ints[i], 10);\n          else if (typeof object.ints[i] === 'number') message.ints[i] = object.ints[i];\n          else if (typeof object.ints[i] === 'object')\n            message.ints[i] = new $util.LongBits(object.ints[i].low >>> 0, object.ints[i].high >>> 0).toNumber();\n      }\n      if (object.strings) {\n        if (!Array.isArray(object.strings)) throw TypeError('.onnx.AttributeProto.strings: array expected');\n        message.strings = [];\n        for (var i = 0; i < object.strings.length; ++i)\n          if (typeof object.strings[i] === 'string')\n            $util.base64.decode(\n              object.strings[i],\n              (message.strings[i] = $util.newBuffer($util.base64.length(object.strings[i]))),\n              0,\n            );\n          else if (object.strings[i].length >= 0) message.strings[i] = object.strings[i];\n      }\n      if (object.tensors) {\n        if (!Array.isArray(object.tensors)) throw TypeError('.onnx.AttributeProto.tensors: array expected');\n        message.tensors = [];\n        for (var i = 0; i < object.tensors.length; ++i) {\n          if (typeof object.tensors[i] !== 'object') throw TypeError('.onnx.AttributeProto.tensors: object expected');\n          message.tensors[i] = $root.onnx.TensorProto.fromObject(object.tensors[i]);\n        }\n      }\n      if (object.graphs) {\n        if (!Array.isArray(object.graphs)) throw TypeError('.onnx.AttributeProto.graphs: array expected');\n        message.graphs = [];\n        for (var i = 0; i < object.graphs.length; ++i) {\n          if (typeof object.graphs[i] !== 'object') throw TypeError('.onnx.AttributeProto.graphs: object expected');\n          message.graphs[i] = $root.onnx.GraphProto.fromObject(object.graphs[i]);\n        }\n      }\n      if (object.sparseTensors) {\n        if (!Array.isArray(object.sparseTensors)) throw TypeError('.onnx.AttributeProto.sparseTensors: array expected');\n        message.sparseTensors = [];\n        for (var i = 0; i < object.sparseTensors.length; ++i) {\n          if (typeof object.sparseTensors[i] !== 'object')\n            throw TypeError('.onnx.AttributeProto.sparseTensors: object expected');\n          message.sparseTensors[i] = $root.onnx.SparseTensorProto.fromObject(object.sparseTensors[i]);\n        }\n      }\n      if (object.typeProtos) {\n        if (!Array.isArray(object.typeProtos)) throw TypeError('.onnx.AttributeProto.typeProtos: array expected');\n        message.typeProtos = [];\n        for (var i = 0; i < object.typeProtos.length; ++i) {\n          if (typeof object.typeProtos[i] !== 'object')\n            throw TypeError('.onnx.AttributeProto.typeProtos: object expected');\n          message.typeProtos[i] = $root.onnx.TypeProto.fromObject(object.typeProtos[i]);\n        }\n      }\n      return message;\n    };\n\n    /**\n     * Creates a plain object from an AttributeProto message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof onnx.AttributeProto\n     * @static\n     * @param {onnx.AttributeProto} message AttributeProto\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    AttributeProto.toObject = function toObject(message, options) {\n      if (!options) options = {};\n      var object = {};\n      if (options.arrays || options.defaults) {\n        object.floats = [];\n        object.ints = [];\n        object.strings = [];\n        object.tensors = [];\n        object.graphs = [];\n        object.typeProtos = [];\n        object.sparseTensors = [];\n      }\n      if (options.defaults) {\n        object.name = '';\n        object.f = 0;\n        if ($util.Long) {\n          var long = new $util.Long(0, 0, false);\n          object.i = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;\n        } else object.i = options.longs === String ? '0' : 0;\n        if (options.bytes === String) object.s = '';\n        else {\n          object.s = [];\n          if (options.bytes !== Array) object.s = $util.newBuffer(object.s);\n        }\n        object.t = null;\n        object.g = null;\n        object.docString = '';\n        object.tp = null;\n        object.type = options.enums === String ? 'UNDEFINED' : 0;\n        object.refAttrName = '';\n        object.sparseTensor = null;\n      }\n      if (message.name != null && message.hasOwnProperty('name')) object.name = message.name;\n      if (message.f != null && message.hasOwnProperty('f'))\n        object.f = options.json && !isFinite(message.f) ? String(message.f) : message.f;\n      if (message.i != null && message.hasOwnProperty('i'))\n        if (typeof message.i === 'number') object.i = options.longs === String ? String(message.i) : message.i;\n        else\n          object.i =\n            options.longs === String\n              ? $util.Long.prototype.toString.call(message.i)\n              : options.longs === Number\n                ? new $util.LongBits(message.i.low >>> 0, message.i.high >>> 0).toNumber()\n                : message.i;\n      if (message.s != null && message.hasOwnProperty('s'))\n        object.s =\n          options.bytes === String\n            ? $util.base64.encode(message.s, 0, message.s.length)\n            : options.bytes === Array\n              ? Array.prototype.slice.call(message.s)\n              : message.s;\n      if (message.t != null && message.hasOwnProperty('t'))\n        object.t = $root.onnx.TensorProto.toObject(message.t, options);\n      if (message.g != null && message.hasOwnProperty('g'))\n        object.g = $root.onnx.GraphProto.toObject(message.g, options);\n      if (message.floats && message.floats.length) {\n        object.floats = [];\n        for (var j = 0; j < message.floats.length; ++j)\n          object.floats[j] =\n            options.json && !isFinite(message.floats[j]) ? String(message.floats[j]) : message.floats[j];\n      }\n      if (message.ints && message.ints.length) {\n        object.ints = [];\n        for (var j = 0; j < message.ints.length; ++j)\n          if (typeof message.ints[j] === 'number')\n            object.ints[j] = options.longs === String ? String(message.ints[j]) : message.ints[j];\n          else\n            object.ints[j] =\n              options.longs === String\n                ? $util.Long.prototype.toString.call(message.ints[j])\n                : options.longs === Number\n                  ? new $util.LongBits(message.ints[j].low >>> 0, message.ints[j].high >>> 0).toNumber()\n                  : message.ints[j];\n      }\n      if (message.strings && message.strings.length) {\n        object.strings = [];\n        for (var j = 0; j < message.strings.length; ++j)\n          object.strings[j] =\n            options.bytes === String\n              ? $util.base64.encode(message.strings[j], 0, message.strings[j].length)\n              : options.bytes === Array\n                ? Array.prototype.slice.call(message.strings[j])\n                : message.strings[j];\n      }\n      if (message.tensors && message.tensors.length) {\n        object.tensors = [];\n        for (var j = 0; j < message.tensors.length; ++j)\n          object.tensors[j] = $root.onnx.TensorProto.toObject(message.tensors[j], options);\n      }\n      if (message.graphs && message.graphs.length) {\n        object.graphs = [];\n        for (var j = 0; j < message.graphs.length; ++j)\n          object.graphs[j] = $root.onnx.GraphProto.toObject(message.graphs[j], options);\n      }\n      if (message.docString != null && message.hasOwnProperty('docString')) object.docString = message.docString;\n      if (message.tp != null && message.hasOwnProperty('tp'))\n        object.tp = $root.onnx.TypeProto.toObject(message.tp, options);\n      if (message.typeProtos && message.typeProtos.length) {\n        object.typeProtos = [];\n        for (var j = 0; j < message.typeProtos.length; ++j)\n          object.typeProtos[j] = $root.onnx.TypeProto.toObject(message.typeProtos[j], options);\n      }\n      if (message.type != null && message.hasOwnProperty('type'))\n        object.type =\n          options.enums === String\n            ? $root.onnx.AttributeProto.AttributeType[message.type] === undefined\n              ? message.type\n              : $root.onnx.AttributeProto.AttributeType[message.type]\n            : message.type;\n      if (message.refAttrName != null && message.hasOwnProperty('refAttrName'))\n        object.refAttrName = message.refAttrName;\n      if (message.sparseTensor != null && message.hasOwnProperty('sparseTensor'))\n        object.sparseTensor = $root.onnx.SparseTensorProto.toObject(message.sparseTensor, options);\n      if (message.sparseTensors && message.sparseTensors.length) {\n        object.sparseTensors = [];\n        for (var j = 0; j < message.sparseTensors.length; ++j)\n          object.sparseTensors[j] = $root.onnx.SparseTensorProto.toObject(message.sparseTensors[j], options);\n      }\n      return object;\n    };\n\n    /**\n     * Converts this AttributeProto to JSON.\n     * @function toJSON\n     * @memberof onnx.AttributeProto\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    AttributeProto.prototype.toJSON = function toJSON() {\n      return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    /**\n     * Gets the default type url for AttributeProto\n     * @function getTypeUrl\n     * @memberof onnx.AttributeProto\n     * @static\n     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default \"type.googleapis.com\")\n     * @returns {string} The default type url\n     */\n    AttributeProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {\n      if (typeUrlPrefix === undefined) {\n        typeUrlPrefix = 'type.googleapis.com';\n      }\n      return typeUrlPrefix + '/onnx.AttributeProto';\n    };\n\n    /**\n     * AttributeType enum.\n     * @name onnx.AttributeProto.AttributeType\n     * @enum {number}\n     * @property {number} UNDEFINED=0 UNDEFINED value\n     * @property {number} FLOAT=1 FLOAT value\n     * @property {number} INT=2 INT value\n     * @property {number} STRING=3 STRING value\n     * @property {number} TENSOR=4 TENSOR value\n     * @property {number} GRAPH=5 GRAPH value\n     * @property {number} SPARSE_TENSOR=11 SPARSE_TENSOR value\n     * @property {number} TYPE_PROTO=13 TYPE_PROTO value\n     * @property {number} FLOATS=6 FLOATS value\n     * @property {number} INTS=7 INTS value\n     * @property {number} STRINGS=8 STRINGS value\n     * @property {number} TENSORS=9 TENSORS value\n     * @property {number} GRAPHS=10 GRAPHS value\n     * @property {number} SPARSE_TENSORS=12 SPARSE_TENSORS value\n     * @property {number} TYPE_PROTOS=14 TYPE_PROTOS value\n     */\n    AttributeProto.AttributeType = (function () {\n      var valuesById = {},\n        values = Object.create(valuesById);\n      values[(valuesById[0] = 'UNDEFINED')] = 0;\n      values[(valuesById[1] = 'FLOAT')] = 1;\n      values[(valuesById[2] = 'INT')] = 2;\n      values[(valuesById[3] = 'STRING')] = 3;\n      values[(valuesById[4] = 'TENSOR')] = 4;\n      values[(valuesById[5] = 'GRAPH')] = 5;\n      values[(valuesById[11] = 'SPARSE_TENSOR')] = 11;\n      values[(valuesById[13] = 'TYPE_PROTO')] = 13;\n      values[(valuesById[6] = 'FLOATS')] = 6;\n      values[(valuesById[7] = 'INTS')] = 7;\n      values[(valuesById[8] = 'STRINGS')] = 8;\n      values[(valuesById[9] = 'TENSORS')] = 9;\n      values[(valuesById[10] = 'GRAPHS')] = 10;\n      values[(valuesById[12] = 'SPARSE_TENSORS')] = 12;\n      values[(valuesById[14] = 'TYPE_PROTOS')] = 14;\n      return values;\n    })();\n\n    return AttributeProto;\n  })();\n\n  onnx.ValueInfoProto = (function () {\n    /**\n     * Properties of a ValueInfoProto.\n     * @memberof onnx\n     * @interface IValueInfoProto\n     * @property {string|null} [name] ValueInfoProto name\n     * @property {onnx.ITypeProto|null} [type] ValueInfoProto type\n     * @property {string|null} [docString] ValueInfoProto docString\n     */\n\n    /**\n     * Constructs a new ValueInfoProto.\n     * @memberof onnx\n     * @classdesc Represents a ValueInfoProto.\n     * @implements IValueInfoProto\n     * @constructor\n     * @param {onnx.IValueInfoProto=} [properties] Properties to set\n     */\n    function ValueInfoProto(properties) {\n      if (properties)\n        for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n          if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * ValueInfoProto name.\n     * @member {string} name\n     * @memberof onnx.ValueInfoProto\n     * @instance\n     */\n    ValueInfoProto.prototype.name = '';\n\n    /**\n     * ValueInfoProto type.\n     * @member {onnx.ITypeProto|null|undefined} type\n     * @memberof onnx.ValueInfoProto\n     * @instance\n     */\n    ValueInfoProto.prototype.type = null;\n\n    /**\n     * ValueInfoProto docString.\n     * @member {string} docString\n     * @memberof onnx.ValueInfoProto\n     * @instance\n     */\n    ValueInfoProto.prototype.docString = '';\n\n    /**\n     * Creates a new ValueInfoProto instance using the specified properties.\n     * @function create\n     * @memberof onnx.ValueInfoProto\n     * @static\n     * @param {onnx.IValueInfoProto=} [properties] Properties to set\n     * @returns {onnx.ValueInfoProto} ValueInfoProto instance\n     */\n    ValueInfoProto.create = function create(properties) {\n      return new ValueInfoProto(properties);\n    };\n\n    /**\n     * Encodes the specified ValueInfoProto message. Does not implicitly {@link onnx.ValueInfoProto.verify|verify} messages.\n     * @function encode\n     * @memberof onnx.ValueInfoProto\n     * @static\n     * @param {onnx.IValueInfoProto} message ValueInfoProto message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    ValueInfoProto.encode = function encode(message, writer) {\n      if (!writer) writer = $Writer.create();\n      if (message.name != null && Object.hasOwnProperty.call(message, 'name'))\n        writer.uint32(/* id 1, wireType 2 =*/ 10).string(message.name);\n      if (message.type != null && Object.hasOwnProperty.call(message, 'type'))\n        $root.onnx.TypeProto.encode(message.type, writer.uint32(/* id 2, wireType 2 =*/ 18).fork()).ldelim();\n      if (message.docString != null && Object.hasOwnProperty.call(message, 'docString'))\n        writer.uint32(/* id 3, wireType 2 =*/ 26).string(message.docString);\n      return writer;\n    };\n\n    /**\n     * Encodes the specified ValueInfoProto message, length delimited. Does not implicitly {@link onnx.ValueInfoProto.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof onnx.ValueInfoProto\n     * @static\n     * @param {onnx.IValueInfoProto} message ValueInfoProto message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    ValueInfoProto.encodeDelimited = function encodeDelimited(message, writer) {\n      return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a ValueInfoProto message from the specified reader or buffer.\n     * @function decode\n     * @memberof onnx.ValueInfoProto\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {onnx.ValueInfoProto} ValueInfoProto\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    ValueInfoProto.decode = function decode(reader, length) {\n      if (!(reader instanceof $Reader)) reader = $Reader.create(reader);\n      var end = length === undefined ? reader.len : reader.pos + length,\n        message = new $root.onnx.ValueInfoProto();\n      while (reader.pos < end) {\n        var tag = reader.uint32();\n        switch (tag >>> 3) {\n          case 1: {\n            message.name = reader.string();\n            break;\n          }\n          case 2: {\n            message.type = $root.onnx.TypeProto.decode(reader, reader.uint32());\n            break;\n          }\n          case 3: {\n            message.docString = reader.string();\n            break;\n          }\n          default:\n            reader.skipType(tag & 7);\n            break;\n        }\n      }\n      return message;\n    };\n\n    /**\n     * Decodes a ValueInfoProto message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof onnx.ValueInfoProto\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {onnx.ValueInfoProto} ValueInfoProto\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    ValueInfoProto.decodeDelimited = function decodeDelimited(reader) {\n      if (!(reader instanceof $Reader)) reader = new $Reader(reader);\n      return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a ValueInfoProto message.\n     * @function verify\n     * @memberof onnx.ValueInfoProto\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    ValueInfoProto.verify = function verify(message) {\n      if (typeof message !== 'object' || message === null) return 'object expected';\n      if (message.name != null && message.hasOwnProperty('name'))\n        if (!$util.isString(message.name)) return 'name: string expected';\n      if (message.type != null && message.hasOwnProperty('type')) {\n        var error = $root.onnx.TypeProto.verify(message.type);\n        if (error) return 'type.' + error;\n      }\n      if (message.docString != null && message.hasOwnProperty('docString'))\n        if (!$util.isString(message.docString)) return 'docString: string expected';\n      return null;\n    };\n\n    /**\n     * Creates a ValueInfoProto message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof onnx.ValueInfoProto\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {onnx.ValueInfoProto} ValueInfoProto\n     */\n    ValueInfoProto.fromObject = function fromObject(object) {\n      if (object instanceof $root.onnx.ValueInfoProto) return object;\n      var message = new $root.onnx.ValueInfoProto();\n      if (object.name != null) message.name = String(object.name);\n      if (object.type != null) {\n        if (typeof object.type !== 'object') throw TypeError('.onnx.ValueInfoProto.type: object expected');\n        message.type = $root.onnx.TypeProto.fromObject(object.type);\n      }\n      if (object.docString != null) message.docString = String(object.docString);\n      return message;\n    };\n\n    /**\n     * Creates a plain object from a ValueInfoProto message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof onnx.ValueInfoProto\n     * @static\n     * @param {onnx.ValueInfoProto} message ValueInfoProto\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    ValueInfoProto.toObject = function toObject(message, options) {\n      if (!options) options = {};\n      var object = {};\n      if (options.defaults) {\n        object.name = '';\n        object.type = null;\n        object.docString = '';\n      }\n      if (message.name != null && message.hasOwnProperty('name')) object.name = message.name;\n      if (message.type != null && message.hasOwnProperty('type'))\n        object.type = $root.onnx.TypeProto.toObject(message.type, options);\n      if (message.docString != null && message.hasOwnProperty('docString')) object.docString = message.docString;\n      return object;\n    };\n\n    /**\n     * Converts this ValueInfoProto to JSON.\n     * @function toJSON\n     * @memberof onnx.ValueInfoProto\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    ValueInfoProto.prototype.toJSON = function toJSON() {\n      return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    /**\n     * Gets the default type url for ValueInfoProto\n     * @function getTypeUrl\n     * @memberof onnx.ValueInfoProto\n     * @static\n     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default \"type.googleapis.com\")\n     * @returns {string} The default type url\n     */\n    ValueInfoProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {\n      if (typeUrlPrefix === undefined) {\n        typeUrlPrefix = 'type.googleapis.com';\n      }\n      return typeUrlPrefix + '/onnx.ValueInfoProto';\n    };\n\n    return ValueInfoProto;\n  })();\n\n  onnx.NodeProto = (function () {\n    /**\n     * Properties of a NodeProto.\n     * @memberof onnx\n     * @interface INodeProto\n     * @property {Array.<string>|null} [input] NodeProto input\n     * @property {Array.<string>|null} [output] NodeProto output\n     * @property {string|null} [name] NodeProto name\n     * @property {string|null} [opType] NodeProto opType\n     * @property {string|null} [domain] NodeProto domain\n     * @property {Array.<onnx.IAttributeProto>|null} [attribute] NodeProto attribute\n     * @property {string|null} [docString] NodeProto docString\n     */\n\n    /**\n     * Constructs a new NodeProto.\n     * @memberof onnx\n     * @classdesc Represents a NodeProto.\n     * @implements INodeProto\n     * @constructor\n     * @param {onnx.INodeProto=} [properties] Properties to set\n     */\n    function NodeProto(properties) {\n      this.input = [];\n      this.output = [];\n      this.attribute = [];\n      if (properties)\n        for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n          if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * NodeProto input.\n     * @member {Array.<string>} input\n     * @memberof onnx.NodeProto\n     * @instance\n     */\n    NodeProto.prototype.input = $util.emptyArray;\n\n    /**\n     * NodeProto output.\n     * @member {Array.<string>} output\n     * @memberof onnx.NodeProto\n     * @instance\n     */\n    NodeProto.prototype.output = $util.emptyArray;\n\n    /**\n     * NodeProto name.\n     * @member {string} name\n     * @memberof onnx.NodeProto\n     * @instance\n     */\n    NodeProto.prototype.name = '';\n\n    /**\n     * NodeProto opType.\n     * @member {string} opType\n     * @memberof onnx.NodeProto\n     * @instance\n     */\n    NodeProto.prototype.opType = '';\n\n    /**\n     * NodeProto domain.\n     * @member {string} domain\n     * @memberof onnx.NodeProto\n     * @instance\n     */\n    NodeProto.prototype.domain = '';\n\n    /**\n     * NodeProto attribute.\n     * @member {Array.<onnx.IAttributeProto>} attribute\n     * @memberof onnx.NodeProto\n     * @instance\n     */\n    NodeProto.prototype.attribute = $util.emptyArray;\n\n    /**\n     * NodeProto docString.\n     * @member {string} docString\n     * @memberof onnx.NodeProto\n     * @instance\n     */\n    NodeProto.prototype.docString = '';\n\n    /**\n     * Creates a new NodeProto instance using the specified properties.\n     * @function create\n     * @memberof onnx.NodeProto\n     * @static\n     * @param {onnx.INodeProto=} [properties] Properties to set\n     * @returns {onnx.NodeProto} NodeProto instance\n     */\n    NodeProto.create = function create(properties) {\n      return new NodeProto(properties);\n    };\n\n    /**\n     * Encodes the specified NodeProto message. Does not implicitly {@link onnx.NodeProto.verify|verify} messages.\n     * @function encode\n     * @memberof onnx.NodeProto\n     * @static\n     * @param {onnx.INodeProto} message NodeProto message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    NodeProto.encode = function encode(message, writer) {\n      if (!writer) writer = $Writer.create();\n      if (message.input != null && message.input.length)\n        for (var i = 0; i < message.input.length; ++i)\n          writer.uint32(/* id 1, wireType 2 =*/ 10).string(message.input[i]);\n      if (message.output != null && message.output.length)\n        for (var i = 0; i < message.output.length; ++i)\n          writer.uint32(/* id 2, wireType 2 =*/ 18).string(message.output[i]);\n      if (message.name != null && Object.hasOwnProperty.call(message, 'name'))\n        writer.uint32(/* id 3, wireType 2 =*/ 26).string(message.name);\n      if (message.opType != null && Object.hasOwnProperty.call(message, 'opType'))\n        writer.uint32(/* id 4, wireType 2 =*/ 34).string(message.opType);\n      if (message.attribute != null && message.attribute.length)\n        for (var i = 0; i < message.attribute.length; ++i)\n          $root.onnx.AttributeProto.encode(\n            message.attribute[i],\n            writer.uint32(/* id 5, wireType 2 =*/ 42).fork(),\n          ).ldelim();\n      if (message.docString != null && Object.hasOwnProperty.call(message, 'docString'))\n        writer.uint32(/* id 6, wireType 2 =*/ 50).string(message.docString);\n      if (message.domain != null && Object.hasOwnProperty.call(message, 'domain'))\n        writer.uint32(/* id 7, wireType 2 =*/ 58).string(message.domain);\n      return writer;\n    };\n\n    /**\n     * Encodes the specified NodeProto message, length delimited. Does not implicitly {@link onnx.NodeProto.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof onnx.NodeProto\n     * @static\n     * @param {onnx.INodeProto} message NodeProto message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    NodeProto.encodeDelimited = function encodeDelimited(message, writer) {\n      return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a NodeProto message from the specified reader or buffer.\n     * @function decode\n     * @memberof onnx.NodeProto\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {onnx.NodeProto} NodeProto\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    NodeProto.decode = function decode(reader, length) {\n      if (!(reader instanceof $Reader)) reader = $Reader.create(reader);\n      var end = length === undefined ? reader.len : reader.pos + length,\n        message = new $root.onnx.NodeProto();\n      while (reader.pos < end) {\n        var tag = reader.uint32();\n        switch (tag >>> 3) {\n          case 1: {\n            if (!(message.input && message.input.length)) message.input = [];\n            message.input.push(reader.string());\n            break;\n          }\n          case 2: {\n            if (!(message.output && message.output.length)) message.output = [];\n            message.output.push(reader.string());\n            break;\n          }\n          case 3: {\n            message.name = reader.string();\n            break;\n          }\n          case 4: {\n            message.opType = reader.string();\n            break;\n          }\n          case 7: {\n            message.domain = reader.string();\n            break;\n          }\n          case 5: {\n            if (!(message.attribute && message.attribute.length)) message.attribute = [];\n            message.attribute.push($root.onnx.AttributeProto.decode(reader, reader.uint32()));\n            break;\n          }\n          case 6: {\n            message.docString = reader.string();\n            break;\n          }\n          default:\n            reader.skipType(tag & 7);\n            break;\n        }\n      }\n      return message;\n    };\n\n    /**\n     * Decodes a NodeProto message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof onnx.NodeProto\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {onnx.NodeProto} NodeProto\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    NodeProto.decodeDelimited = function decodeDelimited(reader) {\n      if (!(reader instanceof $Reader)) reader = new $Reader(reader);\n      return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a NodeProto message.\n     * @function verify\n     * @memberof onnx.NodeProto\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    NodeProto.verify = function verify(message) {\n      if (typeof message !== 'object' || message === null) return 'object expected';\n      if (message.input != null && message.hasOwnProperty('input')) {\n        if (!Array.isArray(message.input)) return 'input: array expected';\n        for (var i = 0; i < message.input.length; ++i)\n          if (!$util.isString(message.input[i])) return 'input: string[] expected';\n      }\n      if (message.output != null && message.hasOwnProperty('output')) {\n        if (!Array.isArray(message.output)) return 'output: array expected';\n        for (var i = 0; i < message.output.length; ++i)\n          if (!$util.isString(message.output[i])) return 'output: string[] expected';\n      }\n      if (message.name != null && message.hasOwnProperty('name'))\n        if (!$util.isString(message.name)) return 'name: string expected';\n      if (message.opType != null && message.hasOwnProperty('opType'))\n        if (!$util.isString(message.opType)) return 'opType: string expected';\n      if (message.domain != null && message.hasOwnProperty('domain'))\n        if (!$util.isString(message.domain)) return 'domain: string expected';\n      if (message.attribute != null && message.hasOwnProperty('attribute')) {\n        if (!Array.isArray(message.attribute)) return 'attribute: array expected';\n        for (var i = 0; i < message.attribute.length; ++i) {\n          var error = $root.onnx.AttributeProto.verify(message.attribute[i]);\n          if (error) return 'attribute.' + error;\n        }\n      }\n      if (message.docString != null && message.hasOwnProperty('docString'))\n        if (!$util.isString(message.docString)) return 'docString: string expected';\n      return null;\n    };\n\n    /**\n     * Creates a NodeProto message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof onnx.NodeProto\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {onnx.NodeProto} NodeProto\n     */\n    NodeProto.fromObject = function fromObject(object) {\n      if (object instanceof $root.onnx.NodeProto) return object;\n      var message = new $root.onnx.NodeProto();\n      if (object.input) {\n        if (!Array.isArray(object.input)) throw TypeError('.onnx.NodeProto.input: array expected');\n        message.input = [];\n        for (var i = 0; i < object.input.length; ++i) message.input[i] = String(object.input[i]);\n      }\n      if (object.output) {\n        if (!Array.isArray(object.output)) throw TypeError('.onnx.NodeProto.output: array expected');\n        message.output = [];\n        for (var i = 0; i < object.output.length; ++i) message.output[i] = String(object.output[i]);\n      }\n      if (object.name != null) message.name = String(object.name);\n      if (object.opType != null) message.opType = String(object.opType);\n      if (object.domain != null) message.domain = String(object.domain);\n      if (object.attribute) {\n        if (!Array.isArray(object.attribute)) throw TypeError('.onnx.NodeProto.attribute: array expected');\n        message.attribute = [];\n        for (var i = 0; i < object.attribute.length; ++i) {\n          if (typeof object.attribute[i] !== 'object') throw TypeError('.onnx.NodeProto.attribute: object expected');\n          message.attribute[i] = $root.onnx.AttributeProto.fromObject(object.attribute[i]);\n        }\n      }\n      if (object.docString != null) message.docString = String(object.docString);\n      return message;\n    };\n\n    /**\n     * Creates a plain object from a NodeProto message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof onnx.NodeProto\n     * @static\n     * @param {onnx.NodeProto} message NodeProto\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    NodeProto.toObject = function toObject(message, options) {\n      if (!options) options = {};\n      var object = {};\n      if (options.arrays || options.defaults) {\n        object.input = [];\n        object.output = [];\n        object.attribute = [];\n      }\n      if (options.defaults) {\n        object.name = '';\n        object.opType = '';\n        object.docString = '';\n        object.domain = '';\n      }\n      if (message.input && message.input.length) {\n        object.input = [];\n        for (var j = 0; j < message.input.length; ++j) object.input[j] = message.input[j];\n      }\n      if (message.output && message.output.length) {\n        object.output = [];\n        for (var j = 0; j < message.output.length; ++j) object.output[j] = message.output[j];\n      }\n      if (message.name != null && message.hasOwnProperty('name')) object.name = message.name;\n      if (message.opType != null && message.hasOwnProperty('opType')) object.opType = message.opType;\n      if (message.attribute && message.attribute.length) {\n        object.attribute = [];\n        for (var j = 0; j < message.attribute.length; ++j)\n          object.attribute[j] = $root.onnx.AttributeProto.toObject(message.attribute[j], options);\n      }\n      if (message.docString != null && message.hasOwnProperty('docString')) object.docString = message.docString;\n      if (message.domain != null && message.hasOwnProperty('domain')) object.domain = message.domain;\n      return object;\n    };\n\n    /**\n     * Converts this NodeProto to JSON.\n     * @function toJSON\n     * @memberof onnx.NodeProto\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    NodeProto.prototype.toJSON = function toJSON() {\n      return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    /**\n     * Gets the default type url for NodeProto\n     * @function getTypeUrl\n     * @memberof onnx.NodeProto\n     * @static\n     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default \"type.googleapis.com\")\n     * @returns {string} The default type url\n     */\n    NodeProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {\n      if (typeUrlPrefix === undefined) {\n        typeUrlPrefix = 'type.googleapis.com';\n      }\n      return typeUrlPrefix + '/onnx.NodeProto';\n    };\n\n    return NodeProto;\n  })();\n\n  onnx.TrainingInfoProto = (function () {\n    /**\n     * Properties of a TrainingInfoProto.\n     * @memberof onnx\n     * @interface ITrainingInfoProto\n     * @property {onnx.IGraphProto|null} [initialization] TrainingInfoProto initialization\n     * @property {onnx.IGraphProto|null} [algorithm] TrainingInfoProto algorithm\n     * @property {Array.<onnx.IStringStringEntryProto>|null} [initializationBinding] TrainingInfoProto initializationBinding\n     * @property {Array.<onnx.IStringStringEntryProto>|null} [updateBinding] TrainingInfoProto updateBinding\n     */\n\n    /**\n     * Constructs a new TrainingInfoProto.\n     * @memberof onnx\n     * @classdesc Represents a TrainingInfoProto.\n     * @implements ITrainingInfoProto\n     * @constructor\n     * @param {onnx.ITrainingInfoProto=} [properties] Properties to set\n     */\n    function TrainingInfoProto(properties) {\n      this.initializationBinding = [];\n      this.updateBinding = [];\n      if (properties)\n        for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n          if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * TrainingInfoProto initialization.\n     * @member {onnx.IGraphProto|null|undefined} initialization\n     * @memberof onnx.TrainingInfoProto\n     * @instance\n     */\n    TrainingInfoProto.prototype.initialization = null;\n\n    /**\n     * TrainingInfoProto algorithm.\n     * @member {onnx.IGraphProto|null|undefined} algorithm\n     * @memberof onnx.TrainingInfoProto\n     * @instance\n     */\n    TrainingInfoProto.prototype.algorithm = null;\n\n    /**\n     * TrainingInfoProto initializationBinding.\n     * @member {Array.<onnx.IStringStringEntryProto>} initializationBinding\n     * @memberof onnx.TrainingInfoProto\n     * @instance\n     */\n    TrainingInfoProto.prototype.initializationBinding = $util.emptyArray;\n\n    /**\n     * TrainingInfoProto updateBinding.\n     * @member {Array.<onnx.IStringStringEntryProto>} updateBinding\n     * @memberof onnx.TrainingInfoProto\n     * @instance\n     */\n    TrainingInfoProto.prototype.updateBinding = $util.emptyArray;\n\n    /**\n     * Creates a new TrainingInfoProto instance using the specified properties.\n     * @function create\n     * @memberof onnx.TrainingInfoProto\n     * @static\n     * @param {onnx.ITrainingInfoProto=} [properties] Properties to set\n     * @returns {onnx.TrainingInfoProto} TrainingInfoProto instance\n     */\n    TrainingInfoProto.create = function create(properties) {\n      return new TrainingInfoProto(properties);\n    };\n\n    /**\n     * Encodes the specified TrainingInfoProto message. Does not implicitly {@link onnx.TrainingInfoProto.verify|verify} messages.\n     * @function encode\n     * @memberof onnx.TrainingInfoProto\n     * @static\n     * @param {onnx.ITrainingInfoProto} message TrainingInfoProto message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    TrainingInfoProto.encode = function encode(message, writer) {\n      if (!writer) writer = $Writer.create();\n      if (message.initialization != null && Object.hasOwnProperty.call(message, 'initialization'))\n        $root.onnx.GraphProto.encode(message.initialization, writer.uint32(/* id 1, wireType 2 =*/ 10).fork()).ldelim();\n      if (message.algorithm != null && Object.hasOwnProperty.call(message, 'algorithm'))\n        $root.onnx.GraphProto.encode(message.algorithm, writer.uint32(/* id 2, wireType 2 =*/ 18).fork()).ldelim();\n      if (message.initializationBinding != null && message.initializationBinding.length)\n        for (var i = 0; i < message.initializationBinding.length; ++i)\n          $root.onnx.StringStringEntryProto.encode(\n            message.initializationBinding[i],\n            writer.uint32(/* id 3, wireType 2 =*/ 26).fork(),\n          ).ldelim();\n      if (message.updateBinding != null && message.updateBinding.length)\n        for (var i = 0; i < message.updateBinding.length; ++i)\n          $root.onnx.StringStringEntryProto.encode(\n            message.updateBinding[i],\n            writer.uint32(/* id 4, wireType 2 =*/ 34).fork(),\n          ).ldelim();\n      return writer;\n    };\n\n    /**\n     * Encodes the specified TrainingInfoProto message, length delimited. Does not implicitly {@link onnx.TrainingInfoProto.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof onnx.TrainingInfoProto\n     * @static\n     * @param {onnx.ITrainingInfoProto} message TrainingInfoProto message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    TrainingInfoProto.encodeDelimited = function encodeDelimited(message, writer) {\n      return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a TrainingInfoProto message from the specified reader or buffer.\n     * @function decode\n     * @memberof onnx.TrainingInfoProto\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {onnx.TrainingInfoProto} TrainingInfoProto\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    TrainingInfoProto.decode = function decode(reader, length) {\n      if (!(reader instanceof $Reader)) reader = $Reader.create(reader);\n      var end = length === undefined ? reader.len : reader.pos + length,\n        message = new $root.onnx.TrainingInfoProto();\n      while (reader.pos < end) {\n        var tag = reader.uint32();\n        switch (tag >>> 3) {\n          case 1: {\n            message.initialization = $root.onnx.GraphProto.decode(reader, reader.uint32());\n            break;\n          }\n          case 2: {\n            message.algorithm = $root.onnx.GraphProto.decode(reader, reader.uint32());\n            break;\n          }\n          case 3: {\n            if (!(message.initializationBinding && message.initializationBinding.length))\n              message.initializationBinding = [];\n            message.initializationBinding.push($root.onnx.StringStringEntryProto.decode(reader, reader.uint32()));\n            break;\n          }\n          case 4: {\n            if (!(message.updateBinding && message.updateBinding.length)) message.updateBinding = [];\n            message.updateBinding.push($root.onnx.StringStringEntryProto.decode(reader, reader.uint32()));\n            break;\n          }\n          default:\n            reader.skipType(tag & 7);\n            break;\n        }\n      }\n      return message;\n    };\n\n    /**\n     * Decodes a TrainingInfoProto message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof onnx.TrainingInfoProto\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {onnx.TrainingInfoProto} TrainingInfoProto\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    TrainingInfoProto.decodeDelimited = function decodeDelimited(reader) {\n      if (!(reader instanceof $Reader)) reader = new $Reader(reader);\n      return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a TrainingInfoProto message.\n     * @function verify\n     * @memberof onnx.TrainingInfoProto\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    TrainingInfoProto.verify = function verify(message) {\n      if (typeof message !== 'object' || message === null) return 'object expected';\n      if (message.initialization != null && message.hasOwnProperty('initialization')) {\n        var error = $root.onnx.GraphProto.verify(message.initialization);\n        if (error) return 'initialization.' + error;\n      }\n      if (message.algorithm != null && message.hasOwnProperty('algorithm')) {\n        var error = $root.onnx.GraphProto.verify(message.algorithm);\n        if (error) return 'algorithm.' + error;\n      }\n      if (message.initializationBinding != null && message.hasOwnProperty('initializationBinding')) {\n        if (!Array.isArray(message.initializationBinding)) return 'initializationBinding: array expected';\n        for (var i = 0; i < message.initializationBinding.length; ++i) {\n          var error = $root.onnx.StringStringEntryProto.verify(message.initializationBinding[i]);\n          if (error) return 'initializationBinding.' + error;\n        }\n      }\n      if (message.updateBinding != null && message.hasOwnProperty('updateBinding')) {\n        if (!Array.isArray(message.updateBinding)) return 'updateBinding: array expected';\n        for (var i = 0; i < message.updateBinding.length; ++i) {\n          var error = $root.onnx.StringStringEntryProto.verify(message.updateBinding[i]);\n          if (error) return 'updateBinding.' + error;\n        }\n      }\n      return null;\n    };\n\n    /**\n     * Creates a TrainingInfoProto message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof onnx.TrainingInfoProto\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {onnx.TrainingInfoProto} TrainingInfoProto\n     */\n    TrainingInfoProto.fromObject = function fromObject(object) {\n      if (object instanceof $root.onnx.TrainingInfoProto) return object;\n      var message = new $root.onnx.TrainingInfoProto();\n      if (object.initialization != null) {\n        if (typeof object.initialization !== 'object')\n          throw TypeError('.onnx.TrainingInfoProto.initialization: object expected');\n        message.initialization = $root.onnx.GraphProto.fromObject(object.initialization);\n      }\n      if (object.algorithm != null) {\n        if (typeof object.algorithm !== 'object') throw TypeError('.onnx.TrainingInfoProto.algorithm: object expected');\n        message.algorithm = $root.onnx.GraphProto.fromObject(object.algorithm);\n      }\n      if (object.initializationBinding) {\n        if (!Array.isArray(object.initializationBinding))\n          throw TypeError('.onnx.TrainingInfoProto.initializationBinding: array expected');\n        message.initializationBinding = [];\n        for (var i = 0; i < object.initializationBinding.length; ++i) {\n          if (typeof object.initializationBinding[i] !== 'object')\n            throw TypeError('.onnx.TrainingInfoProto.initializationBinding: object expected');\n          message.initializationBinding[i] = $root.onnx.StringStringEntryProto.fromObject(\n            object.initializationBinding[i],\n          );\n        }\n      }\n      if (object.updateBinding) {\n        if (!Array.isArray(object.updateBinding))\n          throw TypeError('.onnx.TrainingInfoProto.updateBinding: array expected');\n        message.updateBinding = [];\n        for (var i = 0; i < object.updateBinding.length; ++i) {\n          if (typeof object.updateBinding[i] !== 'object')\n            throw TypeError('.onnx.TrainingInfoProto.updateBinding: object expected');\n          message.updateBinding[i] = $root.onnx.StringStringEntryProto.fromObject(object.updateBinding[i]);\n        }\n      }\n      return message;\n    };\n\n    /**\n     * Creates a plain object from a TrainingInfoProto message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof onnx.TrainingInfoProto\n     * @static\n     * @param {onnx.TrainingInfoProto} message TrainingInfoProto\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    TrainingInfoProto.toObject = function toObject(message, options) {\n      if (!options) options = {};\n      var object = {};\n      if (options.arrays || options.defaults) {\n        object.initializationBinding = [];\n        object.updateBinding = [];\n      }\n      if (options.defaults) {\n        object.initialization = null;\n        object.algorithm = null;\n      }\n      if (message.initialization != null && message.hasOwnProperty('initialization'))\n        object.initialization = $root.onnx.GraphProto.toObject(message.initialization, options);\n      if (message.algorithm != null && message.hasOwnProperty('algorithm'))\n        object.algorithm = $root.onnx.GraphProto.toObject(message.algorithm, options);\n      if (message.initializationBinding && message.initializationBinding.length) {\n        object.initializationBinding = [];\n        for (var j = 0; j < message.initializationBinding.length; ++j)\n          object.initializationBinding[j] = $root.onnx.StringStringEntryProto.toObject(\n            message.initializationBinding[j],\n            options,\n          );\n      }\n      if (message.updateBinding && message.updateBinding.length) {\n        object.updateBinding = [];\n        for (var j = 0; j < message.updateBinding.length; ++j)\n          object.updateBinding[j] = $root.onnx.StringStringEntryProto.toObject(message.updateBinding[j], options);\n      }\n      return object;\n    };\n\n    /**\n     * Converts this TrainingInfoProto to JSON.\n     * @function toJSON\n     * @memberof onnx.TrainingInfoProto\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    TrainingInfoProto.prototype.toJSON = function toJSON() {\n      return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    /**\n     * Gets the default type url for TrainingInfoProto\n     * @function getTypeUrl\n     * @memberof onnx.TrainingInfoProto\n     * @static\n     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default \"type.googleapis.com\")\n     * @returns {string} The default type url\n     */\n    TrainingInfoProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {\n      if (typeUrlPrefix === undefined) {\n        typeUrlPrefix = 'type.googleapis.com';\n      }\n      return typeUrlPrefix + '/onnx.TrainingInfoProto';\n    };\n\n    return TrainingInfoProto;\n  })();\n\n  onnx.ModelProto = (function () {\n    /**\n     * Properties of a ModelProto.\n     * @memberof onnx\n     * @interface IModelProto\n     * @property {number|Long|null} [irVersion] ModelProto irVersion\n     * @property {Array.<onnx.IOperatorSetIdProto>|null} [opsetImport] ModelProto opsetImport\n     * @property {string|null} [producerName] ModelProto producerName\n     * @property {string|null} [producerVersion] ModelProto producerVersion\n     * @property {string|null} [domain] ModelProto domain\n     * @property {number|Long|null} [modelVersion] ModelProto modelVersion\n     * @property {string|null} [docString] ModelProto docString\n     * @property {onnx.IGraphProto|null} [graph] ModelProto graph\n     * @property {Array.<onnx.IStringStringEntryProto>|null} [metadataProps] ModelProto metadataProps\n     * @property {Array.<onnx.ITrainingInfoProto>|null} [trainingInfo] ModelProto trainingInfo\n     * @property {Array.<onnx.IFunctionProto>|null} [functions] ModelProto functions\n     */\n\n    /**\n     * Constructs a new ModelProto.\n     * @memberof onnx\n     * @classdesc Represents a ModelProto.\n     * @implements IModelProto\n     * @constructor\n     * @param {onnx.IModelProto=} [properties] Properties to set\n     */\n    function ModelProto(properties) {\n      this.opsetImport = [];\n      this.metadataProps = [];\n      this.trainingInfo = [];\n      this.functions = [];\n      if (properties)\n        for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n          if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * ModelProto irVersion.\n     * @member {number|Long} irVersion\n     * @memberof onnx.ModelProto\n     * @instance\n     */\n    ModelProto.prototype.irVersion = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;\n\n    /**\n     * ModelProto opsetImport.\n     * @member {Array.<onnx.IOperatorSetIdProto>} opsetImport\n     * @memberof onnx.ModelProto\n     * @instance\n     */\n    ModelProto.prototype.opsetImport = $util.emptyArray;\n\n    /**\n     * ModelProto producerName.\n     * @member {string} producerName\n     * @memberof onnx.ModelProto\n     * @instance\n     */\n    ModelProto.prototype.producerName = '';\n\n    /**\n     * ModelProto producerVersion.\n     * @member {string} producerVersion\n     * @memberof onnx.ModelProto\n     * @instance\n     */\n    ModelProto.prototype.producerVersion = '';\n\n    /**\n     * ModelProto domain.\n     * @member {string} domain\n     * @memberof onnx.ModelProto\n     * @instance\n     */\n    ModelProto.prototype.domain = '';\n\n    /**\n     * ModelProto modelVersion.\n     * @member {number|Long} modelVersion\n     * @memberof onnx.ModelProto\n     * @instance\n     */\n    ModelProto.prototype.modelVersion = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;\n\n    /**\n     * ModelProto docString.\n     * @member {string} docString\n     * @memberof onnx.ModelProto\n     * @instance\n     */\n    ModelProto.prototype.docString = '';\n\n    /**\n     * ModelProto graph.\n     * @member {onnx.IGraphProto|null|undefined} graph\n     * @memberof onnx.ModelProto\n     * @instance\n     */\n    ModelProto.prototype.graph = null;\n\n    /**\n     * ModelProto metadataProps.\n     * @member {Array.<onnx.IStringStringEntryProto>} metadataProps\n     * @memberof onnx.ModelProto\n     * @instance\n     */\n    ModelProto.prototype.metadataProps = $util.emptyArray;\n\n    /**\n     * ModelProto trainingInfo.\n     * @member {Array.<onnx.ITrainingInfoProto>} trainingInfo\n     * @memberof onnx.ModelProto\n     * @instance\n     */\n    ModelProto.prototype.trainingInfo = $util.emptyArray;\n\n    /**\n     * ModelProto functions.\n     * @member {Array.<onnx.IFunctionProto>} functions\n     * @memberof onnx.ModelProto\n     * @instance\n     */\n    ModelProto.prototype.functions = $util.emptyArray;\n\n    /**\n     * Creates a new ModelProto instance using the specified properties.\n     * @function create\n     * @memberof onnx.ModelProto\n     * @static\n     * @param {onnx.IModelProto=} [properties] Properties to set\n     * @returns {onnx.ModelProto} ModelProto instance\n     */\n    ModelProto.create = function create(properties) {\n      return new ModelProto(properties);\n    };\n\n    /**\n     * Encodes the specified ModelProto message. Does not implicitly {@link onnx.ModelProto.verify|verify} messages.\n     * @function encode\n     * @memberof onnx.ModelProto\n     * @static\n     * @param {onnx.IModelProto} message ModelProto message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    ModelProto.encode = function encode(message, writer) {\n      if (!writer) writer = $Writer.create();\n      if (message.irVersion != null && Object.hasOwnProperty.call(message, 'irVersion'))\n        writer.uint32(/* id 1, wireType 0 =*/ 8).int64(message.irVersion);\n      if (message.producerName != null && Object.hasOwnProperty.call(message, 'producerName'))\n        writer.uint32(/* id 2, wireType 2 =*/ 18).string(message.producerName);\n      if (message.producerVersion != null && Object.hasOwnProperty.call(message, 'producerVersion'))\n        writer.uint32(/* id 3, wireType 2 =*/ 26).string(message.producerVersion);\n      if (message.domain != null && Object.hasOwnProperty.call(message, 'domain'))\n        writer.uint32(/* id 4, wireType 2 =*/ 34).string(message.domain);\n      if (message.modelVersion != null && Object.hasOwnProperty.call(message, 'modelVersion'))\n        writer.uint32(/* id 5, wireType 0 =*/ 40).int64(message.modelVersion);\n      if (message.docString != null && Object.hasOwnProperty.call(message, 'docString'))\n        writer.uint32(/* id 6, wireType 2 =*/ 50).string(message.docString);\n      if (message.graph != null && Object.hasOwnProperty.call(message, 'graph'))\n        $root.onnx.GraphProto.encode(message.graph, writer.uint32(/* id 7, wireType 2 =*/ 58).fork()).ldelim();\n      if (message.opsetImport != null && message.opsetImport.length)\n        for (var i = 0; i < message.opsetImport.length; ++i)\n          $root.onnx.OperatorSetIdProto.encode(\n            message.opsetImport[i],\n            writer.uint32(/* id 8, wireType 2 =*/ 66).fork(),\n          ).ldelim();\n      if (message.metadataProps != null && message.metadataProps.length)\n        for (var i = 0; i < message.metadataProps.length; ++i)\n          $root.onnx.StringStringEntryProto.encode(\n            message.metadataProps[i],\n            writer.uint32(/* id 14, wireType 2 =*/ 114).fork(),\n          ).ldelim();\n      if (message.trainingInfo != null && message.trainingInfo.length)\n        for (var i = 0; i < message.trainingInfo.length; ++i)\n          $root.onnx.TrainingInfoProto.encode(\n            message.trainingInfo[i],\n            writer.uint32(/* id 20, wireType 2 =*/ 162).fork(),\n          ).ldelim();\n      if (message.functions != null && message.functions.length)\n        for (var i = 0; i < message.functions.length; ++i)\n          $root.onnx.FunctionProto.encode(\n            message.functions[i],\n            writer.uint32(/* id 25, wireType 2 =*/ 202).fork(),\n          ).ldelim();\n      return writer;\n    };\n\n    /**\n     * Encodes the specified ModelProto message, length delimited. Does not implicitly {@link onnx.ModelProto.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof onnx.ModelProto\n     * @static\n     * @param {onnx.IModelProto} message ModelProto message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    ModelProto.encodeDelimited = function encodeDelimited(message, writer) {\n      return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a ModelProto message from the specified reader or buffer.\n     * @function decode\n     * @memberof onnx.ModelProto\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {onnx.ModelProto} ModelProto\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    ModelProto.decode = function decode(reader, length) {\n      if (!(reader instanceof $Reader)) reader = $Reader.create(reader);\n      var end = length === undefined ? reader.len : reader.pos + length,\n        message = new $root.onnx.ModelProto();\n      while (reader.pos < end) {\n        var tag = reader.uint32();\n        switch (tag >>> 3) {\n          case 1: {\n            message.irVersion = reader.int64();\n            break;\n          }\n          case 8: {\n            if (!(message.opsetImport && message.opsetImport.length)) message.opsetImport = [];\n            message.opsetImport.push($root.onnx.OperatorSetIdProto.decode(reader, reader.uint32()));\n            break;\n          }\n          case 2: {\n            message.producerName = reader.string();\n            break;\n          }\n          case 3: {\n            message.producerVersion = reader.string();\n            break;\n          }\n          case 4: {\n            message.domain = reader.string();\n            break;\n          }\n          case 5: {\n            message.modelVersion = reader.int64();\n            break;\n          }\n          case 6: {\n            message.docString = reader.string();\n            break;\n          }\n          case 7: {\n            message.graph = $root.onnx.GraphProto.decode(reader, reader.uint32());\n            break;\n          }\n          case 14: {\n            if (!(message.metadataProps && message.metadataProps.length)) message.metadataProps = [];\n            message.metadataProps.push($root.onnx.StringStringEntryProto.decode(reader, reader.uint32()));\n            break;\n          }\n          case 20: {\n            if (!(message.trainingInfo && message.trainingInfo.length)) message.trainingInfo = [];\n            message.trainingInfo.push($root.onnx.TrainingInfoProto.decode(reader, reader.uint32()));\n            break;\n          }\n          case 25: {\n            if (!(message.functions && message.functions.length)) message.functions = [];\n            message.functions.push($root.onnx.FunctionProto.decode(reader, reader.uint32()));\n            break;\n          }\n          default:\n            reader.skipType(tag & 7);\n            break;\n        }\n      }\n      return message;\n    };\n\n    /**\n     * Decodes a ModelProto message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof onnx.ModelProto\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {onnx.ModelProto} ModelProto\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    ModelProto.decodeDelimited = function decodeDelimited(reader) {\n      if (!(reader instanceof $Reader)) reader = new $Reader(reader);\n      return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a ModelProto message.\n     * @function verify\n     * @memberof onnx.ModelProto\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    ModelProto.verify = function verify(message) {\n      if (typeof message !== 'object' || message === null) return 'object expected';\n      if (message.irVersion != null && message.hasOwnProperty('irVersion'))\n        if (\n          !$util.isInteger(message.irVersion) &&\n          !(message.irVersion && $util.isInteger(message.irVersion.low) && $util.isInteger(message.irVersion.high))\n        )\n          return 'irVersion: integer|Long expected';\n      if (message.opsetImport != null && message.hasOwnProperty('opsetImport')) {\n        if (!Array.isArray(message.opsetImport)) return 'opsetImport: array expected';\n        for (var i = 0; i < message.opsetImport.length; ++i) {\n          var error = $root.onnx.OperatorSetIdProto.verify(message.opsetImport[i]);\n          if (error) return 'opsetImport.' + error;\n        }\n      }\n      if (message.producerName != null && message.hasOwnProperty('producerName'))\n        if (!$util.isString(message.producerName)) return 'producerName: string expected';\n      if (message.producerVersion != null && message.hasOwnProperty('producerVersion'))\n        if (!$util.isString(message.producerVersion)) return 'producerVersion: string expected';\n      if (message.domain != null && message.hasOwnProperty('domain'))\n        if (!$util.isString(message.domain)) return 'domain: string expected';\n      if (message.modelVersion != null && message.hasOwnProperty('modelVersion'))\n        if (\n          !$util.isInteger(message.modelVersion) &&\n          !(\n            message.modelVersion &&\n            $util.isInteger(message.modelVersion.low) &&\n            $util.isInteger(message.modelVersion.high)\n          )\n        )\n          return 'modelVersion: integer|Long expected';\n      if (message.docString != null && message.hasOwnProperty('docString'))\n        if (!$util.isString(message.docString)) return 'docString: string expected';\n      if (message.graph != null && message.hasOwnProperty('graph')) {\n        var error = $root.onnx.GraphProto.verify(message.graph);\n        if (error) return 'graph.' + error;\n      }\n      if (message.metadataProps != null && message.hasOwnProperty('metadataProps')) {\n        if (!Array.isArray(message.metadataProps)) return 'metadataProps: array expected';\n        for (var i = 0; i < message.metadataProps.length; ++i) {\n          var error = $root.onnx.StringStringEntryProto.verify(message.metadataProps[i]);\n          if (error) return 'metadataProps.' + error;\n        }\n      }\n      if (message.trainingInfo != null && message.hasOwnProperty('trainingInfo')) {\n        if (!Array.isArray(message.trainingInfo)) return 'trainingInfo: array expected';\n        for (var i = 0; i < message.trainingInfo.length; ++i) {\n          var error = $root.onnx.TrainingInfoProto.verify(message.trainingInfo[i]);\n          if (error) return 'trainingInfo.' + error;\n        }\n      }\n      if (message.functions != null && message.hasOwnProperty('functions')) {\n        if (!Array.isArray(message.functions)) return 'functions: array expected';\n        for (var i = 0; i < message.functions.length; ++i) {\n          var error = $root.onnx.FunctionProto.verify(message.functions[i]);\n          if (error) return 'functions.' + error;\n        }\n      }\n      return null;\n    };\n\n    /**\n     * Creates a ModelProto message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof onnx.ModelProto\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {onnx.ModelProto} ModelProto\n     */\n    ModelProto.fromObject = function fromObject(object) {\n      if (object instanceof $root.onnx.ModelProto) return object;\n      var message = new $root.onnx.ModelProto();\n      if (object.irVersion != null)\n        if ($util.Long) (message.irVersion = $util.Long.fromValue(object.irVersion)).unsigned = false;\n        else if (typeof object.irVersion === 'string') message.irVersion = parseInt(object.irVersion, 10);\n        else if (typeof object.irVersion === 'number') message.irVersion = object.irVersion;\n        else if (typeof object.irVersion === 'object')\n          message.irVersion = new $util.LongBits(object.irVersion.low >>> 0, object.irVersion.high >>> 0).toNumber();\n      if (object.opsetImport) {\n        if (!Array.isArray(object.opsetImport)) throw TypeError('.onnx.ModelProto.opsetImport: array expected');\n        message.opsetImport = [];\n        for (var i = 0; i < object.opsetImport.length; ++i) {\n          if (typeof object.opsetImport[i] !== 'object')\n            throw TypeError('.onnx.ModelProto.opsetImport: object expected');\n          message.opsetImport[i] = $root.onnx.OperatorSetIdProto.fromObject(object.opsetImport[i]);\n        }\n      }\n      if (object.producerName != null) message.producerName = String(object.producerName);\n      if (object.producerVersion != null) message.producerVersion = String(object.producerVersion);\n      if (object.domain != null) message.domain = String(object.domain);\n      if (object.modelVersion != null)\n        if ($util.Long) (message.modelVersion = $util.Long.fromValue(object.modelVersion)).unsigned = false;\n        else if (typeof object.modelVersion === 'string') message.modelVersion = parseInt(object.modelVersion, 10);\n        else if (typeof object.modelVersion === 'number') message.modelVersion = object.modelVersion;\n        else if (typeof object.modelVersion === 'object')\n          message.modelVersion = new $util.LongBits(\n            object.modelVersion.low >>> 0,\n            object.modelVersion.high >>> 0,\n          ).toNumber();\n      if (object.docString != null) message.docString = String(object.docString);\n      if (object.graph != null) {\n        if (typeof object.graph !== 'object') throw TypeError('.onnx.ModelProto.graph: object expected');\n        message.graph = $root.onnx.GraphProto.fromObject(object.graph);\n      }\n      if (object.metadataProps) {\n        if (!Array.isArray(object.metadataProps)) throw TypeError('.onnx.ModelProto.metadataProps: array expected');\n        message.metadataProps = [];\n        for (var i = 0; i < object.metadataProps.length; ++i) {\n          if (typeof object.metadataProps[i] !== 'object')\n            throw TypeError('.onnx.ModelProto.metadataProps: object expected');\n          message.metadataProps[i] = $root.onnx.StringStringEntryProto.fromObject(object.metadataProps[i]);\n        }\n      }\n      if (object.trainingInfo) {\n        if (!Array.isArray(object.trainingInfo)) throw TypeError('.onnx.ModelProto.trainingInfo: array expected');\n        message.trainingInfo = [];\n        for (var i = 0; i < object.trainingInfo.length; ++i) {\n          if (typeof object.trainingInfo[i] !== 'object')\n            throw TypeError('.onnx.ModelProto.trainingInfo: object expected');\n          message.trainingInfo[i] = $root.onnx.TrainingInfoProto.fromObject(object.trainingInfo[i]);\n        }\n      }\n      if (object.functions) {\n        if (!Array.isArray(object.functions)) throw TypeError('.onnx.ModelProto.functions: array expected');\n        message.functions = [];\n        for (var i = 0; i < object.functions.length; ++i) {\n          if (typeof object.functions[i] !== 'object') throw TypeError('.onnx.ModelProto.functions: object expected');\n          message.functions[i] = $root.onnx.FunctionProto.fromObject(object.functions[i]);\n        }\n      }\n      return message;\n    };\n\n    /**\n     * Creates a plain object from a ModelProto message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof onnx.ModelProto\n     * @static\n     * @param {onnx.ModelProto} message ModelProto\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    ModelProto.toObject = function toObject(message, options) {\n      if (!options) options = {};\n      var object = {};\n      if (options.arrays || options.defaults) {\n        object.opsetImport = [];\n        object.metadataProps = [];\n        object.trainingInfo = [];\n        object.functions = [];\n      }\n      if (options.defaults) {\n        if ($util.Long) {\n          var long = new $util.Long(0, 0, false);\n          object.irVersion =\n            options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;\n        } else object.irVersion = options.longs === String ? '0' : 0;\n        object.producerName = '';\n        object.producerVersion = '';\n        object.domain = '';\n        if ($util.Long) {\n          var long = new $util.Long(0, 0, false);\n          object.modelVersion =\n            options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;\n        } else object.modelVersion = options.longs === String ? '0' : 0;\n        object.docString = '';\n        object.graph = null;\n      }\n      if (message.irVersion != null && message.hasOwnProperty('irVersion'))\n        if (typeof message.irVersion === 'number')\n          object.irVersion = options.longs === String ? String(message.irVersion) : message.irVersion;\n        else\n          object.irVersion =\n            options.longs === String\n              ? $util.Long.prototype.toString.call(message.irVersion)\n              : options.longs === Number\n                ? new $util.LongBits(message.irVersion.low >>> 0, message.irVersion.high >>> 0).toNumber()\n                : message.irVersion;\n      if (message.producerName != null && message.hasOwnProperty('producerName'))\n        object.producerName = message.producerName;\n      if (message.producerVersion != null && message.hasOwnProperty('producerVersion'))\n        object.producerVersion = message.producerVersion;\n      if (message.domain != null && message.hasOwnProperty('domain')) object.domain = message.domain;\n      if (message.modelVersion != null && message.hasOwnProperty('modelVersion'))\n        if (typeof message.modelVersion === 'number')\n          object.modelVersion = options.longs === String ? String(message.modelVersion) : message.modelVersion;\n        else\n          object.modelVersion =\n            options.longs === String\n              ? $util.Long.prototype.toString.call(message.modelVersion)\n              : options.longs === Number\n                ? new $util.LongBits(message.modelVersion.low >>> 0, message.modelVersion.high >>> 0).toNumber()\n                : message.modelVersion;\n      if (message.docString != null && message.hasOwnProperty('docString')) object.docString = message.docString;\n      if (message.graph != null && message.hasOwnProperty('graph'))\n        object.graph = $root.onnx.GraphProto.toObject(message.graph, options);\n      if (message.opsetImport && message.opsetImport.length) {\n        object.opsetImport = [];\n        for (var j = 0; j < message.opsetImport.length; ++j)\n          object.opsetImport[j] = $root.onnx.OperatorSetIdProto.toObject(message.opsetImport[j], options);\n      }\n      if (message.metadataProps && message.metadataProps.length) {\n        object.metadataProps = [];\n        for (var j = 0; j < message.metadataProps.length; ++j)\n          object.metadataProps[j] = $root.onnx.StringStringEntryProto.toObject(message.metadataProps[j], options);\n      }\n      if (message.trainingInfo && message.trainingInfo.length) {\n        object.trainingInfo = [];\n        for (var j = 0; j < message.trainingInfo.length; ++j)\n          object.trainingInfo[j] = $root.onnx.TrainingInfoProto.toObject(message.trainingInfo[j], options);\n      }\n      if (message.functions && message.functions.length) {\n        object.functions = [];\n        for (var j = 0; j < message.functions.length; ++j)\n          object.functions[j] = $root.onnx.FunctionProto.toObject(message.functions[j], options);\n      }\n      return object;\n    };\n\n    /**\n     * Converts this ModelProto to JSON.\n     * @function toJSON\n     * @memberof onnx.ModelProto\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    ModelProto.prototype.toJSON = function toJSON() {\n      return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    /**\n     * Gets the default type url for ModelProto\n     * @function getTypeUrl\n     * @memberof onnx.ModelProto\n     * @static\n     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default \"type.googleapis.com\")\n     * @returns {string} The default type url\n     */\n    ModelProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {\n      if (typeUrlPrefix === undefined) {\n        typeUrlPrefix = 'type.googleapis.com';\n      }\n      return typeUrlPrefix + '/onnx.ModelProto';\n    };\n\n    return ModelProto;\n  })();\n\n  onnx.StringStringEntryProto = (function () {\n    /**\n     * Properties of a StringStringEntryProto.\n     * @memberof onnx\n     * @interface IStringStringEntryProto\n     * @property {string|null} [key] StringStringEntryProto key\n     * @property {string|null} [value] StringStringEntryProto value\n     */\n\n    /**\n     * Constructs a new StringStringEntryProto.\n     * @memberof onnx\n     * @classdesc Represents a StringStringEntryProto.\n     * @implements IStringStringEntryProto\n     * @constructor\n     * @param {onnx.IStringStringEntryProto=} [properties] Properties to set\n     */\n    function StringStringEntryProto(properties) {\n      if (properties)\n        for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n          if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * StringStringEntryProto key.\n     * @member {string} key\n     * @memberof onnx.StringStringEntryProto\n     * @instance\n     */\n    StringStringEntryProto.prototype.key = '';\n\n    /**\n     * StringStringEntryProto value.\n     * @member {string} value\n     * @memberof onnx.StringStringEntryProto\n     * @instance\n     */\n    StringStringEntryProto.prototype.value = '';\n\n    /**\n     * Creates a new StringStringEntryProto instance using the specified properties.\n     * @function create\n     * @memberof onnx.StringStringEntryProto\n     * @static\n     * @param {onnx.IStringStringEntryProto=} [properties] Properties to set\n     * @returns {onnx.StringStringEntryProto} StringStringEntryProto instance\n     */\n    StringStringEntryProto.create = function create(properties) {\n      return new StringStringEntryProto(properties);\n    };\n\n    /**\n     * Encodes the specified StringStringEntryProto message. Does not implicitly {@link onnx.StringStringEntryProto.verify|verify} messages.\n     * @function encode\n     * @memberof onnx.StringStringEntryProto\n     * @static\n     * @param {onnx.IStringStringEntryProto} message StringStringEntryProto message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    StringStringEntryProto.encode = function encode(message, writer) {\n      if (!writer) writer = $Writer.create();\n      if (message.key != null && Object.hasOwnProperty.call(message, 'key'))\n        writer.uint32(/* id 1, wireType 2 =*/ 10).string(message.key);\n      if (message.value != null && Object.hasOwnProperty.call(message, 'value'))\n        writer.uint32(/* id 2, wireType 2 =*/ 18).string(message.value);\n      return writer;\n    };\n\n    /**\n     * Encodes the specified StringStringEntryProto message, length delimited. Does not implicitly {@link onnx.StringStringEntryProto.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof onnx.StringStringEntryProto\n     * @static\n     * @param {onnx.IStringStringEntryProto} message StringStringEntryProto message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    StringStringEntryProto.encodeDelimited = function encodeDelimited(message, writer) {\n      return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a StringStringEntryProto message from the specified reader or buffer.\n     * @function decode\n     * @memberof onnx.StringStringEntryProto\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {onnx.StringStringEntryProto} StringStringEntryProto\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    StringStringEntryProto.decode = function decode(reader, length) {\n      if (!(reader instanceof $Reader)) reader = $Reader.create(reader);\n      var end = length === undefined ? reader.len : reader.pos + length,\n        message = new $root.onnx.StringStringEntryProto();\n      while (reader.pos < end) {\n        var tag = reader.uint32();\n        switch (tag >>> 3) {\n          case 1: {\n            message.key = reader.string();\n            break;\n          }\n          case 2: {\n            message.value = reader.string();\n            break;\n          }\n          default:\n            reader.skipType(tag & 7);\n            break;\n        }\n      }\n      return message;\n    };\n\n    /**\n     * Decodes a StringStringEntryProto message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof onnx.StringStringEntryProto\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {onnx.StringStringEntryProto} StringStringEntryProto\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    StringStringEntryProto.decodeDelimited = function decodeDelimited(reader) {\n      if (!(reader instanceof $Reader)) reader = new $Reader(reader);\n      return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a StringStringEntryProto message.\n     * @function verify\n     * @memberof onnx.StringStringEntryProto\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    StringStringEntryProto.verify = function verify(message) {\n      if (typeof message !== 'object' || message === null) return 'object expected';\n      if (message.key != null && message.hasOwnProperty('key'))\n        if (!$util.isString(message.key)) return 'key: string expected';\n      if (message.value != null && message.hasOwnProperty('value'))\n        if (!$util.isString(message.value)) return 'value: string expected';\n      return null;\n    };\n\n    /**\n     * Creates a StringStringEntryProto message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof onnx.StringStringEntryProto\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {onnx.StringStringEntryProto} StringStringEntryProto\n     */\n    StringStringEntryProto.fromObject = function fromObject(object) {\n      if (object instanceof $root.onnx.StringStringEntryProto) return object;\n      var message = new $root.onnx.StringStringEntryProto();\n      if (object.key != null) message.key = String(object.key);\n      if (object.value != null) message.value = String(object.value);\n      return message;\n    };\n\n    /**\n     * Creates a plain object from a StringStringEntryProto message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof onnx.StringStringEntryProto\n     * @static\n     * @param {onnx.StringStringEntryProto} message StringStringEntryProto\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    StringStringEntryProto.toObject = function toObject(message, options) {\n      if (!options) options = {};\n      var object = {};\n      if (options.defaults) {\n        object.key = '';\n        object.value = '';\n      }\n      if (message.key != null && message.hasOwnProperty('key')) object.key = message.key;\n      if (message.value != null && message.hasOwnProperty('value')) object.value = message.value;\n      return object;\n    };\n\n    /**\n     * Converts this StringStringEntryProto to JSON.\n     * @function toJSON\n     * @memberof onnx.StringStringEntryProto\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    StringStringEntryProto.prototype.toJSON = function toJSON() {\n      return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    /**\n     * Gets the default type url for StringStringEntryProto\n     * @function getTypeUrl\n     * @memberof onnx.StringStringEntryProto\n     * @static\n     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default \"type.googleapis.com\")\n     * @returns {string} The default type url\n     */\n    StringStringEntryProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {\n      if (typeUrlPrefix === undefined) {\n        typeUrlPrefix = 'type.googleapis.com';\n      }\n      return typeUrlPrefix + '/onnx.StringStringEntryProto';\n    };\n\n    return StringStringEntryProto;\n  })();\n\n  onnx.TensorAnnotation = (function () {\n    /**\n     * Properties of a TensorAnnotation.\n     * @memberof onnx\n     * @interface ITensorAnnotation\n     * @property {string|null} [tensorName] TensorAnnotation tensorName\n     * @property {Array.<onnx.IStringStringEntryProto>|null} [quantParameterTensorNames] TensorAnnotation quantParameterTensorNames\n     */\n\n    /**\n     * Constructs a new TensorAnnotation.\n     * @memberof onnx\n     * @classdesc Represents a TensorAnnotation.\n     * @implements ITensorAnnotation\n     * @constructor\n     * @param {onnx.ITensorAnnotation=} [properties] Properties to set\n     */\n    function TensorAnnotation(properties) {\n      this.quantParameterTensorNames = [];\n      if (properties)\n        for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n          if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * TensorAnnotation tensorName.\n     * @member {string} tensorName\n     * @memberof onnx.TensorAnnotation\n     * @instance\n     */\n    TensorAnnotation.prototype.tensorName = '';\n\n    /**\n     * TensorAnnotation quantParameterTensorNames.\n     * @member {Array.<onnx.IStringStringEntryProto>} quantParameterTensorNames\n     * @memberof onnx.TensorAnnotation\n     * @instance\n     */\n    TensorAnnotation.prototype.quantParameterTensorNames = $util.emptyArray;\n\n    /**\n     * Creates a new TensorAnnotation instance using the specified properties.\n     * @function create\n     * @memberof onnx.TensorAnnotation\n     * @static\n     * @param {onnx.ITensorAnnotation=} [properties] Properties to set\n     * @returns {onnx.TensorAnnotation} TensorAnnotation instance\n     */\n    TensorAnnotation.create = function create(properties) {\n      return new TensorAnnotation(properties);\n    };\n\n    /**\n     * Encodes the specified TensorAnnotation message. Does not implicitly {@link onnx.TensorAnnotation.verify|verify} messages.\n     * @function encode\n     * @memberof onnx.TensorAnnotation\n     * @static\n     * @param {onnx.ITensorAnnotation} message TensorAnnotation message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    TensorAnnotation.encode = function encode(message, writer) {\n      if (!writer) writer = $Writer.create();\n      if (message.tensorName != null && Object.hasOwnProperty.call(message, 'tensorName'))\n        writer.uint32(/* id 1, wireType 2 =*/ 10).string(message.tensorName);\n      if (message.quantParameterTensorNames != null && message.quantParameterTensorNames.length)\n        for (var i = 0; i < message.quantParameterTensorNames.length; ++i)\n          $root.onnx.StringStringEntryProto.encode(\n            message.quantParameterTensorNames[i],\n            writer.uint32(/* id 2, wireType 2 =*/ 18).fork(),\n          ).ldelim();\n      return writer;\n    };\n\n    /**\n     * Encodes the specified TensorAnnotation message, length delimited. Does not implicitly {@link onnx.TensorAnnotation.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof onnx.TensorAnnotation\n     * @static\n     * @param {onnx.ITensorAnnotation} message TensorAnnotation message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    TensorAnnotation.encodeDelimited = function encodeDelimited(message, writer) {\n      return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a TensorAnnotation message from the specified reader or buffer.\n     * @function decode\n     * @memberof onnx.TensorAnnotation\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {onnx.TensorAnnotation} TensorAnnotation\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    TensorAnnotation.decode = function decode(reader, length) {\n      if (!(reader instanceof $Reader)) reader = $Reader.create(reader);\n      var end = length === undefined ? reader.len : reader.pos + length,\n        message = new $root.onnx.TensorAnnotation();\n      while (reader.pos < end) {\n        var tag = reader.uint32();\n        switch (tag >>> 3) {\n          case 1: {\n            message.tensorName = reader.string();\n            break;\n          }\n          case 2: {\n            if (!(message.quantParameterTensorNames && message.quantParameterTensorNames.length))\n              message.quantParameterTensorNames = [];\n            message.quantParameterTensorNames.push($root.onnx.StringStringEntryProto.decode(reader, reader.uint32()));\n            break;\n          }\n          default:\n            reader.skipType(tag & 7);\n            break;\n        }\n      }\n      return message;\n    };\n\n    /**\n     * Decodes a TensorAnnotation message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof onnx.TensorAnnotation\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {onnx.TensorAnnotation} TensorAnnotation\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    TensorAnnotation.decodeDelimited = function decodeDelimited(reader) {\n      if (!(reader instanceof $Reader)) reader = new $Reader(reader);\n      return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a TensorAnnotation message.\n     * @function verify\n     * @memberof onnx.TensorAnnotation\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    TensorAnnotation.verify = function verify(message) {\n      if (typeof message !== 'object' || message === null) return 'object expected';\n      if (message.tensorName != null && message.hasOwnProperty('tensorName'))\n        if (!$util.isString(message.tensorName)) return 'tensorName: string expected';\n      if (message.quantParameterTensorNames != null && message.hasOwnProperty('quantParameterTensorNames')) {\n        if (!Array.isArray(message.quantParameterTensorNames)) return 'quantParameterTensorNames: array expected';\n        for (var i = 0; i < message.quantParameterTensorNames.length; ++i) {\n          var error = $root.onnx.StringStringEntryProto.verify(message.quantParameterTensorNames[i]);\n          if (error) return 'quantParameterTensorNames.' + error;\n        }\n      }\n      return null;\n    };\n\n    /**\n     * Creates a TensorAnnotation message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof onnx.TensorAnnotation\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {onnx.TensorAnnotation} TensorAnnotation\n     */\n    TensorAnnotation.fromObject = function fromObject(object) {\n      if (object instanceof $root.onnx.TensorAnnotation) return object;\n      var message = new $root.onnx.TensorAnnotation();\n      if (object.tensorName != null) message.tensorName = String(object.tensorName);\n      if (object.quantParameterTensorNames) {\n        if (!Array.isArray(object.quantParameterTensorNames))\n          throw TypeError('.onnx.TensorAnnotation.quantParameterTensorNames: array expected');\n        message.quantParameterTensorNames = [];\n        for (var i = 0; i < object.quantParameterTensorNames.length; ++i) {\n          if (typeof object.quantParameterTensorNames[i] !== 'object')\n            throw TypeError('.onnx.TensorAnnotation.quantParameterTensorNames: object expected');\n          message.quantParameterTensorNames[i] = $root.onnx.StringStringEntryProto.fromObject(\n            object.quantParameterTensorNames[i],\n          );\n        }\n      }\n      return message;\n    };\n\n    /**\n     * Creates a plain object from a TensorAnnotation message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof onnx.TensorAnnotation\n     * @static\n     * @param {onnx.TensorAnnotation} message TensorAnnotation\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    TensorAnnotation.toObject = function toObject(message, options) {\n      if (!options) options = {};\n      var object = {};\n      if (options.arrays || options.defaults) object.quantParameterTensorNames = [];\n      if (options.defaults) object.tensorName = '';\n      if (message.tensorName != null && message.hasOwnProperty('tensorName')) object.tensorName = message.tensorName;\n      if (message.quantParameterTensorNames && message.quantParameterTensorNames.length) {\n        object.quantParameterTensorNames = [];\n        for (var j = 0; j < message.quantParameterTensorNames.length; ++j)\n          object.quantParameterTensorNames[j] = $root.onnx.StringStringEntryProto.toObject(\n            message.quantParameterTensorNames[j],\n            options,\n          );\n      }\n      return object;\n    };\n\n    /**\n     * Converts this TensorAnnotation to JSON.\n     * @function toJSON\n     * @memberof onnx.TensorAnnotation\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    TensorAnnotation.prototype.toJSON = function toJSON() {\n      return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    /**\n     * Gets the default type url for TensorAnnotation\n     * @function getTypeUrl\n     * @memberof onnx.TensorAnnotation\n     * @static\n     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default \"type.googleapis.com\")\n     * @returns {string} The default type url\n     */\n    TensorAnnotation.getTypeUrl = function getTypeUrl(typeUrlPrefix) {\n      if (typeUrlPrefix === undefined) {\n        typeUrlPrefix = 'type.googleapis.com';\n      }\n      return typeUrlPrefix + '/onnx.TensorAnnotation';\n    };\n\n    return TensorAnnotation;\n  })();\n\n  onnx.GraphProto = (function () {\n    /**\n     * Properties of a GraphProto.\n     * @memberof onnx\n     * @interface IGraphProto\n     * @property {Array.<onnx.INodeProto>|null} [node] GraphProto node\n     * @property {string|null} [name] GraphProto name\n     * @property {Array.<onnx.ITensorProto>|null} [initializer] GraphProto initializer\n     * @property {Array.<onnx.ISparseTensorProto>|null} [sparseInitializer] GraphProto sparseInitializer\n     * @property {string|null} [docString] GraphProto docString\n     * @property {Array.<onnx.IValueInfoProto>|null} [input] GraphProto input\n     * @property {Array.<onnx.IValueInfoProto>|null} [output] GraphProto output\n     * @property {Array.<onnx.IValueInfoProto>|null} [valueInfo] GraphProto valueInfo\n     * @property {Array.<onnx.ITensorAnnotation>|null} [quantizationAnnotation] GraphProto quantizationAnnotation\n     */\n\n    /**\n     * Constructs a new GraphProto.\n     * @memberof onnx\n     * @classdesc Represents a GraphProto.\n     * @implements IGraphProto\n     * @constructor\n     * @param {onnx.IGraphProto=} [properties] Properties to set\n     */\n    function GraphProto(properties) {\n      this.node = [];\n      this.initializer = [];\n      this.sparseInitializer = [];\n      this.input = [];\n      this.output = [];\n      this.valueInfo = [];\n      this.quantizationAnnotation = [];\n      if (properties)\n        for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n          if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * GraphProto node.\n     * @member {Array.<onnx.INodeProto>} node\n     * @memberof onnx.GraphProto\n     * @instance\n     */\n    GraphProto.prototype.node = $util.emptyArray;\n\n    /**\n     * GraphProto name.\n     * @member {string} name\n     * @memberof onnx.GraphProto\n     * @instance\n     */\n    GraphProto.prototype.name = '';\n\n    /**\n     * GraphProto initializer.\n     * @member {Array.<onnx.ITensorProto>} initializer\n     * @memberof onnx.GraphProto\n     * @instance\n     */\n    GraphProto.prototype.initializer = $util.emptyArray;\n\n    /**\n     * GraphProto sparseInitializer.\n     * @member {Array.<onnx.ISparseTensorProto>} sparseInitializer\n     * @memberof onnx.GraphProto\n     * @instance\n     */\n    GraphProto.prototype.sparseInitializer = $util.emptyArray;\n\n    /**\n     * GraphProto docString.\n     * @member {string} docString\n     * @memberof onnx.GraphProto\n     * @instance\n     */\n    GraphProto.prototype.docString = '';\n\n    /**\n     * GraphProto input.\n     * @member {Array.<onnx.IValueInfoProto>} input\n     * @memberof onnx.GraphProto\n     * @instance\n     */\n    GraphProto.prototype.input = $util.emptyArray;\n\n    /**\n     * GraphProto output.\n     * @member {Array.<onnx.IValueInfoProto>} output\n     * @memberof onnx.GraphProto\n     * @instance\n     */\n    GraphProto.prototype.output = $util.emptyArray;\n\n    /**\n     * GraphProto valueInfo.\n     * @member {Array.<onnx.IValueInfoProto>} valueInfo\n     * @memberof onnx.GraphProto\n     * @instance\n     */\n    GraphProto.prototype.valueInfo = $util.emptyArray;\n\n    /**\n     * GraphProto quantizationAnnotation.\n     * @member {Array.<onnx.ITensorAnnotation>} quantizationAnnotation\n     * @memberof onnx.GraphProto\n     * @instance\n     */\n    GraphProto.prototype.quantizationAnnotation = $util.emptyArray;\n\n    /**\n     * Creates a new GraphProto instance using the specified properties.\n     * @function create\n     * @memberof onnx.GraphProto\n     * @static\n     * @param {onnx.IGraphProto=} [properties] Properties to set\n     * @returns {onnx.GraphProto} GraphProto instance\n     */\n    GraphProto.create = function create(properties) {\n      return new GraphProto(properties);\n    };\n\n    /**\n     * Encodes the specified GraphProto message. Does not implicitly {@link onnx.GraphProto.verify|verify} messages.\n     * @function encode\n     * @memberof onnx.GraphProto\n     * @static\n     * @param {onnx.IGraphProto} message GraphProto message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    GraphProto.encode = function encode(message, writer) {\n      if (!writer) writer = $Writer.create();\n      if (message.node != null && message.node.length)\n        for (var i = 0; i < message.node.length; ++i)\n          $root.onnx.NodeProto.encode(message.node[i], writer.uint32(/* id 1, wireType 2 =*/ 10).fork()).ldelim();\n      if (message.name != null && Object.hasOwnProperty.call(message, 'name'))\n        writer.uint32(/* id 2, wireType 2 =*/ 18).string(message.name);\n      if (message.initializer != null && message.initializer.length)\n        for (var i = 0; i < message.initializer.length; ++i)\n          $root.onnx.TensorProto.encode(\n            message.initializer[i],\n            writer.uint32(/* id 5, wireType 2 =*/ 42).fork(),\n          ).ldelim();\n      if (message.docString != null && Object.hasOwnProperty.call(message, 'docString'))\n        writer.uint32(/* id 10, wireType 2 =*/ 82).string(message.docString);\n      if (message.input != null && message.input.length)\n        for (var i = 0; i < message.input.length; ++i)\n          $root.onnx.ValueInfoProto.encode(\n            message.input[i],\n            writer.uint32(/* id 11, wireType 2 =*/ 90).fork(),\n          ).ldelim();\n      if (message.output != null && message.output.length)\n        for (var i = 0; i < message.output.length; ++i)\n          $root.onnx.ValueInfoProto.encode(\n            message.output[i],\n            writer.uint32(/* id 12, wireType 2 =*/ 98).fork(),\n          ).ldelim();\n      if (message.valueInfo != null && message.valueInfo.length)\n        for (var i = 0; i < message.valueInfo.length; ++i)\n          $root.onnx.ValueInfoProto.encode(\n            message.valueInfo[i],\n            writer.uint32(/* id 13, wireType 2 =*/ 106).fork(),\n          ).ldelim();\n      if (message.quantizationAnnotation != null && message.quantizationAnnotation.length)\n        for (var i = 0; i < message.quantizationAnnotation.length; ++i)\n          $root.onnx.TensorAnnotation.encode(\n            message.quantizationAnnotation[i],\n            writer.uint32(/* id 14, wireType 2 =*/ 114).fork(),\n          ).ldelim();\n      if (message.sparseInitializer != null && message.sparseInitializer.length)\n        for (var i = 0; i < message.sparseInitializer.length; ++i)\n          $root.onnx.SparseTensorProto.encode(\n            message.sparseInitializer[i],\n            writer.uint32(/* id 15, wireType 2 =*/ 122).fork(),\n          ).ldelim();\n      return writer;\n    };\n\n    /**\n     * Encodes the specified GraphProto message, length delimited. Does not implicitly {@link onnx.GraphProto.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof onnx.GraphProto\n     * @static\n     * @param {onnx.IGraphProto} message GraphProto message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    GraphProto.encodeDelimited = function encodeDelimited(message, writer) {\n      return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a GraphProto message from the specified reader or buffer.\n     * @function decode\n     * @memberof onnx.GraphProto\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {onnx.GraphProto} GraphProto\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    GraphProto.decode = function decode(reader, length) {\n      if (!(reader instanceof $Reader)) reader = $Reader.create(reader);\n      var end = length === undefined ? reader.len : reader.pos + length,\n        message = new $root.onnx.GraphProto();\n      while (reader.pos < end) {\n        var tag = reader.uint32();\n        switch (tag >>> 3) {\n          case 1: {\n            if (!(message.node && message.node.length)) message.node = [];\n            message.node.push($root.onnx.NodeProto.decode(reader, reader.uint32()));\n            break;\n          }\n          case 2: {\n            message.name = reader.string();\n            break;\n          }\n          case 5: {\n            if (!(message.initializer && message.initializer.length)) message.initializer = [];\n            message.initializer.push($root.onnx.TensorProto.decode(reader, reader.uint32()));\n            break;\n          }\n          case 15: {\n            if (!(message.sparseInitializer && message.sparseInitializer.length)) message.sparseInitializer = [];\n            message.sparseInitializer.push($root.onnx.SparseTensorProto.decode(reader, reader.uint32()));\n            break;\n          }\n          case 10: {\n            message.docString = reader.string();\n            break;\n          }\n          case 11: {\n            if (!(message.input && message.input.length)) message.input = [];\n            message.input.push($root.onnx.ValueInfoProto.decode(reader, reader.uint32()));\n            break;\n          }\n          case 12: {\n            if (!(message.output && message.output.length)) message.output = [];\n            message.output.push($root.onnx.ValueInfoProto.decode(reader, reader.uint32()));\n            break;\n          }\n          case 13: {\n            if (!(message.valueInfo && message.valueInfo.length)) message.valueInfo = [];\n            message.valueInfo.push($root.onnx.ValueInfoProto.decode(reader, reader.uint32()));\n            break;\n          }\n          case 14: {\n            if (!(message.quantizationAnnotation && message.quantizationAnnotation.length))\n              message.quantizationAnnotation = [];\n            message.quantizationAnnotation.push($root.onnx.TensorAnnotation.decode(reader, reader.uint32()));\n            break;\n          }\n          default:\n            reader.skipType(tag & 7);\n            break;\n        }\n      }\n      return message;\n    };\n\n    /**\n     * Decodes a GraphProto message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof onnx.GraphProto\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {onnx.GraphProto} GraphProto\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    GraphProto.decodeDelimited = function decodeDelimited(reader) {\n      if (!(reader instanceof $Reader)) reader = new $Reader(reader);\n      return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a GraphProto message.\n     * @function verify\n     * @memberof onnx.GraphProto\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    GraphProto.verify = function verify(message) {\n      if (typeof message !== 'object' || message === null) return 'object expected';\n      if (message.node != null && message.hasOwnProperty('node')) {\n        if (!Array.isArray(message.node)) return 'node: array expected';\n        for (var i = 0; i < message.node.length; ++i) {\n          var error = $root.onnx.NodeProto.verify(message.node[i]);\n          if (error) return 'node.' + error;\n        }\n      }\n      if (message.name != null && message.hasOwnProperty('name'))\n        if (!$util.isString(message.name)) return 'name: string expected';\n      if (message.initializer != null && message.hasOwnProperty('initializer')) {\n        if (!Array.isArray(message.initializer)) return 'initializer: array expected';\n        for (var i = 0; i < message.initializer.length; ++i) {\n          var error = $root.onnx.TensorProto.verify(message.initializer[i]);\n          if (error) return 'initializer.' + error;\n        }\n      }\n      if (message.sparseInitializer != null && message.hasOwnProperty('sparseInitializer')) {\n        if (!Array.isArray(message.sparseInitializer)) return 'sparseInitializer: array expected';\n        for (var i = 0; i < message.sparseInitializer.length; ++i) {\n          var error = $root.onnx.SparseTensorProto.verify(message.sparseInitializer[i]);\n          if (error) return 'sparseInitializer.' + error;\n        }\n      }\n      if (message.docString != null && message.hasOwnProperty('docString'))\n        if (!$util.isString(message.docString)) return 'docString: string expected';\n      if (message.input != null && message.hasOwnProperty('input')) {\n        if (!Array.isArray(message.input)) return 'input: array expected';\n        for (var i = 0; i < message.input.length; ++i) {\n          var error = $root.onnx.ValueInfoProto.verify(message.input[i]);\n          if (error) return 'input.' + error;\n        }\n      }\n      if (message.output != null && message.hasOwnProperty('output')) {\n        if (!Array.isArray(message.output)) return 'output: array expected';\n        for (var i = 0; i < message.output.length; ++i) {\n          var error = $root.onnx.ValueInfoProto.verify(message.output[i]);\n          if (error) return 'output.' + error;\n        }\n      }\n      if (message.valueInfo != null && message.hasOwnProperty('valueInfo')) {\n        if (!Array.isArray(message.valueInfo)) return 'valueInfo: array expected';\n        for (var i = 0; i < message.valueInfo.length; ++i) {\n          var error = $root.onnx.ValueInfoProto.verify(message.valueInfo[i]);\n          if (error) return 'valueInfo.' + error;\n        }\n      }\n      if (message.quantizationAnnotation != null && message.hasOwnProperty('quantizationAnnotation')) {\n        if (!Array.isArray(message.quantizationAnnotation)) return 'quantizationAnnotation: array expected';\n        for (var i = 0; i < message.quantizationAnnotation.length; ++i) {\n          var error = $root.onnx.TensorAnnotation.verify(message.quantizationAnnotation[i]);\n          if (error) return 'quantizationAnnotation.' + error;\n        }\n      }\n      return null;\n    };\n\n    /**\n     * Creates a GraphProto message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof onnx.GraphProto\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {onnx.GraphProto} GraphProto\n     */\n    GraphProto.fromObject = function fromObject(object) {\n      if (object instanceof $root.onnx.GraphProto) return object;\n      var message = new $root.onnx.GraphProto();\n      if (object.node) {\n        if (!Array.isArray(object.node)) throw TypeError('.onnx.GraphProto.node: array expected');\n        message.node = [];\n        for (var i = 0; i < object.node.length; ++i) {\n          if (typeof object.node[i] !== 'object') throw TypeError('.onnx.GraphProto.node: object expected');\n          message.node[i] = $root.onnx.NodeProto.fromObject(object.node[i]);\n        }\n      }\n      if (object.name != null) message.name = String(object.name);\n      if (object.initializer) {\n        if (!Array.isArray(object.initializer)) throw TypeError('.onnx.GraphProto.initializer: array expected');\n        message.initializer = [];\n        for (var i = 0; i < object.initializer.length; ++i) {\n          if (typeof object.initializer[i] !== 'object')\n            throw TypeError('.onnx.GraphProto.initializer: object expected');\n          message.initializer[i] = $root.onnx.TensorProto.fromObject(object.initializer[i]);\n        }\n      }\n      if (object.sparseInitializer) {\n        if (!Array.isArray(object.sparseInitializer))\n          throw TypeError('.onnx.GraphProto.sparseInitializer: array expected');\n        message.sparseInitializer = [];\n        for (var i = 0; i < object.sparseInitializer.length; ++i) {\n          if (typeof object.sparseInitializer[i] !== 'object')\n            throw TypeError('.onnx.GraphProto.sparseInitializer: object expected');\n          message.sparseInitializer[i] = $root.onnx.SparseTensorProto.fromObject(object.sparseInitializer[i]);\n        }\n      }\n      if (object.docString != null) message.docString = String(object.docString);\n      if (object.input) {\n        if (!Array.isArray(object.input)) throw TypeError('.onnx.GraphProto.input: array expected');\n        message.input = [];\n        for (var i = 0; i < object.input.length; ++i) {\n          if (typeof object.input[i] !== 'object') throw TypeError('.onnx.GraphProto.input: object expected');\n          message.input[i] = $root.onnx.ValueInfoProto.fromObject(object.input[i]);\n        }\n      }\n      if (object.output) {\n        if (!Array.isArray(object.output)) throw TypeError('.onnx.GraphProto.output: array expected');\n        message.output = [];\n        for (var i = 0; i < object.output.length; ++i) {\n          if (typeof object.output[i] !== 'object') throw TypeError('.onnx.GraphProto.output: object expected');\n          message.output[i] = $root.onnx.ValueInfoProto.fromObject(object.output[i]);\n        }\n      }\n      if (object.valueInfo) {\n        if (!Array.isArray(object.valueInfo)) throw TypeError('.onnx.GraphProto.valueInfo: array expected');\n        message.valueInfo = [];\n        for (var i = 0; i < object.valueInfo.length; ++i) {\n          if (typeof object.valueInfo[i] !== 'object') throw TypeError('.onnx.GraphProto.valueInfo: object expected');\n          message.valueInfo[i] = $root.onnx.ValueInfoProto.fromObject(object.valueInfo[i]);\n        }\n      }\n      if (object.quantizationAnnotation) {\n        if (!Array.isArray(object.quantizationAnnotation))\n          throw TypeError('.onnx.GraphProto.quantizationAnnotation: array expected');\n        message.quantizationAnnotation = [];\n        for (var i = 0; i < object.quantizationAnnotation.length; ++i) {\n          if (typeof object.quantizationAnnotation[i] !== 'object')\n            throw TypeError('.onnx.GraphProto.quantizationAnnotation: object expected');\n          message.quantizationAnnotation[i] = $root.onnx.TensorAnnotation.fromObject(object.quantizationAnnotation[i]);\n        }\n      }\n      return message;\n    };\n\n    /**\n     * Creates a plain object from a GraphProto message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof onnx.GraphProto\n     * @static\n     * @param {onnx.GraphProto} message GraphProto\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    GraphProto.toObject = function toObject(message, options) {\n      if (!options) options = {};\n      var object = {};\n      if (options.arrays || options.defaults) {\n        object.node = [];\n        object.initializer = [];\n        object.input = [];\n        object.output = [];\n        object.valueInfo = [];\n        object.quantizationAnnotation = [];\n        object.sparseInitializer = [];\n      }\n      if (options.defaults) {\n        object.name = '';\n        object.docString = '';\n      }\n      if (message.node && message.node.length) {\n        object.node = [];\n        for (var j = 0; j < message.node.length; ++j)\n          object.node[j] = $root.onnx.NodeProto.toObject(message.node[j], options);\n      }\n      if (message.name != null && message.hasOwnProperty('name')) object.name = message.name;\n      if (message.initializer && message.initializer.length) {\n        object.initializer = [];\n        for (var j = 0; j < message.initializer.length; ++j)\n          object.initializer[j] = $root.onnx.TensorProto.toObject(message.initializer[j], options);\n      }\n      if (message.docString != null && message.hasOwnProperty('docString')) object.docString = message.docString;\n      if (message.input && message.input.length) {\n        object.input = [];\n        for (var j = 0; j < message.input.length; ++j)\n          object.input[j] = $root.onnx.ValueInfoProto.toObject(message.input[j], options);\n      }\n      if (message.output && message.output.length) {\n        object.output = [];\n        for (var j = 0; j < message.output.length; ++j)\n          object.output[j] = $root.onnx.ValueInfoProto.toObject(message.output[j], options);\n      }\n      if (message.valueInfo && message.valueInfo.length) {\n        object.valueInfo = [];\n        for (var j = 0; j < message.valueInfo.length; ++j)\n          object.valueInfo[j] = $root.onnx.ValueInfoProto.toObject(message.valueInfo[j], options);\n      }\n      if (message.quantizationAnnotation && message.quantizationAnnotation.length) {\n        object.quantizationAnnotation = [];\n        for (var j = 0; j < message.quantizationAnnotation.length; ++j)\n          object.quantizationAnnotation[j] = $root.onnx.TensorAnnotation.toObject(\n            message.quantizationAnnotation[j],\n            options,\n          );\n      }\n      if (message.sparseInitializer && message.sparseInitializer.length) {\n        object.sparseInitializer = [];\n        for (var j = 0; j < message.sparseInitializer.length; ++j)\n          object.sparseInitializer[j] = $root.onnx.SparseTensorProto.toObject(message.sparseInitializer[j], options);\n      }\n      return object;\n    };\n\n    /**\n     * Converts this GraphProto to JSON.\n     * @function toJSON\n     * @memberof onnx.GraphProto\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    GraphProto.prototype.toJSON = function toJSON() {\n      return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    /**\n     * Gets the default type url for GraphProto\n     * @function getTypeUrl\n     * @memberof onnx.GraphProto\n     * @static\n     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default \"type.googleapis.com\")\n     * @returns {string} The default type url\n     */\n    GraphProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {\n      if (typeUrlPrefix === undefined) {\n        typeUrlPrefix = 'type.googleapis.com';\n      }\n      return typeUrlPrefix + '/onnx.GraphProto';\n    };\n\n    return GraphProto;\n  })();\n\n  onnx.TensorProto = (function () {\n    /**\n     * Properties of a TensorProto.\n     * @memberof onnx\n     * @interface ITensorProto\n     * @property {Array.<number|Long>|null} [dims] TensorProto dims\n     * @property {number|null} [dataType] TensorProto dataType\n     * @property {onnx.TensorProto.ISegment|null} [segment] TensorProto segment\n     * @property {Array.<number>|null} [floatData] TensorProto floatData\n     * @property {Array.<number>|null} [int32Data] TensorProto int32Data\n     * @property {Array.<Uint8Array>|null} [stringData] TensorProto stringData\n     * @property {Array.<number|Long>|null} [int64Data] TensorProto int64Data\n     * @property {string|null} [name] TensorProto name\n     * @property {string|null} [docString] TensorProto docString\n     * @property {Uint8Array|null} [rawData] TensorProto rawData\n     * @property {Array.<onnx.IStringStringEntryProto>|null} [externalData] TensorProto externalData\n     * @property {onnx.TensorProto.DataLocation|null} [dataLocation] TensorProto dataLocation\n     * @property {Array.<number>|null} [doubleData] TensorProto doubleData\n     * @property {Array.<number|Long>|null} [uint64Data] TensorProto uint64Data\n     */\n\n    /**\n     * Constructs a new TensorProto.\n     * @memberof onnx\n     * @classdesc Represents a TensorProto.\n     * @implements ITensorProto\n     * @constructor\n     * @param {onnx.ITensorProto=} [properties] Properties to set\n     */\n    function TensorProto(properties) {\n      this.dims = [];\n      this.floatData = [];\n      this.int32Data = [];\n      this.stringData = [];\n      this.int64Data = [];\n      this.externalData = [];\n      this.doubleData = [];\n      this.uint64Data = [];\n      if (properties)\n        for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n          if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * TensorProto dims.\n     * @member {Array.<number|Long>} dims\n     * @memberof onnx.TensorProto\n     * @instance\n     */\n    TensorProto.prototype.dims = $util.emptyArray;\n\n    /**\n     * TensorProto dataType.\n     * @member {number} dataType\n     * @memberof onnx.TensorProto\n     * @instance\n     */\n    TensorProto.prototype.dataType = 0;\n\n    /**\n     * TensorProto segment.\n     * @member {onnx.TensorProto.ISegment|null|undefined} segment\n     * @memberof onnx.TensorProto\n     * @instance\n     */\n    TensorProto.prototype.segment = null;\n\n    /**\n     * TensorProto floatData.\n     * @member {Array.<number>} floatData\n     * @memberof onnx.TensorProto\n     * @instance\n     */\n    TensorProto.prototype.floatData = $util.emptyArray;\n\n    /**\n     * TensorProto int32Data.\n     * @member {Array.<number>} int32Data\n     * @memberof onnx.TensorProto\n     * @instance\n     */\n    TensorProto.prototype.int32Data = $util.emptyArray;\n\n    /**\n     * TensorProto stringData.\n     * @member {Array.<Uint8Array>} stringData\n     * @memberof onnx.TensorProto\n     * @instance\n     */\n    TensorProto.prototype.stringData = $util.emptyArray;\n\n    /**\n     * TensorProto int64Data.\n     * @member {Array.<number|Long>} int64Data\n     * @memberof onnx.TensorProto\n     * @instance\n     */\n    TensorProto.prototype.int64Data = $util.emptyArray;\n\n    /**\n     * TensorProto name.\n     * @member {string} name\n     * @memberof onnx.TensorProto\n     * @instance\n     */\n    TensorProto.prototype.name = '';\n\n    /**\n     * TensorProto docString.\n     * @member {string} docString\n     * @memberof onnx.TensorProto\n     * @instance\n     */\n    TensorProto.prototype.docString = '';\n\n    /**\n     * TensorProto rawData.\n     * @member {Uint8Array} rawData\n     * @memberof onnx.TensorProto\n     * @instance\n     */\n    TensorProto.prototype.rawData = $util.newBuffer([]);\n\n    /**\n     * TensorProto externalData.\n     * @member {Array.<onnx.IStringStringEntryProto>} externalData\n     * @memberof onnx.TensorProto\n     * @instance\n     */\n    TensorProto.prototype.externalData = $util.emptyArray;\n\n    /**\n     * TensorProto dataLocation.\n     * @member {onnx.TensorProto.DataLocation} dataLocation\n     * @memberof onnx.TensorProto\n     * @instance\n     */\n    TensorProto.prototype.dataLocation = 0;\n\n    /**\n     * TensorProto doubleData.\n     * @member {Array.<number>} doubleData\n     * @memberof onnx.TensorProto\n     * @instance\n     */\n    TensorProto.prototype.doubleData = $util.emptyArray;\n\n    /**\n     * TensorProto uint64Data.\n     * @member {Array.<number|Long>} uint64Data\n     * @memberof onnx.TensorProto\n     * @instance\n     */\n    TensorProto.prototype.uint64Data = $util.emptyArray;\n\n    /**\n     * Creates a new TensorProto instance using the specified properties.\n     * @function create\n     * @memberof onnx.TensorProto\n     * @static\n     * @param {onnx.ITensorProto=} [properties] Properties to set\n     * @returns {onnx.TensorProto} TensorProto instance\n     */\n    TensorProto.create = function create(properties) {\n      return new TensorProto(properties);\n    };\n\n    /**\n     * Encodes the specified TensorProto message. Does not implicitly {@link onnx.TensorProto.verify|verify} messages.\n     * @function encode\n     * @memberof onnx.TensorProto\n     * @static\n     * @param {onnx.ITensorProto} message TensorProto message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    TensorProto.encode = function encode(message, writer) {\n      if (!writer) writer = $Writer.create();\n      if (message.dims != null && message.dims.length) {\n        writer.uint32(/* id 1, wireType 2 =*/ 10).fork();\n        for (var i = 0; i < message.dims.length; ++i) writer.int64(message.dims[i]);\n        writer.ldelim();\n      }\n      if (message.dataType != null && Object.hasOwnProperty.call(message, 'dataType'))\n        writer.uint32(/* id 2, wireType 0 =*/ 16).int32(message.dataType);\n      if (message.segment != null && Object.hasOwnProperty.call(message, 'segment'))\n        $root.onnx.TensorProto.Segment.encode(\n          message.segment,\n          writer.uint32(/* id 3, wireType 2 =*/ 26).fork(),\n        ).ldelim();\n      if (message.floatData != null && message.floatData.length) {\n        writer.uint32(/* id 4, wireType 2 =*/ 34).fork();\n        for (var i = 0; i < message.floatData.length; ++i) writer.float(message.floatData[i]);\n        writer.ldelim();\n      }\n      if (message.int32Data != null && message.int32Data.length) {\n        writer.uint32(/* id 5, wireType 2 =*/ 42).fork();\n        for (var i = 0; i < message.int32Data.length; ++i) writer.int32(message.int32Data[i]);\n        writer.ldelim();\n      }\n      if (message.stringData != null && message.stringData.length)\n        for (var i = 0; i < message.stringData.length; ++i)\n          writer.uint32(/* id 6, wireType 2 =*/ 50).bytes(message.stringData[i]);\n      if (message.int64Data != null && message.int64Data.length) {\n        writer.uint32(/* id 7, wireType 2 =*/ 58).fork();\n        for (var i = 0; i < message.int64Data.length; ++i) writer.int64(message.int64Data[i]);\n        writer.ldelim();\n      }\n      if (message.name != null && Object.hasOwnProperty.call(message, 'name'))\n        writer.uint32(/* id 8, wireType 2 =*/ 66).string(message.name);\n      if (message.rawData != null && Object.hasOwnProperty.call(message, 'rawData'))\n        writer.uint32(/* id 9, wireType 2 =*/ 74).bytes(message.rawData);\n      if (message.doubleData != null && message.doubleData.length) {\n        writer.uint32(/* id 10, wireType 2 =*/ 82).fork();\n        for (var i = 0; i < message.doubleData.length; ++i) writer.double(message.doubleData[i]);\n        writer.ldelim();\n      }\n      if (message.uint64Data != null && message.uint64Data.length) {\n        writer.uint32(/* id 11, wireType 2 =*/ 90).fork();\n        for (var i = 0; i < message.uint64Data.length; ++i) writer.uint64(message.uint64Data[i]);\n        writer.ldelim();\n      }\n      if (message.docString != null && Object.hasOwnProperty.call(message, 'docString'))\n        writer.uint32(/* id 12, wireType 2 =*/ 98).string(message.docString);\n      if (message.externalData != null && message.externalData.length)\n        for (var i = 0; i < message.externalData.length; ++i)\n          $root.onnx.StringStringEntryProto.encode(\n            message.externalData[i],\n            writer.uint32(/* id 13, wireType 2 =*/ 106).fork(),\n          ).ldelim();\n      if (message.dataLocation != null && Object.hasOwnProperty.call(message, 'dataLocation'))\n        writer.uint32(/* id 14, wireType 0 =*/ 112).int32(message.dataLocation);\n      return writer;\n    };\n\n    /**\n     * Encodes the specified TensorProto message, length delimited. Does not implicitly {@link onnx.TensorProto.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof onnx.TensorProto\n     * @static\n     * @param {onnx.ITensorProto} message TensorProto message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    TensorProto.encodeDelimited = function encodeDelimited(message, writer) {\n      return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a TensorProto message from the specified reader or buffer.\n     * @function decode\n     * @memberof onnx.TensorProto\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {onnx.TensorProto} TensorProto\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    TensorProto.decode = function decode(reader, length) {\n      if (!(reader instanceof $Reader)) reader = $Reader.create(reader);\n      var end = length === undefined ? reader.len : reader.pos + length,\n        message = new $root.onnx.TensorProto();\n      while (reader.pos < end) {\n        var tag = reader.uint32();\n        switch (tag >>> 3) {\n          case 1: {\n            if (!(message.dims && message.dims.length)) message.dims = [];\n            if ((tag & 7) === 2) {\n              var end2 = reader.uint32() + reader.pos;\n              while (reader.pos < end2) message.dims.push(reader.int64());\n            } else message.dims.push(reader.int64());\n            break;\n          }\n          case 2: {\n            message.dataType = reader.int32();\n            break;\n          }\n          case 3: {\n            message.segment = $root.onnx.TensorProto.Segment.decode(reader, reader.uint32());\n            break;\n          }\n          case 4: {\n            if (!(message.floatData && message.floatData.length)) message.floatData = [];\n            if ((tag & 7) === 2) {\n              var end2 = reader.uint32() + reader.pos;\n              while (reader.pos < end2) message.floatData.push(reader.float());\n            } else message.floatData.push(reader.float());\n            break;\n          }\n          case 5: {\n            if (!(message.int32Data && message.int32Data.length)) message.int32Data = [];\n            if ((tag & 7) === 2) {\n              var end2 = reader.uint32() + reader.pos;\n              while (reader.pos < end2) message.int32Data.push(reader.int32());\n            } else message.int32Data.push(reader.int32());\n            break;\n          }\n          case 6: {\n            if (!(message.stringData && message.stringData.length)) message.stringData = [];\n            message.stringData.push(reader.bytes());\n            break;\n          }\n          case 7: {\n            if (!(message.int64Data && message.int64Data.length)) message.int64Data = [];\n            if ((tag & 7) === 2) {\n              var end2 = reader.uint32() + reader.pos;\n              while (reader.pos < end2) message.int64Data.push(reader.int64());\n            } else message.int64Data.push(reader.int64());\n            break;\n          }\n          case 8: {\n            message.name = reader.string();\n            break;\n          }\n          case 12: {\n            message.docString = reader.string();\n            break;\n          }\n          case 9: {\n            message.rawData = reader.bytes();\n            break;\n          }\n          case 13: {\n            if (!(message.externalData && message.externalData.length)) message.externalData = [];\n            message.externalData.push($root.onnx.StringStringEntryProto.decode(reader, reader.uint32()));\n            break;\n          }\n          case 14: {\n            message.dataLocation = reader.int32();\n            break;\n          }\n          case 10: {\n            if (!(message.doubleData && message.doubleData.length)) message.doubleData = [];\n            if ((tag & 7) === 2) {\n              var end2 = reader.uint32() + reader.pos;\n              while (reader.pos < end2) message.doubleData.push(reader.double());\n            } else message.doubleData.push(reader.double());\n            break;\n          }\n          case 11: {\n            if (!(message.uint64Data && message.uint64Data.length)) message.uint64Data = [];\n            if ((tag & 7) === 2) {\n              var end2 = reader.uint32() + reader.pos;\n              while (reader.pos < end2) message.uint64Data.push(reader.uint64());\n            } else message.uint64Data.push(reader.uint64());\n            break;\n          }\n          default:\n            reader.skipType(tag & 7);\n            break;\n        }\n      }\n      return message;\n    };\n\n    /**\n     * Decodes a TensorProto message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof onnx.TensorProto\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {onnx.TensorProto} TensorProto\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    TensorProto.decodeDelimited = function decodeDelimited(reader) {\n      if (!(reader instanceof $Reader)) reader = new $Reader(reader);\n      return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a TensorProto message.\n     * @function verify\n     * @memberof onnx.TensorProto\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    TensorProto.verify = function verify(message) {\n      if (typeof message !== 'object' || message === null) return 'object expected';\n      if (message.dims != null && message.hasOwnProperty('dims')) {\n        if (!Array.isArray(message.dims)) return 'dims: array expected';\n        for (var i = 0; i < message.dims.length; ++i)\n          if (\n            !$util.isInteger(message.dims[i]) &&\n            !(message.dims[i] && $util.isInteger(message.dims[i].low) && $util.isInteger(message.dims[i].high))\n          )\n            return 'dims: integer|Long[] expected';\n      }\n      if (message.dataType != null && message.hasOwnProperty('dataType'))\n        if (!$util.isInteger(message.dataType)) return 'dataType: integer expected';\n      if (message.segment != null && message.hasOwnProperty('segment')) {\n        var error = $root.onnx.TensorProto.Segment.verify(message.segment);\n        if (error) return 'segment.' + error;\n      }\n      if (message.floatData != null && message.hasOwnProperty('floatData')) {\n        if (!Array.isArray(message.floatData)) return 'floatData: array expected';\n        for (var i = 0; i < message.floatData.length; ++i)\n          if (typeof message.floatData[i] !== 'number') return 'floatData: number[] expected';\n      }\n      if (message.int32Data != null && message.hasOwnProperty('int32Data')) {\n        if (!Array.isArray(message.int32Data)) return 'int32Data: array expected';\n        for (var i = 0; i < message.int32Data.length; ++i)\n          if (!$util.isInteger(message.int32Data[i])) return 'int32Data: integer[] expected';\n      }\n      if (message.stringData != null && message.hasOwnProperty('stringData')) {\n        if (!Array.isArray(message.stringData)) return 'stringData: array expected';\n        for (var i = 0; i < message.stringData.length; ++i)\n          if (\n            !(\n              (message.stringData[i] && typeof message.stringData[i].length === 'number') ||\n              $util.isString(message.stringData[i])\n            )\n          )\n            return 'stringData: buffer[] expected';\n      }\n      if (message.int64Data != null && message.hasOwnProperty('int64Data')) {\n        if (!Array.isArray(message.int64Data)) return 'int64Data: array expected';\n        for (var i = 0; i < message.int64Data.length; ++i)\n          if (\n            !$util.isInteger(message.int64Data[i]) &&\n            !(\n              message.int64Data[i] &&\n              $util.isInteger(message.int64Data[i].low) &&\n              $util.isInteger(message.int64Data[i].high)\n            )\n          )\n            return 'int64Data: integer|Long[] expected';\n      }\n      if (message.name != null && message.hasOwnProperty('name'))\n        if (!$util.isString(message.name)) return 'name: string expected';\n      if (message.docString != null && message.hasOwnProperty('docString'))\n        if (!$util.isString(message.docString)) return 'docString: string expected';\n      if (message.rawData != null && message.hasOwnProperty('rawData'))\n        if (!((message.rawData && typeof message.rawData.length === 'number') || $util.isString(message.rawData)))\n          return 'rawData: buffer expected';\n      if (message.externalData != null && message.hasOwnProperty('externalData')) {\n        if (!Array.isArray(message.externalData)) return 'externalData: array expected';\n        for (var i = 0; i < message.externalData.length; ++i) {\n          var error = $root.onnx.StringStringEntryProto.verify(message.externalData[i]);\n          if (error) return 'externalData.' + error;\n        }\n      }\n      if (message.dataLocation != null && message.hasOwnProperty('dataLocation'))\n        switch (message.dataLocation) {\n          default:\n            return 'dataLocation: enum value expected';\n          case 0:\n          case 1:\n            break;\n        }\n      if (message.doubleData != null && message.hasOwnProperty('doubleData')) {\n        if (!Array.isArray(message.doubleData)) return 'doubleData: array expected';\n        for (var i = 0; i < message.doubleData.length; ++i)\n          if (typeof message.doubleData[i] !== 'number') return 'doubleData: number[] expected';\n      }\n      if (message.uint64Data != null && message.hasOwnProperty('uint64Data')) {\n        if (!Array.isArray(message.uint64Data)) return 'uint64Data: array expected';\n        for (var i = 0; i < message.uint64Data.length; ++i)\n          if (\n            !$util.isInteger(message.uint64Data[i]) &&\n            !(\n              message.uint64Data[i] &&\n              $util.isInteger(message.uint64Data[i].low) &&\n              $util.isInteger(message.uint64Data[i].high)\n            )\n          )\n            return 'uint64Data: integer|Long[] expected';\n      }\n      return null;\n    };\n\n    /**\n     * Creates a TensorProto message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof onnx.TensorProto\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {onnx.TensorProto} TensorProto\n     */\n    TensorProto.fromObject = function fromObject(object) {\n      if (object instanceof $root.onnx.TensorProto) return object;\n      var message = new $root.onnx.TensorProto();\n      if (object.dims) {\n        if (!Array.isArray(object.dims)) throw TypeError('.onnx.TensorProto.dims: array expected');\n        message.dims = [];\n        for (var i = 0; i < object.dims.length; ++i)\n          if ($util.Long) (message.dims[i] = $util.Long.fromValue(object.dims[i])).unsigned = false;\n          else if (typeof object.dims[i] === 'string') message.dims[i] = parseInt(object.dims[i], 10);\n          else if (typeof object.dims[i] === 'number') message.dims[i] = object.dims[i];\n          else if (typeof object.dims[i] === 'object')\n            message.dims[i] = new $util.LongBits(object.dims[i].low >>> 0, object.dims[i].high >>> 0).toNumber();\n      }\n      if (object.dataType != null) message.dataType = object.dataType | 0;\n      if (object.segment != null) {\n        if (typeof object.segment !== 'object') throw TypeError('.onnx.TensorProto.segment: object expected');\n        message.segment = $root.onnx.TensorProto.Segment.fromObject(object.segment);\n      }\n      if (object.floatData) {\n        if (!Array.isArray(object.floatData)) throw TypeError('.onnx.TensorProto.floatData: array expected');\n        message.floatData = [];\n        for (var i = 0; i < object.floatData.length; ++i) message.floatData[i] = Number(object.floatData[i]);\n      }\n      if (object.int32Data) {\n        if (!Array.isArray(object.int32Data)) throw TypeError('.onnx.TensorProto.int32Data: array expected');\n        message.int32Data = [];\n        for (var i = 0; i < object.int32Data.length; ++i) message.int32Data[i] = object.int32Data[i] | 0;\n      }\n      if (object.stringData) {\n        if (!Array.isArray(object.stringData)) throw TypeError('.onnx.TensorProto.stringData: array expected');\n        message.stringData = [];\n        for (var i = 0; i < object.stringData.length; ++i)\n          if (typeof object.stringData[i] === 'string')\n            $util.base64.decode(\n              object.stringData[i],\n              (message.stringData[i] = $util.newBuffer($util.base64.length(object.stringData[i]))),\n              0,\n            );\n          else if (object.stringData[i].length >= 0) message.stringData[i] = object.stringData[i];\n      }\n      if (object.int64Data) {\n        if (!Array.isArray(object.int64Data)) throw TypeError('.onnx.TensorProto.int64Data: array expected');\n        message.int64Data = [];\n        for (var i = 0; i < object.int64Data.length; ++i)\n          if ($util.Long) (message.int64Data[i] = $util.Long.fromValue(object.int64Data[i])).unsigned = false;\n          else if (typeof object.int64Data[i] === 'string') message.int64Data[i] = parseInt(object.int64Data[i], 10);\n          else if (typeof object.int64Data[i] === 'number') message.int64Data[i] = object.int64Data[i];\n          else if (typeof object.int64Data[i] === 'object')\n            message.int64Data[i] = new $util.LongBits(\n              object.int64Data[i].low >>> 0,\n              object.int64Data[i].high >>> 0,\n            ).toNumber();\n      }\n      if (object.name != null) message.name = String(object.name);\n      if (object.docString != null) message.docString = String(object.docString);\n      if (object.rawData != null)\n        if (typeof object.rawData === 'string')\n          $util.base64.decode(\n            object.rawData,\n            (message.rawData = $util.newBuffer($util.base64.length(object.rawData))),\n            0,\n          );\n        else if (object.rawData.length >= 0) message.rawData = object.rawData;\n      if (object.externalData) {\n        if (!Array.isArray(object.externalData)) throw TypeError('.onnx.TensorProto.externalData: array expected');\n        message.externalData = [];\n        for (var i = 0; i < object.externalData.length; ++i) {\n          if (typeof object.externalData[i] !== 'object')\n            throw TypeError('.onnx.TensorProto.externalData: object expected');\n          message.externalData[i] = $root.onnx.StringStringEntryProto.fromObject(object.externalData[i]);\n        }\n      }\n      switch (object.dataLocation) {\n        default:\n          if (typeof object.dataLocation === 'number') {\n            message.dataLocation = object.dataLocation;\n            break;\n          }\n          break;\n        case 'DEFAULT':\n        case 0:\n          message.dataLocation = 0;\n          break;\n        case 'EXTERNAL':\n        case 1:\n          message.dataLocation = 1;\n          break;\n      }\n      if (object.doubleData) {\n        if (!Array.isArray(object.doubleData)) throw TypeError('.onnx.TensorProto.doubleData: array expected');\n        message.doubleData = [];\n        for (var i = 0; i < object.doubleData.length; ++i) message.doubleData[i] = Number(object.doubleData[i]);\n      }\n      if (object.uint64Data) {\n        if (!Array.isArray(object.uint64Data)) throw TypeError('.onnx.TensorProto.uint64Data: array expected');\n        message.uint64Data = [];\n        for (var i = 0; i < object.uint64Data.length; ++i)\n          if ($util.Long) (message.uint64Data[i] = $util.Long.fromValue(object.uint64Data[i])).unsigned = true;\n          else if (typeof object.uint64Data[i] === 'string') message.uint64Data[i] = parseInt(object.uint64Data[i], 10);\n          else if (typeof object.uint64Data[i] === 'number') message.uint64Data[i] = object.uint64Data[i];\n          else if (typeof object.uint64Data[i] === 'object')\n            message.uint64Data[i] = new $util.LongBits(\n              object.uint64Data[i].low >>> 0,\n              object.uint64Data[i].high >>> 0,\n            ).toNumber(true);\n      }\n      return message;\n    };\n\n    /**\n     * Creates a plain object from a TensorProto message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof onnx.TensorProto\n     * @static\n     * @param {onnx.TensorProto} message TensorProto\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    TensorProto.toObject = function toObject(message, options) {\n      if (!options) options = {};\n      var object = {};\n      if (options.arrays || options.defaults) {\n        object.dims = [];\n        object.floatData = [];\n        object.int32Data = [];\n        object.stringData = [];\n        object.int64Data = [];\n        object.doubleData = [];\n        object.uint64Data = [];\n        object.externalData = [];\n      }\n      if (options.defaults) {\n        object.dataType = 0;\n        object.segment = null;\n        object.name = '';\n        if (options.bytes === String) object.rawData = '';\n        else {\n          object.rawData = [];\n          if (options.bytes !== Array) object.rawData = $util.newBuffer(object.rawData);\n        }\n        object.docString = '';\n        object.dataLocation = options.enums === String ? 'DEFAULT' : 0;\n      }\n      if (message.dims && message.dims.length) {\n        object.dims = [];\n        for (var j = 0; j < message.dims.length; ++j)\n          if (typeof message.dims[j] === 'number')\n            object.dims[j] = options.longs === String ? String(message.dims[j]) : message.dims[j];\n          else\n            object.dims[j] =\n              options.longs === String\n                ? $util.Long.prototype.toString.call(message.dims[j])\n                : options.longs === Number\n                  ? new $util.LongBits(message.dims[j].low >>> 0, message.dims[j].high >>> 0).toNumber()\n                  : message.dims[j];\n      }\n      if (message.dataType != null && message.hasOwnProperty('dataType')) object.dataType = message.dataType;\n      if (message.segment != null && message.hasOwnProperty('segment'))\n        object.segment = $root.onnx.TensorProto.Segment.toObject(message.segment, options);\n      if (message.floatData && message.floatData.length) {\n        object.floatData = [];\n        for (var j = 0; j < message.floatData.length; ++j)\n          object.floatData[j] =\n            options.json && !isFinite(message.floatData[j]) ? String(message.floatData[j]) : message.floatData[j];\n      }\n      if (message.int32Data && message.int32Data.length) {\n        object.int32Data = [];\n        for (var j = 0; j < message.int32Data.length; ++j) object.int32Data[j] = message.int32Data[j];\n      }\n      if (message.stringData && message.stringData.length) {\n        object.stringData = [];\n        for (var j = 0; j < message.stringData.length; ++j)\n          object.stringData[j] =\n            options.bytes === String\n              ? $util.base64.encode(message.stringData[j], 0, message.stringData[j].length)\n              : options.bytes === Array\n                ? Array.prototype.slice.call(message.stringData[j])\n                : message.stringData[j];\n      }\n      if (message.int64Data && message.int64Data.length) {\n        object.int64Data = [];\n        for (var j = 0; j < message.int64Data.length; ++j)\n          if (typeof message.int64Data[j] === 'number')\n            object.int64Data[j] = options.longs === String ? String(message.int64Data[j]) : message.int64Data[j];\n          else\n            object.int64Data[j] =\n              options.longs === String\n                ? $util.Long.prototype.toString.call(message.int64Data[j])\n                : options.longs === Number\n                  ? new $util.LongBits(message.int64Data[j].low >>> 0, message.int64Data[j].high >>> 0).toNumber()\n                  : message.int64Data[j];\n      }\n      if (message.name != null && message.hasOwnProperty('name')) object.name = message.name;\n      if (message.rawData != null && message.hasOwnProperty('rawData'))\n        object.rawData =\n          options.bytes === String\n            ? $util.base64.encode(message.rawData, 0, message.rawData.length)\n            : options.bytes === Array\n              ? Array.prototype.slice.call(message.rawData)\n              : message.rawData;\n      if (message.doubleData && message.doubleData.length) {\n        object.doubleData = [];\n        for (var j = 0; j < message.doubleData.length; ++j)\n          object.doubleData[j] =\n            options.json && !isFinite(message.doubleData[j]) ? String(message.doubleData[j]) : message.doubleData[j];\n      }\n      if (message.uint64Data && message.uint64Data.length) {\n        object.uint64Data = [];\n        for (var j = 0; j < message.uint64Data.length; ++j)\n          if (typeof message.uint64Data[j] === 'number')\n            object.uint64Data[j] = options.longs === String ? String(message.uint64Data[j]) : message.uint64Data[j];\n          else\n            object.uint64Data[j] =\n              options.longs === String\n                ? $util.Long.prototype.toString.call(message.uint64Data[j])\n                : options.longs === Number\n                  ? new $util.LongBits(message.uint64Data[j].low >>> 0, message.uint64Data[j].high >>> 0).toNumber(true)\n                  : message.uint64Data[j];\n      }\n      if (message.docString != null && message.hasOwnProperty('docString')) object.docString = message.docString;\n      if (message.externalData && message.externalData.length) {\n        object.externalData = [];\n        for (var j = 0; j < message.externalData.length; ++j)\n          object.externalData[j] = $root.onnx.StringStringEntryProto.toObject(message.externalData[j], options);\n      }\n      if (message.dataLocation != null && message.hasOwnProperty('dataLocation'))\n        object.dataLocation =\n          options.enums === String\n            ? $root.onnx.TensorProto.DataLocation[message.dataLocation] === undefined\n              ? message.dataLocation\n              : $root.onnx.TensorProto.DataLocation[message.dataLocation]\n            : message.dataLocation;\n      return object;\n    };\n\n    /**\n     * Converts this TensorProto to JSON.\n     * @function toJSON\n     * @memberof onnx.TensorProto\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    TensorProto.prototype.toJSON = function toJSON() {\n      return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    /**\n     * Gets the default type url for TensorProto\n     * @function getTypeUrl\n     * @memberof onnx.TensorProto\n     * @static\n     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default \"type.googleapis.com\")\n     * @returns {string} The default type url\n     */\n    TensorProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {\n      if (typeUrlPrefix === undefined) {\n        typeUrlPrefix = 'type.googleapis.com';\n      }\n      return typeUrlPrefix + '/onnx.TensorProto';\n    };\n\n    /**\n     * DataType enum.\n     * @name onnx.TensorProto.DataType\n     * @enum {number}\n     * @property {number} UNDEFINED=0 UNDEFINED value\n     * @property {number} FLOAT=1 FLOAT value\n     * @property {number} UINT8=2 UINT8 value\n     * @property {number} INT8=3 INT8 value\n     * @property {number} UINT16=4 UINT16 value\n     * @property {number} INT16=5 INT16 value\n     * @property {number} INT32=6 INT32 value\n     * @property {number} INT64=7 INT64 value\n     * @property {number} STRING=8 STRING value\n     * @property {number} BOOL=9 BOOL value\n     * @property {number} FLOAT16=10 FLOAT16 value\n     * @property {number} DOUBLE=11 DOUBLE value\n     * @property {number} UINT32=12 UINT32 value\n     * @property {number} UINT64=13 UINT64 value\n     * @property {number} COMPLEX64=14 COMPLEX64 value\n     * @property {number} COMPLEX128=15 COMPLEX128 value\n     * @property {number} BFLOAT16=16 BFLOAT16 value\n     * @property {number} FLOAT8E4M3FN=17 FLOAT8E4M3FN value\n     * @property {number} FLOAT8E4M3FNUZ=18 FLOAT8E4M3FNUZ value\n     * @property {number} FLOAT8E5M2=19 FLOAT8E5M2 value\n     * @property {number} FLOAT8E5M2FNUZ=20 FLOAT8E5M2FNUZ value\n     */\n    TensorProto.DataType = (function () {\n      var valuesById = {},\n        values = Object.create(valuesById);\n      values[(valuesById[0] = 'UNDEFINED')] = 0;\n      values[(valuesById[1] = 'FLOAT')] = 1;\n      values[(valuesById[2] = 'UINT8')] = 2;\n      values[(valuesById[3] = 'INT8')] = 3;\n      values[(valuesById[4] = 'UINT16')] = 4;\n      values[(valuesById[5] = 'INT16')] = 5;\n      values[(valuesById[6] = 'INT32')] = 6;\n      values[(valuesById[7] = 'INT64')] = 7;\n      values[(valuesById[8] = 'STRING')] = 8;\n      values[(valuesById[9] = 'BOOL')] = 9;\n      values[(valuesById[10] = 'FLOAT16')] = 10;\n      values[(valuesById[11] = 'DOUBLE')] = 11;\n      values[(valuesById[12] = 'UINT32')] = 12;\n      values[(valuesById[13] = 'UINT64')] = 13;\n      values[(valuesById[14] = 'COMPLEX64')] = 14;\n      values[(valuesById[15] = 'COMPLEX128')] = 15;\n      values[(valuesById[16] = 'BFLOAT16')] = 16;\n      values[(valuesById[17] = 'FLOAT8E4M3FN')] = 17;\n      values[(valuesById[18] = 'FLOAT8E4M3FNUZ')] = 18;\n      values[(valuesById[19] = 'FLOAT8E5M2')] = 19;\n      values[(valuesById[20] = 'FLOAT8E5M2FNUZ')] = 20;\n      return values;\n    })();\n\n    TensorProto.Segment = (function () {\n      /**\n       * Properties of a Segment.\n       * @memberof onnx.TensorProto\n       * @interface ISegment\n       * @property {number|Long|null} [begin] Segment begin\n       * @property {number|Long|null} [end] Segment end\n       */\n\n      /**\n       * Constructs a new Segment.\n       * @memberof onnx.TensorProto\n       * @classdesc Represents a Segment.\n       * @implements ISegment\n       * @constructor\n       * @param {onnx.TensorProto.ISegment=} [properties] Properties to set\n       */\n      function Segment(properties) {\n        if (properties)\n          for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n            if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];\n      }\n\n      /**\n       * Segment begin.\n       * @member {number|Long} begin\n       * @memberof onnx.TensorProto.Segment\n       * @instance\n       */\n      Segment.prototype.begin = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;\n\n      /**\n       * Segment end.\n       * @member {number|Long} end\n       * @memberof onnx.TensorProto.Segment\n       * @instance\n       */\n      Segment.prototype.end = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;\n\n      /**\n       * Creates a new Segment instance using the specified properties.\n       * @function create\n       * @memberof onnx.TensorProto.Segment\n       * @static\n       * @param {onnx.TensorProto.ISegment=} [properties] Properties to set\n       * @returns {onnx.TensorProto.Segment} Segment instance\n       */\n      Segment.create = function create(properties) {\n        return new Segment(properties);\n      };\n\n      /**\n       * Encodes the specified Segment message. Does not implicitly {@link onnx.TensorProto.Segment.verify|verify} messages.\n       * @function encode\n       * @memberof onnx.TensorProto.Segment\n       * @static\n       * @param {onnx.TensorProto.ISegment} message Segment message or plain object to encode\n       * @param {$protobuf.Writer} [writer] Writer to encode to\n       * @returns {$protobuf.Writer} Writer\n       */\n      Segment.encode = function encode(message, writer) {\n        if (!writer) writer = $Writer.create();\n        if (message.begin != null && Object.hasOwnProperty.call(message, 'begin'))\n          writer.uint32(/* id 1, wireType 0 =*/ 8).int64(message.begin);\n        if (message.end != null && Object.hasOwnProperty.call(message, 'end'))\n          writer.uint32(/* id 2, wireType 0 =*/ 16).int64(message.end);\n        return writer;\n      };\n\n      /**\n       * Encodes the specified Segment message, length delimited. Does not implicitly {@link onnx.TensorProto.Segment.verify|verify} messages.\n       * @function encodeDelimited\n       * @memberof onnx.TensorProto.Segment\n       * @static\n       * @param {onnx.TensorProto.ISegment} message Segment message or plain object to encode\n       * @param {$protobuf.Writer} [writer] Writer to encode to\n       * @returns {$protobuf.Writer} Writer\n       */\n      Segment.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n      };\n\n      /**\n       * Decodes a Segment message from the specified reader or buffer.\n       * @function decode\n       * @memberof onnx.TensorProto.Segment\n       * @static\n       * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n       * @param {number} [length] Message length if known beforehand\n       * @returns {onnx.TensorProto.Segment} Segment\n       * @throws {Error} If the payload is not a reader or valid buffer\n       * @throws {$protobuf.util.ProtocolError} If required fields are missing\n       */\n      Segment.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader)) reader = $Reader.create(reader);\n        var end = length === undefined ? reader.len : reader.pos + length,\n          message = new $root.onnx.TensorProto.Segment();\n        while (reader.pos < end) {\n          var tag = reader.uint32();\n          switch (tag >>> 3) {\n            case 1: {\n              message.begin = reader.int64();\n              break;\n            }\n            case 2: {\n              message.end = reader.int64();\n              break;\n            }\n            default:\n              reader.skipType(tag & 7);\n              break;\n          }\n        }\n        return message;\n      };\n\n      /**\n       * Decodes a Segment message from the specified reader or buffer, length delimited.\n       * @function decodeDelimited\n       * @memberof onnx.TensorProto.Segment\n       * @static\n       * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n       * @returns {onnx.TensorProto.Segment} Segment\n       * @throws {Error} If the payload is not a reader or valid buffer\n       * @throws {$protobuf.util.ProtocolError} If required fields are missing\n       */\n      Segment.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader)) reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n      };\n\n      /**\n       * Verifies a Segment message.\n       * @function verify\n       * @memberof onnx.TensorProto.Segment\n       * @static\n       * @param {Object.<string,*>} message Plain object to verify\n       * @returns {string|null} `null` if valid, otherwise the reason why it is not\n       */\n      Segment.verify = function verify(message) {\n        if (typeof message !== 'object' || message === null) return 'object expected';\n        if (message.begin != null && message.hasOwnProperty('begin'))\n          if (\n            !$util.isInteger(message.begin) &&\n            !(message.begin && $util.isInteger(message.begin.low) && $util.isInteger(message.begin.high))\n          )\n            return 'begin: integer|Long expected';\n        if (message.end != null && message.hasOwnProperty('end'))\n          if (\n            !$util.isInteger(message.end) &&\n            !(message.end && $util.isInteger(message.end.low) && $util.isInteger(message.end.high))\n          )\n            return 'end: integer|Long expected';\n        return null;\n      };\n\n      /**\n       * Creates a Segment message from a plain object. Also converts values to their respective internal types.\n       * @function fromObject\n       * @memberof onnx.TensorProto.Segment\n       * @static\n       * @param {Object.<string,*>} object Plain object\n       * @returns {onnx.TensorProto.Segment} Segment\n       */\n      Segment.fromObject = function fromObject(object) {\n        if (object instanceof $root.onnx.TensorProto.Segment) return object;\n        var message = new $root.onnx.TensorProto.Segment();\n        if (object.begin != null)\n          if ($util.Long) (message.begin = $util.Long.fromValue(object.begin)).unsigned = false;\n          else if (typeof object.begin === 'string') message.begin = parseInt(object.begin, 10);\n          else if (typeof object.begin === 'number') message.begin = object.begin;\n          else if (typeof object.begin === 'object')\n            message.begin = new $util.LongBits(object.begin.low >>> 0, object.begin.high >>> 0).toNumber();\n        if (object.end != null)\n          if ($util.Long) (message.end = $util.Long.fromValue(object.end)).unsigned = false;\n          else if (typeof object.end === 'string') message.end = parseInt(object.end, 10);\n          else if (typeof object.end === 'number') message.end = object.end;\n          else if (typeof object.end === 'object')\n            message.end = new $util.LongBits(object.end.low >>> 0, object.end.high >>> 0).toNumber();\n        return message;\n      };\n\n      /**\n       * Creates a plain object from a Segment message. Also converts values to other types if specified.\n       * @function toObject\n       * @memberof onnx.TensorProto.Segment\n       * @static\n       * @param {onnx.TensorProto.Segment} message Segment\n       * @param {$protobuf.IConversionOptions} [options] Conversion options\n       * @returns {Object.<string,*>} Plain object\n       */\n      Segment.toObject = function toObject(message, options) {\n        if (!options) options = {};\n        var object = {};\n        if (options.defaults) {\n          if ($util.Long) {\n            var long = new $util.Long(0, 0, false);\n            object.begin =\n              options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;\n          } else object.begin = options.longs === String ? '0' : 0;\n          if ($util.Long) {\n            var long = new $util.Long(0, 0, false);\n            object.end = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;\n          } else object.end = options.longs === String ? '0' : 0;\n        }\n        if (message.begin != null && message.hasOwnProperty('begin'))\n          if (typeof message.begin === 'number')\n            object.begin = options.longs === String ? String(message.begin) : message.begin;\n          else\n            object.begin =\n              options.longs === String\n                ? $util.Long.prototype.toString.call(message.begin)\n                : options.longs === Number\n                  ? new $util.LongBits(message.begin.low >>> 0, message.begin.high >>> 0).toNumber()\n                  : message.begin;\n        if (message.end != null && message.hasOwnProperty('end'))\n          if (typeof message.end === 'number')\n            object.end = options.longs === String ? String(message.end) : message.end;\n          else\n            object.end =\n              options.longs === String\n                ? $util.Long.prototype.toString.call(message.end)\n                : options.longs === Number\n                  ? new $util.LongBits(message.end.low >>> 0, message.end.high >>> 0).toNumber()\n                  : message.end;\n        return object;\n      };\n\n      /**\n       * Converts this Segment to JSON.\n       * @function toJSON\n       * @memberof onnx.TensorProto.Segment\n       * @instance\n       * @returns {Object.<string,*>} JSON object\n       */\n      Segment.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n      };\n\n      /**\n       * Gets the default type url for Segment\n       * @function getTypeUrl\n       * @memberof onnx.TensorProto.Segment\n       * @static\n       * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default \"type.googleapis.com\")\n       * @returns {string} The default type url\n       */\n      Segment.getTypeUrl = function getTypeUrl(typeUrlPrefix) {\n        if (typeUrlPrefix === undefined) {\n          typeUrlPrefix = 'type.googleapis.com';\n        }\n        return typeUrlPrefix + '/onnx.TensorProto.Segment';\n      };\n\n      return Segment;\n    })();\n\n    /**\n     * DataLocation enum.\n     * @name onnx.TensorProto.DataLocation\n     * @enum {number}\n     * @property {number} DEFAULT=0 DEFAULT value\n     * @property {number} EXTERNAL=1 EXTERNAL value\n     */\n    TensorProto.DataLocation = (function () {\n      var valuesById = {},\n        values = Object.create(valuesById);\n      values[(valuesById[0] = 'DEFAULT')] = 0;\n      values[(valuesById[1] = 'EXTERNAL')] = 1;\n      return values;\n    })();\n\n    return TensorProto;\n  })();\n\n  onnx.SparseTensorProto = (function () {\n    /**\n     * Properties of a SparseTensorProto.\n     * @memberof onnx\n     * @interface ISparseTensorProto\n     * @property {onnx.ITensorProto|null} [values] SparseTensorProto values\n     * @property {onnx.ITensorProto|null} [indices] SparseTensorProto indices\n     * @property {Array.<number|Long>|null} [dims] SparseTensorProto dims\n     */\n\n    /**\n     * Constructs a new SparseTensorProto.\n     * @memberof onnx\n     * @classdesc Represents a SparseTensorProto.\n     * @implements ISparseTensorProto\n     * @constructor\n     * @param {onnx.ISparseTensorProto=} [properties] Properties to set\n     */\n    function SparseTensorProto(properties) {\n      this.dims = [];\n      if (properties)\n        for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n          if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * SparseTensorProto values.\n     * @member {onnx.ITensorProto|null|undefined} values\n     * @memberof onnx.SparseTensorProto\n     * @instance\n     */\n    SparseTensorProto.prototype.values = null;\n\n    /**\n     * SparseTensorProto indices.\n     * @member {onnx.ITensorProto|null|undefined} indices\n     * @memberof onnx.SparseTensorProto\n     * @instance\n     */\n    SparseTensorProto.prototype.indices = null;\n\n    /**\n     * SparseTensorProto dims.\n     * @member {Array.<number|Long>} dims\n     * @memberof onnx.SparseTensorProto\n     * @instance\n     */\n    SparseTensorProto.prototype.dims = $util.emptyArray;\n\n    /**\n     * Creates a new SparseTensorProto instance using the specified properties.\n     * @function create\n     * @memberof onnx.SparseTensorProto\n     * @static\n     * @param {onnx.ISparseTensorProto=} [properties] Properties to set\n     * @returns {onnx.SparseTensorProto} SparseTensorProto instance\n     */\n    SparseTensorProto.create = function create(properties) {\n      return new SparseTensorProto(properties);\n    };\n\n    /**\n     * Encodes the specified SparseTensorProto message. Does not implicitly {@link onnx.SparseTensorProto.verify|verify} messages.\n     * @function encode\n     * @memberof onnx.SparseTensorProto\n     * @static\n     * @param {onnx.ISparseTensorProto} message SparseTensorProto message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    SparseTensorProto.encode = function encode(message, writer) {\n      if (!writer) writer = $Writer.create();\n      if (message.values != null && Object.hasOwnProperty.call(message, 'values'))\n        $root.onnx.TensorProto.encode(message.values, writer.uint32(/* id 1, wireType 2 =*/ 10).fork()).ldelim();\n      if (message.indices != null && Object.hasOwnProperty.call(message, 'indices'))\n        $root.onnx.TensorProto.encode(message.indices, writer.uint32(/* id 2, wireType 2 =*/ 18).fork()).ldelim();\n      if (message.dims != null && message.dims.length) {\n        writer.uint32(/* id 3, wireType 2 =*/ 26).fork();\n        for (var i = 0; i < message.dims.length; ++i) writer.int64(message.dims[i]);\n        writer.ldelim();\n      }\n      return writer;\n    };\n\n    /**\n     * Encodes the specified SparseTensorProto message, length delimited. Does not implicitly {@link onnx.SparseTensorProto.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof onnx.SparseTensorProto\n     * @static\n     * @param {onnx.ISparseTensorProto} message SparseTensorProto message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    SparseTensorProto.encodeDelimited = function encodeDelimited(message, writer) {\n      return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a SparseTensorProto message from the specified reader or buffer.\n     * @function decode\n     * @memberof onnx.SparseTensorProto\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {onnx.SparseTensorProto} SparseTensorProto\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    SparseTensorProto.decode = function decode(reader, length) {\n      if (!(reader instanceof $Reader)) reader = $Reader.create(reader);\n      var end = length === undefined ? reader.len : reader.pos + length,\n        message = new $root.onnx.SparseTensorProto();\n      while (reader.pos < end) {\n        var tag = reader.uint32();\n        switch (tag >>> 3) {\n          case 1: {\n            message.values = $root.onnx.TensorProto.decode(reader, reader.uint32());\n            break;\n          }\n          case 2: {\n            message.indices = $root.onnx.TensorProto.decode(reader, reader.uint32());\n            break;\n          }\n          case 3: {\n            if (!(message.dims && message.dims.length)) message.dims = [];\n            if ((tag & 7) === 2) {\n              var end2 = reader.uint32() + reader.pos;\n              while (reader.pos < end2) message.dims.push(reader.int64());\n            } else message.dims.push(reader.int64());\n            break;\n          }\n          default:\n            reader.skipType(tag & 7);\n            break;\n        }\n      }\n      return message;\n    };\n\n    /**\n     * Decodes a SparseTensorProto message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof onnx.SparseTensorProto\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {onnx.SparseTensorProto} SparseTensorProto\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    SparseTensorProto.decodeDelimited = function decodeDelimited(reader) {\n      if (!(reader instanceof $Reader)) reader = new $Reader(reader);\n      return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a SparseTensorProto message.\n     * @function verify\n     * @memberof onnx.SparseTensorProto\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    SparseTensorProto.verify = function verify(message) {\n      if (typeof message !== 'object' || message === null) return 'object expected';\n      if (message.values != null && message.hasOwnProperty('values')) {\n        var error = $root.onnx.TensorProto.verify(message.values);\n        if (error) return 'values.' + error;\n      }\n      if (message.indices != null && message.hasOwnProperty('indices')) {\n        var error = $root.onnx.TensorProto.verify(message.indices);\n        if (error) return 'indices.' + error;\n      }\n      if (message.dims != null && message.hasOwnProperty('dims')) {\n        if (!Array.isArray(message.dims)) return 'dims: array expected';\n        for (var i = 0; i < message.dims.length; ++i)\n          if (\n            !$util.isInteger(message.dims[i]) &&\n            !(message.dims[i] && $util.isInteger(message.dims[i].low) && $util.isInteger(message.dims[i].high))\n          )\n            return 'dims: integer|Long[] expected';\n      }\n      return null;\n    };\n\n    /**\n     * Creates a SparseTensorProto message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof onnx.SparseTensorProto\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {onnx.SparseTensorProto} SparseTensorProto\n     */\n    SparseTensorProto.fromObject = function fromObject(object) {\n      if (object instanceof $root.onnx.SparseTensorProto) return object;\n      var message = new $root.onnx.SparseTensorProto();\n      if (object.values != null) {\n        if (typeof object.values !== 'object') throw TypeError('.onnx.SparseTensorProto.values: object expected');\n        message.values = $root.onnx.TensorProto.fromObject(object.values);\n      }\n      if (object.indices != null) {\n        if (typeof object.indices !== 'object') throw TypeError('.onnx.SparseTensorProto.indices: object expected');\n        message.indices = $root.onnx.TensorProto.fromObject(object.indices);\n      }\n      if (object.dims) {\n        if (!Array.isArray(object.dims)) throw TypeError('.onnx.SparseTensorProto.dims: array expected');\n        message.dims = [];\n        for (var i = 0; i < object.dims.length; ++i)\n          if ($util.Long) (message.dims[i] = $util.Long.fromValue(object.dims[i])).unsigned = false;\n          else if (typeof object.dims[i] === 'string') message.dims[i] = parseInt(object.dims[i], 10);\n          else if (typeof object.dims[i] === 'number') message.dims[i] = object.dims[i];\n          else if (typeof object.dims[i] === 'object')\n            message.dims[i] = new $util.LongBits(object.dims[i].low >>> 0, object.dims[i].high >>> 0).toNumber();\n      }\n      return message;\n    };\n\n    /**\n     * Creates a plain object from a SparseTensorProto message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof onnx.SparseTensorProto\n     * @static\n     * @param {onnx.SparseTensorProto} message SparseTensorProto\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    SparseTensorProto.toObject = function toObject(message, options) {\n      if (!options) options = {};\n      var object = {};\n      if (options.arrays || options.defaults) object.dims = [];\n      if (options.defaults) {\n        object.values = null;\n        object.indices = null;\n      }\n      if (message.values != null && message.hasOwnProperty('values'))\n        object.values = $root.onnx.TensorProto.toObject(message.values, options);\n      if (message.indices != null && message.hasOwnProperty('indices'))\n        object.indices = $root.onnx.TensorProto.toObject(message.indices, options);\n      if (message.dims && message.dims.length) {\n        object.dims = [];\n        for (var j = 0; j < message.dims.length; ++j)\n          if (typeof message.dims[j] === 'number')\n            object.dims[j] = options.longs === String ? String(message.dims[j]) : message.dims[j];\n          else\n            object.dims[j] =\n              options.longs === String\n                ? $util.Long.prototype.toString.call(message.dims[j])\n                : options.longs === Number\n                  ? new $util.LongBits(message.dims[j].low >>> 0, message.dims[j].high >>> 0).toNumber()\n                  : message.dims[j];\n      }\n      return object;\n    };\n\n    /**\n     * Converts this SparseTensorProto to JSON.\n     * @function toJSON\n     * @memberof onnx.SparseTensorProto\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    SparseTensorProto.prototype.toJSON = function toJSON() {\n      return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    /**\n     * Gets the default type url for SparseTensorProto\n     * @function getTypeUrl\n     * @memberof onnx.SparseTensorProto\n     * @static\n     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default \"type.googleapis.com\")\n     * @returns {string} The default type url\n     */\n    SparseTensorProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {\n      if (typeUrlPrefix === undefined) {\n        typeUrlPrefix = 'type.googleapis.com';\n      }\n      return typeUrlPrefix + '/onnx.SparseTensorProto';\n    };\n\n    return SparseTensorProto;\n  })();\n\n  onnx.TensorShapeProto = (function () {\n    /**\n     * Properties of a TensorShapeProto.\n     * @memberof onnx\n     * @interface ITensorShapeProto\n     * @property {Array.<onnx.TensorShapeProto.IDimension>|null} [dim] TensorShapeProto dim\n     */\n\n    /**\n     * Constructs a new TensorShapeProto.\n     * @memberof onnx\n     * @classdesc Represents a TensorShapeProto.\n     * @implements ITensorShapeProto\n     * @constructor\n     * @param {onnx.ITensorShapeProto=} [properties] Properties to set\n     */\n    function TensorShapeProto(properties) {\n      this.dim = [];\n      if (properties)\n        for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n          if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * TensorShapeProto dim.\n     * @member {Array.<onnx.TensorShapeProto.IDimension>} dim\n     * @memberof onnx.TensorShapeProto\n     * @instance\n     */\n    TensorShapeProto.prototype.dim = $util.emptyArray;\n\n    /**\n     * Creates a new TensorShapeProto instance using the specified properties.\n     * @function create\n     * @memberof onnx.TensorShapeProto\n     * @static\n     * @param {onnx.ITensorShapeProto=} [properties] Properties to set\n     * @returns {onnx.TensorShapeProto} TensorShapeProto instance\n     */\n    TensorShapeProto.create = function create(properties) {\n      return new TensorShapeProto(properties);\n    };\n\n    /**\n     * Encodes the specified TensorShapeProto message. Does not implicitly {@link onnx.TensorShapeProto.verify|verify} messages.\n     * @function encode\n     * @memberof onnx.TensorShapeProto\n     * @static\n     * @param {onnx.ITensorShapeProto} message TensorShapeProto message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    TensorShapeProto.encode = function encode(message, writer) {\n      if (!writer) writer = $Writer.create();\n      if (message.dim != null && message.dim.length)\n        for (var i = 0; i < message.dim.length; ++i)\n          $root.onnx.TensorShapeProto.Dimension.encode(\n            message.dim[i],\n            writer.uint32(/* id 1, wireType 2 =*/ 10).fork(),\n          ).ldelim();\n      return writer;\n    };\n\n    /**\n     * Encodes the specified TensorShapeProto message, length delimited. Does not implicitly {@link onnx.TensorShapeProto.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof onnx.TensorShapeProto\n     * @static\n     * @param {onnx.ITensorShapeProto} message TensorShapeProto message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    TensorShapeProto.encodeDelimited = function encodeDelimited(message, writer) {\n      return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a TensorShapeProto message from the specified reader or buffer.\n     * @function decode\n     * @memberof onnx.TensorShapeProto\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {onnx.TensorShapeProto} TensorShapeProto\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    TensorShapeProto.decode = function decode(reader, length) {\n      if (!(reader instanceof $Reader)) reader = $Reader.create(reader);\n      var end = length === undefined ? reader.len : reader.pos + length,\n        message = new $root.onnx.TensorShapeProto();\n      while (reader.pos < end) {\n        var tag = reader.uint32();\n        switch (tag >>> 3) {\n          case 1: {\n            if (!(message.dim && message.dim.length)) message.dim = [];\n            message.dim.push($root.onnx.TensorShapeProto.Dimension.decode(reader, reader.uint32()));\n            break;\n          }\n          default:\n            reader.skipType(tag & 7);\n            break;\n        }\n      }\n      return message;\n    };\n\n    /**\n     * Decodes a TensorShapeProto message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof onnx.TensorShapeProto\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {onnx.TensorShapeProto} TensorShapeProto\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    TensorShapeProto.decodeDelimited = function decodeDelimited(reader) {\n      if (!(reader instanceof $Reader)) reader = new $Reader(reader);\n      return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a TensorShapeProto message.\n     * @function verify\n     * @memberof onnx.TensorShapeProto\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    TensorShapeProto.verify = function verify(message) {\n      if (typeof message !== 'object' || message === null) return 'object expected';\n      if (message.dim != null && message.hasOwnProperty('dim')) {\n        if (!Array.isArray(message.dim)) return 'dim: array expected';\n        for (var i = 0; i < message.dim.length; ++i) {\n          var error = $root.onnx.TensorShapeProto.Dimension.verify(message.dim[i]);\n          if (error) return 'dim.' + error;\n        }\n      }\n      return null;\n    };\n\n    /**\n     * Creates a TensorShapeProto message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof onnx.TensorShapeProto\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {onnx.TensorShapeProto} TensorShapeProto\n     */\n    TensorShapeProto.fromObject = function fromObject(object) {\n      if (object instanceof $root.onnx.TensorShapeProto) return object;\n      var message = new $root.onnx.TensorShapeProto();\n      if (object.dim) {\n        if (!Array.isArray(object.dim)) throw TypeError('.onnx.TensorShapeProto.dim: array expected');\n        message.dim = [];\n        for (var i = 0; i < object.dim.length; ++i) {\n          if (typeof object.dim[i] !== 'object') throw TypeError('.onnx.TensorShapeProto.dim: object expected');\n          message.dim[i] = $root.onnx.TensorShapeProto.Dimension.fromObject(object.dim[i]);\n        }\n      }\n      return message;\n    };\n\n    /**\n     * Creates a plain object from a TensorShapeProto message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof onnx.TensorShapeProto\n     * @static\n     * @param {onnx.TensorShapeProto} message TensorShapeProto\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    TensorShapeProto.toObject = function toObject(message, options) {\n      if (!options) options = {};\n      var object = {};\n      if (options.arrays || options.defaults) object.dim = [];\n      if (message.dim && message.dim.length) {\n        object.dim = [];\n        for (var j = 0; j < message.dim.length; ++j)\n          object.dim[j] = $root.onnx.TensorShapeProto.Dimension.toObject(message.dim[j], options);\n      }\n      return object;\n    };\n\n    /**\n     * Converts this TensorShapeProto to JSON.\n     * @function toJSON\n     * @memberof onnx.TensorShapeProto\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    TensorShapeProto.prototype.toJSON = function toJSON() {\n      return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    /**\n     * Gets the default type url for TensorShapeProto\n     * @function getTypeUrl\n     * @memberof onnx.TensorShapeProto\n     * @static\n     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default \"type.googleapis.com\")\n     * @returns {string} The default type url\n     */\n    TensorShapeProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {\n      if (typeUrlPrefix === undefined) {\n        typeUrlPrefix = 'type.googleapis.com';\n      }\n      return typeUrlPrefix + '/onnx.TensorShapeProto';\n    };\n\n    TensorShapeProto.Dimension = (function () {\n      /**\n       * Properties of a Dimension.\n       * @memberof onnx.TensorShapeProto\n       * @interface IDimension\n       * @property {number|Long|null} [dimValue] Dimension dimValue\n       * @property {string|null} [dimParam] Dimension dimParam\n       * @property {string|null} [denotation] Dimension denotation\n       */\n\n      /**\n       * Constructs a new Dimension.\n       * @memberof onnx.TensorShapeProto\n       * @classdesc Represents a Dimension.\n       * @implements IDimension\n       * @constructor\n       * @param {onnx.TensorShapeProto.IDimension=} [properties] Properties to set\n       */\n      function Dimension(properties) {\n        if (properties)\n          for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n            if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];\n      }\n\n      /**\n       * Dimension dimValue.\n       * @member {number|Long|null|undefined} dimValue\n       * @memberof onnx.TensorShapeProto.Dimension\n       * @instance\n       */\n      Dimension.prototype.dimValue = null;\n\n      /**\n       * Dimension dimParam.\n       * @member {string|null|undefined} dimParam\n       * @memberof onnx.TensorShapeProto.Dimension\n       * @instance\n       */\n      Dimension.prototype.dimParam = null;\n\n      /**\n       * Dimension denotation.\n       * @member {string} denotation\n       * @memberof onnx.TensorShapeProto.Dimension\n       * @instance\n       */\n      Dimension.prototype.denotation = '';\n\n      // OneOf field names bound to virtual getters and setters\n      var $oneOfFields;\n\n      /**\n       * Dimension value.\n       * @member {\"dimValue\"|\"dimParam\"|undefined} value\n       * @memberof onnx.TensorShapeProto.Dimension\n       * @instance\n       */\n      Object.defineProperty(Dimension.prototype, 'value', {\n        get: $util.oneOfGetter(($oneOfFields = ['dimValue', 'dimParam'])),\n        set: $util.oneOfSetter($oneOfFields),\n      });\n\n      /**\n       * Creates a new Dimension instance using the specified properties.\n       * @function create\n       * @memberof onnx.TensorShapeProto.Dimension\n       * @static\n       * @param {onnx.TensorShapeProto.IDimension=} [properties] Properties to set\n       * @returns {onnx.TensorShapeProto.Dimension} Dimension instance\n       */\n      Dimension.create = function create(properties) {\n        return new Dimension(properties);\n      };\n\n      /**\n       * Encodes the specified Dimension message. Does not implicitly {@link onnx.TensorShapeProto.Dimension.verify|verify} messages.\n       * @function encode\n       * @memberof onnx.TensorShapeProto.Dimension\n       * @static\n       * @param {onnx.TensorShapeProto.IDimension} message Dimension message or plain object to encode\n       * @param {$protobuf.Writer} [writer] Writer to encode to\n       * @returns {$protobuf.Writer} Writer\n       */\n      Dimension.encode = function encode(message, writer) {\n        if (!writer) writer = $Writer.create();\n        if (message.dimValue != null && Object.hasOwnProperty.call(message, 'dimValue'))\n          writer.uint32(/* id 1, wireType 0 =*/ 8).int64(message.dimValue);\n        if (message.dimParam != null && Object.hasOwnProperty.call(message, 'dimParam'))\n          writer.uint32(/* id 2, wireType 2 =*/ 18).string(message.dimParam);\n        if (message.denotation != null && Object.hasOwnProperty.call(message, 'denotation'))\n          writer.uint32(/* id 3, wireType 2 =*/ 26).string(message.denotation);\n        return writer;\n      };\n\n      /**\n       * Encodes the specified Dimension message, length delimited. Does not implicitly {@link onnx.TensorShapeProto.Dimension.verify|verify} messages.\n       * @function encodeDelimited\n       * @memberof onnx.TensorShapeProto.Dimension\n       * @static\n       * @param {onnx.TensorShapeProto.IDimension} message Dimension message or plain object to encode\n       * @param {$protobuf.Writer} [writer] Writer to encode to\n       * @returns {$protobuf.Writer} Writer\n       */\n      Dimension.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n      };\n\n      /**\n       * Decodes a Dimension message from the specified reader or buffer.\n       * @function decode\n       * @memberof onnx.TensorShapeProto.Dimension\n       * @static\n       * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n       * @param {number} [length] Message length if known beforehand\n       * @returns {onnx.TensorShapeProto.Dimension} Dimension\n       * @throws {Error} If the payload is not a reader or valid buffer\n       * @throws {$protobuf.util.ProtocolError} If required fields are missing\n       */\n      Dimension.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader)) reader = $Reader.create(reader);\n        var end = length === undefined ? reader.len : reader.pos + length,\n          message = new $root.onnx.TensorShapeProto.Dimension();\n        while (reader.pos < end) {\n          var tag = reader.uint32();\n          switch (tag >>> 3) {\n            case 1: {\n              message.dimValue = reader.int64();\n              break;\n            }\n            case 2: {\n              message.dimParam = reader.string();\n              break;\n            }\n            case 3: {\n              message.denotation = reader.string();\n              break;\n            }\n            default:\n              reader.skipType(tag & 7);\n              break;\n          }\n        }\n        return message;\n      };\n\n      /**\n       * Decodes a Dimension message from the specified reader or buffer, length delimited.\n       * @function decodeDelimited\n       * @memberof onnx.TensorShapeProto.Dimension\n       * @static\n       * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n       * @returns {onnx.TensorShapeProto.Dimension} Dimension\n       * @throws {Error} If the payload is not a reader or valid buffer\n       * @throws {$protobuf.util.ProtocolError} If required fields are missing\n       */\n      Dimension.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader)) reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n      };\n\n      /**\n       * Verifies a Dimension message.\n       * @function verify\n       * @memberof onnx.TensorShapeProto.Dimension\n       * @static\n       * @param {Object.<string,*>} message Plain object to verify\n       * @returns {string|null} `null` if valid, otherwise the reason why it is not\n       */\n      Dimension.verify = function verify(message) {\n        if (typeof message !== 'object' || message === null) return 'object expected';\n        var properties = {};\n        if (message.dimValue != null && message.hasOwnProperty('dimValue')) {\n          properties.value = 1;\n          if (\n            !$util.isInteger(message.dimValue) &&\n            !(message.dimValue && $util.isInteger(message.dimValue.low) && $util.isInteger(message.dimValue.high))\n          )\n            return 'dimValue: integer|Long expected';\n        }\n        if (message.dimParam != null && message.hasOwnProperty('dimParam')) {\n          if (properties.value === 1) return 'value: multiple values';\n          properties.value = 1;\n          if (!$util.isString(message.dimParam)) return 'dimParam: string expected';\n        }\n        if (message.denotation != null && message.hasOwnProperty('denotation'))\n          if (!$util.isString(message.denotation)) return 'denotation: string expected';\n        return null;\n      };\n\n      /**\n       * Creates a Dimension message from a plain object. Also converts values to their respective internal types.\n       * @function fromObject\n       * @memberof onnx.TensorShapeProto.Dimension\n       * @static\n       * @param {Object.<string,*>} object Plain object\n       * @returns {onnx.TensorShapeProto.Dimension} Dimension\n       */\n      Dimension.fromObject = function fromObject(object) {\n        if (object instanceof $root.onnx.TensorShapeProto.Dimension) return object;\n        var message = new $root.onnx.TensorShapeProto.Dimension();\n        if (object.dimValue != null)\n          if ($util.Long) (message.dimValue = $util.Long.fromValue(object.dimValue)).unsigned = false;\n          else if (typeof object.dimValue === 'string') message.dimValue = parseInt(object.dimValue, 10);\n          else if (typeof object.dimValue === 'number') message.dimValue = object.dimValue;\n          else if (typeof object.dimValue === 'object')\n            message.dimValue = new $util.LongBits(object.dimValue.low >>> 0, object.dimValue.high >>> 0).toNumber();\n        if (object.dimParam != null) message.dimParam = String(object.dimParam);\n        if (object.denotation != null) message.denotation = String(object.denotation);\n        return message;\n      };\n\n      /**\n       * Creates a plain object from a Dimension message. Also converts values to other types if specified.\n       * @function toObject\n       * @memberof onnx.TensorShapeProto.Dimension\n       * @static\n       * @param {onnx.TensorShapeProto.Dimension} message Dimension\n       * @param {$protobuf.IConversionOptions} [options] Conversion options\n       * @returns {Object.<string,*>} Plain object\n       */\n      Dimension.toObject = function toObject(message, options) {\n        if (!options) options = {};\n        var object = {};\n        if (options.defaults) object.denotation = '';\n        if (message.dimValue != null && message.hasOwnProperty('dimValue')) {\n          if (typeof message.dimValue === 'number')\n            object.dimValue = options.longs === String ? String(message.dimValue) : message.dimValue;\n          else\n            object.dimValue =\n              options.longs === String\n                ? $util.Long.prototype.toString.call(message.dimValue)\n                : options.longs === Number\n                  ? new $util.LongBits(message.dimValue.low >>> 0, message.dimValue.high >>> 0).toNumber()\n                  : message.dimValue;\n          if (options.oneofs) object.value = 'dimValue';\n        }\n        if (message.dimParam != null && message.hasOwnProperty('dimParam')) {\n          object.dimParam = message.dimParam;\n          if (options.oneofs) object.value = 'dimParam';\n        }\n        if (message.denotation != null && message.hasOwnProperty('denotation')) object.denotation = message.denotation;\n        return object;\n      };\n\n      /**\n       * Converts this Dimension to JSON.\n       * @function toJSON\n       * @memberof onnx.TensorShapeProto.Dimension\n       * @instance\n       * @returns {Object.<string,*>} JSON object\n       */\n      Dimension.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n      };\n\n      /**\n       * Gets the default type url for Dimension\n       * @function getTypeUrl\n       * @memberof onnx.TensorShapeProto.Dimension\n       * @static\n       * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default \"type.googleapis.com\")\n       * @returns {string} The default type url\n       */\n      Dimension.getTypeUrl = function getTypeUrl(typeUrlPrefix) {\n        if (typeUrlPrefix === undefined) {\n          typeUrlPrefix = 'type.googleapis.com';\n        }\n        return typeUrlPrefix + '/onnx.TensorShapeProto.Dimension';\n      };\n\n      return Dimension;\n    })();\n\n    return TensorShapeProto;\n  })();\n\n  onnx.TypeProto = (function () {\n    /**\n     * Properties of a TypeProto.\n     * @memberof onnx\n     * @interface ITypeProto\n     * @property {onnx.TypeProto.ITensor|null} [tensorType] TypeProto tensorType\n     * @property {onnx.TypeProto.ISequence|null} [sequenceType] TypeProto sequenceType\n     * @property {onnx.TypeProto.IMap|null} [mapType] TypeProto mapType\n     * @property {onnx.TypeProto.IOptional|null} [optionalType] TypeProto optionalType\n     * @property {onnx.TypeProto.ISparseTensor|null} [sparseTensorType] TypeProto sparseTensorType\n     * @property {string|null} [denotation] TypeProto denotation\n     */\n\n    /**\n     * Constructs a new TypeProto.\n     * @memberof onnx\n     * @classdesc Represents a TypeProto.\n     * @implements ITypeProto\n     * @constructor\n     * @param {onnx.ITypeProto=} [properties] Properties to set\n     */\n    function TypeProto(properties) {\n      if (properties)\n        for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n          if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * TypeProto tensorType.\n     * @member {onnx.TypeProto.ITensor|null|undefined} tensorType\n     * @memberof onnx.TypeProto\n     * @instance\n     */\n    TypeProto.prototype.tensorType = null;\n\n    /**\n     * TypeProto sequenceType.\n     * @member {onnx.TypeProto.ISequence|null|undefined} sequenceType\n     * @memberof onnx.TypeProto\n     * @instance\n     */\n    TypeProto.prototype.sequenceType = null;\n\n    /**\n     * TypeProto mapType.\n     * @member {onnx.TypeProto.IMap|null|undefined} mapType\n     * @memberof onnx.TypeProto\n     * @instance\n     */\n    TypeProto.prototype.mapType = null;\n\n    /**\n     * TypeProto optionalType.\n     * @member {onnx.TypeProto.IOptional|null|undefined} optionalType\n     * @memberof onnx.TypeProto\n     * @instance\n     */\n    TypeProto.prototype.optionalType = null;\n\n    /**\n     * TypeProto sparseTensorType.\n     * @member {onnx.TypeProto.ISparseTensor|null|undefined} sparseTensorType\n     * @memberof onnx.TypeProto\n     * @instance\n     */\n    TypeProto.prototype.sparseTensorType = null;\n\n    /**\n     * TypeProto denotation.\n     * @member {string} denotation\n     * @memberof onnx.TypeProto\n     * @instance\n     */\n    TypeProto.prototype.denotation = '';\n\n    // OneOf field names bound to virtual getters and setters\n    var $oneOfFields;\n\n    /**\n     * TypeProto value.\n     * @member {\"tensorType\"|\"sequenceType\"|\"mapType\"|\"optionalType\"|\"sparseTensorType\"|undefined} value\n     * @memberof onnx.TypeProto\n     * @instance\n     */\n    Object.defineProperty(TypeProto.prototype, 'value', {\n      get: $util.oneOfGetter(\n        ($oneOfFields = ['tensorType', 'sequenceType', 'mapType', 'optionalType', 'sparseTensorType']),\n      ),\n      set: $util.oneOfSetter($oneOfFields),\n    });\n\n    /**\n     * Creates a new TypeProto instance using the specified properties.\n     * @function create\n     * @memberof onnx.TypeProto\n     * @static\n     * @param {onnx.ITypeProto=} [properties] Properties to set\n     * @returns {onnx.TypeProto} TypeProto instance\n     */\n    TypeProto.create = function create(properties) {\n      return new TypeProto(properties);\n    };\n\n    /**\n     * Encodes the specified TypeProto message. Does not implicitly {@link onnx.TypeProto.verify|verify} messages.\n     * @function encode\n     * @memberof onnx.TypeProto\n     * @static\n     * @param {onnx.ITypeProto} message TypeProto message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    TypeProto.encode = function encode(message, writer) {\n      if (!writer) writer = $Writer.create();\n      if (message.tensorType != null && Object.hasOwnProperty.call(message, 'tensorType'))\n        $root.onnx.TypeProto.Tensor.encode(\n          message.tensorType,\n          writer.uint32(/* id 1, wireType 2 =*/ 10).fork(),\n        ).ldelim();\n      if (message.sequenceType != null && Object.hasOwnProperty.call(message, 'sequenceType'))\n        $root.onnx.TypeProto.Sequence.encode(\n          message.sequenceType,\n          writer.uint32(/* id 4, wireType 2 =*/ 34).fork(),\n        ).ldelim();\n      if (message.mapType != null && Object.hasOwnProperty.call(message, 'mapType'))\n        $root.onnx.TypeProto.Map.encode(message.mapType, writer.uint32(/* id 5, wireType 2 =*/ 42).fork()).ldelim();\n      if (message.denotation != null && Object.hasOwnProperty.call(message, 'denotation'))\n        writer.uint32(/* id 6, wireType 2 =*/ 50).string(message.denotation);\n      if (message.sparseTensorType != null && Object.hasOwnProperty.call(message, 'sparseTensorType'))\n        $root.onnx.TypeProto.SparseTensor.encode(\n          message.sparseTensorType,\n          writer.uint32(/* id 8, wireType 2 =*/ 66).fork(),\n        ).ldelim();\n      if (message.optionalType != null && Object.hasOwnProperty.call(message, 'optionalType'))\n        $root.onnx.TypeProto.Optional.encode(\n          message.optionalType,\n          writer.uint32(/* id 9, wireType 2 =*/ 74).fork(),\n        ).ldelim();\n      return writer;\n    };\n\n    /**\n     * Encodes the specified TypeProto message, length delimited. Does not implicitly {@link onnx.TypeProto.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof onnx.TypeProto\n     * @static\n     * @param {onnx.ITypeProto} message TypeProto message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    TypeProto.encodeDelimited = function encodeDelimited(message, writer) {\n      return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a TypeProto message from the specified reader or buffer.\n     * @function decode\n     * @memberof onnx.TypeProto\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {onnx.TypeProto} TypeProto\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    TypeProto.decode = function decode(reader, length) {\n      if (!(reader instanceof $Reader)) reader = $Reader.create(reader);\n      var end = length === undefined ? reader.len : reader.pos + length,\n        message = new $root.onnx.TypeProto();\n      while (reader.pos < end) {\n        var tag = reader.uint32();\n        switch (tag >>> 3) {\n          case 1: {\n            message.tensorType = $root.onnx.TypeProto.Tensor.decode(reader, reader.uint32());\n            break;\n          }\n          case 4: {\n            message.sequenceType = $root.onnx.TypeProto.Sequence.decode(reader, reader.uint32());\n            break;\n          }\n          case 5: {\n            message.mapType = $root.onnx.TypeProto.Map.decode(reader, reader.uint32());\n            break;\n          }\n          case 9: {\n            message.optionalType = $root.onnx.TypeProto.Optional.decode(reader, reader.uint32());\n            break;\n          }\n          case 8: {\n            message.sparseTensorType = $root.onnx.TypeProto.SparseTensor.decode(reader, reader.uint32());\n            break;\n          }\n          case 6: {\n            message.denotation = reader.string();\n            break;\n          }\n          default:\n            reader.skipType(tag & 7);\n            break;\n        }\n      }\n      return message;\n    };\n\n    /**\n     * Decodes a TypeProto message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof onnx.TypeProto\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {onnx.TypeProto} TypeProto\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    TypeProto.decodeDelimited = function decodeDelimited(reader) {\n      if (!(reader instanceof $Reader)) reader = new $Reader(reader);\n      return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a TypeProto message.\n     * @function verify\n     * @memberof onnx.TypeProto\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    TypeProto.verify = function verify(message) {\n      if (typeof message !== 'object' || message === null) return 'object expected';\n      var properties = {};\n      if (message.tensorType != null && message.hasOwnProperty('tensorType')) {\n        properties.value = 1;\n        {\n          var error = $root.onnx.TypeProto.Tensor.verify(message.tensorType);\n          if (error) return 'tensorType.' + error;\n        }\n      }\n      if (message.sequenceType != null && message.hasOwnProperty('sequenceType')) {\n        if (properties.value === 1) return 'value: multiple values';\n        properties.value = 1;\n        {\n          var error = $root.onnx.TypeProto.Sequence.verify(message.sequenceType);\n          if (error) return 'sequenceType.' + error;\n        }\n      }\n      if (message.mapType != null && message.hasOwnProperty('mapType')) {\n        if (properties.value === 1) return 'value: multiple values';\n        properties.value = 1;\n        {\n          var error = $root.onnx.TypeProto.Map.verify(message.mapType);\n          if (error) return 'mapType.' + error;\n        }\n      }\n      if (message.optionalType != null && message.hasOwnProperty('optionalType')) {\n        if (properties.value === 1) return 'value: multiple values';\n        properties.value = 1;\n        {\n          var error = $root.onnx.TypeProto.Optional.verify(message.optionalType);\n          if (error) return 'optionalType.' + error;\n        }\n      }\n      if (message.sparseTensorType != null && message.hasOwnProperty('sparseTensorType')) {\n        if (properties.value === 1) return 'value: multiple values';\n        properties.value = 1;\n        {\n          var error = $root.onnx.TypeProto.SparseTensor.verify(message.sparseTensorType);\n          if (error) return 'sparseTensorType.' + error;\n        }\n      }\n      if (message.denotation != null && message.hasOwnProperty('denotation'))\n        if (!$util.isString(message.denotation)) return 'denotation: string expected';\n      return null;\n    };\n\n    /**\n     * Creates a TypeProto message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof onnx.TypeProto\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {onnx.TypeProto} TypeProto\n     */\n    TypeProto.fromObject = function fromObject(object) {\n      if (object instanceof $root.onnx.TypeProto) return object;\n      var message = new $root.onnx.TypeProto();\n      if (object.tensorType != null) {\n        if (typeof object.tensorType !== 'object') throw TypeError('.onnx.TypeProto.tensorType: object expected');\n        message.tensorType = $root.onnx.TypeProto.Tensor.fromObject(object.tensorType);\n      }\n      if (object.sequenceType != null) {\n        if (typeof object.sequenceType !== 'object') throw TypeError('.onnx.TypeProto.sequenceType: object expected');\n        message.sequenceType = $root.onnx.TypeProto.Sequence.fromObject(object.sequenceType);\n      }\n      if (object.mapType != null) {\n        if (typeof object.mapType !== 'object') throw TypeError('.onnx.TypeProto.mapType: object expected');\n        message.mapType = $root.onnx.TypeProto.Map.fromObject(object.mapType);\n      }\n      if (object.optionalType != null) {\n        if (typeof object.optionalType !== 'object') throw TypeError('.onnx.TypeProto.optionalType: object expected');\n        message.optionalType = $root.onnx.TypeProto.Optional.fromObject(object.optionalType);\n      }\n      if (object.sparseTensorType != null) {\n        if (typeof object.sparseTensorType !== 'object')\n          throw TypeError('.onnx.TypeProto.sparseTensorType: object expected');\n        message.sparseTensorType = $root.onnx.TypeProto.SparseTensor.fromObject(object.sparseTensorType);\n      }\n      if (object.denotation != null) message.denotation = String(object.denotation);\n      return message;\n    };\n\n    /**\n     * Creates a plain object from a TypeProto message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof onnx.TypeProto\n     * @static\n     * @param {onnx.TypeProto} message TypeProto\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    TypeProto.toObject = function toObject(message, options) {\n      if (!options) options = {};\n      var object = {};\n      if (options.defaults) object.denotation = '';\n      if (message.tensorType != null && message.hasOwnProperty('tensorType')) {\n        object.tensorType = $root.onnx.TypeProto.Tensor.toObject(message.tensorType, options);\n        if (options.oneofs) object.value = 'tensorType';\n      }\n      if (message.sequenceType != null && message.hasOwnProperty('sequenceType')) {\n        object.sequenceType = $root.onnx.TypeProto.Sequence.toObject(message.sequenceType, options);\n        if (options.oneofs) object.value = 'sequenceType';\n      }\n      if (message.mapType != null && message.hasOwnProperty('mapType')) {\n        object.mapType = $root.onnx.TypeProto.Map.toObject(message.mapType, options);\n        if (options.oneofs) object.value = 'mapType';\n      }\n      if (message.denotation != null && message.hasOwnProperty('denotation')) object.denotation = message.denotation;\n      if (message.sparseTensorType != null && message.hasOwnProperty('sparseTensorType')) {\n        object.sparseTensorType = $root.onnx.TypeProto.SparseTensor.toObject(message.sparseTensorType, options);\n        if (options.oneofs) object.value = 'sparseTensorType';\n      }\n      if (message.optionalType != null && message.hasOwnProperty('optionalType')) {\n        object.optionalType = $root.onnx.TypeProto.Optional.toObject(message.optionalType, options);\n        if (options.oneofs) object.value = 'optionalType';\n      }\n      return object;\n    };\n\n    /**\n     * Converts this TypeProto to JSON.\n     * @function toJSON\n     * @memberof onnx.TypeProto\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    TypeProto.prototype.toJSON = function toJSON() {\n      return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    /**\n     * Gets the default type url for TypeProto\n     * @function getTypeUrl\n     * @memberof onnx.TypeProto\n     * @static\n     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default \"type.googleapis.com\")\n     * @returns {string} The default type url\n     */\n    TypeProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {\n      if (typeUrlPrefix === undefined) {\n        typeUrlPrefix = 'type.googleapis.com';\n      }\n      return typeUrlPrefix + '/onnx.TypeProto';\n    };\n\n    TypeProto.Tensor = (function () {\n      /**\n       * Properties of a Tensor.\n       * @memberof onnx.TypeProto\n       * @interface ITensor\n       * @property {number|null} [elemType] Tensor elemType\n       * @property {onnx.ITensorShapeProto|null} [shape] Tensor shape\n       */\n\n      /**\n       * Constructs a new Tensor.\n       * @memberof onnx.TypeProto\n       * @classdesc Represents a Tensor.\n       * @implements ITensor\n       * @constructor\n       * @param {onnx.TypeProto.ITensor=} [properties] Properties to set\n       */\n      function Tensor(properties) {\n        if (properties)\n          for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n            if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];\n      }\n\n      /**\n       * Tensor elemType.\n       * @member {number} elemType\n       * @memberof onnx.TypeProto.Tensor\n       * @instance\n       */\n      Tensor.prototype.elemType = 0;\n\n      /**\n       * Tensor shape.\n       * @member {onnx.ITensorShapeProto|null|undefined} shape\n       * @memberof onnx.TypeProto.Tensor\n       * @instance\n       */\n      Tensor.prototype.shape = null;\n\n      /**\n       * Creates a new Tensor instance using the specified properties.\n       * @function create\n       * @memberof onnx.TypeProto.Tensor\n       * @static\n       * @param {onnx.TypeProto.ITensor=} [properties] Properties to set\n       * @returns {onnx.TypeProto.Tensor} Tensor instance\n       */\n      Tensor.create = function create(properties) {\n        return new Tensor(properties);\n      };\n\n      /**\n       * Encodes the specified Tensor message. Does not implicitly {@link onnx.TypeProto.Tensor.verify|verify} messages.\n       * @function encode\n       * @memberof onnx.TypeProto.Tensor\n       * @static\n       * @param {onnx.TypeProto.ITensor} message Tensor message or plain object to encode\n       * @param {$protobuf.Writer} [writer] Writer to encode to\n       * @returns {$protobuf.Writer} Writer\n       */\n      Tensor.encode = function encode(message, writer) {\n        if (!writer) writer = $Writer.create();\n        if (message.elemType != null && Object.hasOwnProperty.call(message, 'elemType'))\n          writer.uint32(/* id 1, wireType 0 =*/ 8).int32(message.elemType);\n        if (message.shape != null && Object.hasOwnProperty.call(message, 'shape'))\n          $root.onnx.TensorShapeProto.encode(message.shape, writer.uint32(/* id 2, wireType 2 =*/ 18).fork()).ldelim();\n        return writer;\n      };\n\n      /**\n       * Encodes the specified Tensor message, length delimited. Does not implicitly {@link onnx.TypeProto.Tensor.verify|verify} messages.\n       * @function encodeDelimited\n       * @memberof onnx.TypeProto.Tensor\n       * @static\n       * @param {onnx.TypeProto.ITensor} message Tensor message or plain object to encode\n       * @param {$protobuf.Writer} [writer] Writer to encode to\n       * @returns {$protobuf.Writer} Writer\n       */\n      Tensor.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n      };\n\n      /**\n       * Decodes a Tensor message from the specified reader or buffer.\n       * @function decode\n       * @memberof onnx.TypeProto.Tensor\n       * @static\n       * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n       * @param {number} [length] Message length if known beforehand\n       * @returns {onnx.TypeProto.Tensor} Tensor\n       * @throws {Error} If the payload is not a reader or valid buffer\n       * @throws {$protobuf.util.ProtocolError} If required fields are missing\n       */\n      Tensor.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader)) reader = $Reader.create(reader);\n        var end = length === undefined ? reader.len : reader.pos + length,\n          message = new $root.onnx.TypeProto.Tensor();\n        while (reader.pos < end) {\n          var tag = reader.uint32();\n          switch (tag >>> 3) {\n            case 1: {\n              message.elemType = reader.int32();\n              break;\n            }\n            case 2: {\n              message.shape = $root.onnx.TensorShapeProto.decode(reader, reader.uint32());\n              break;\n            }\n            default:\n              reader.skipType(tag & 7);\n              break;\n          }\n        }\n        return message;\n      };\n\n      /**\n       * Decodes a Tensor message from the specified reader or buffer, length delimited.\n       * @function decodeDelimited\n       * @memberof onnx.TypeProto.Tensor\n       * @static\n       * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n       * @returns {onnx.TypeProto.Tensor} Tensor\n       * @throws {Error} If the payload is not a reader or valid buffer\n       * @throws {$protobuf.util.ProtocolError} If required fields are missing\n       */\n      Tensor.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader)) reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n      };\n\n      /**\n       * Verifies a Tensor message.\n       * @function verify\n       * @memberof onnx.TypeProto.Tensor\n       * @static\n       * @param {Object.<string,*>} message Plain object to verify\n       * @returns {string|null} `null` if valid, otherwise the reason why it is not\n       */\n      Tensor.verify = function verify(message) {\n        if (typeof message !== 'object' || message === null) return 'object expected';\n        if (message.elemType != null && message.hasOwnProperty('elemType'))\n          if (!$util.isInteger(message.elemType)) return 'elemType: integer expected';\n        if (message.shape != null && message.hasOwnProperty('shape')) {\n          var error = $root.onnx.TensorShapeProto.verify(message.shape);\n          if (error) return 'shape.' + error;\n        }\n        return null;\n      };\n\n      /**\n       * Creates a Tensor message from a plain object. Also converts values to their respective internal types.\n       * @function fromObject\n       * @memberof onnx.TypeProto.Tensor\n       * @static\n       * @param {Object.<string,*>} object Plain object\n       * @returns {onnx.TypeProto.Tensor} Tensor\n       */\n      Tensor.fromObject = function fromObject(object) {\n        if (object instanceof $root.onnx.TypeProto.Tensor) return object;\n        var message = new $root.onnx.TypeProto.Tensor();\n        if (object.elemType != null) message.elemType = object.elemType | 0;\n        if (object.shape != null) {\n          if (typeof object.shape !== 'object') throw TypeError('.onnx.TypeProto.Tensor.shape: object expected');\n          message.shape = $root.onnx.TensorShapeProto.fromObject(object.shape);\n        }\n        return message;\n      };\n\n      /**\n       * Creates a plain object from a Tensor message. Also converts values to other types if specified.\n       * @function toObject\n       * @memberof onnx.TypeProto.Tensor\n       * @static\n       * @param {onnx.TypeProto.Tensor} message Tensor\n       * @param {$protobuf.IConversionOptions} [options] Conversion options\n       * @returns {Object.<string,*>} Plain object\n       */\n      Tensor.toObject = function toObject(message, options) {\n        if (!options) options = {};\n        var object = {};\n        if (options.defaults) {\n          object.elemType = 0;\n          object.shape = null;\n        }\n        if (message.elemType != null && message.hasOwnProperty('elemType')) object.elemType = message.elemType;\n        if (message.shape != null && message.hasOwnProperty('shape'))\n          object.shape = $root.onnx.TensorShapeProto.toObject(message.shape, options);\n        return object;\n      };\n\n      /**\n       * Converts this Tensor to JSON.\n       * @function toJSON\n       * @memberof onnx.TypeProto.Tensor\n       * @instance\n       * @returns {Object.<string,*>} JSON object\n       */\n      Tensor.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n      };\n\n      /**\n       * Gets the default type url for Tensor\n       * @function getTypeUrl\n       * @memberof onnx.TypeProto.Tensor\n       * @static\n       * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default \"type.googleapis.com\")\n       * @returns {string} The default type url\n       */\n      Tensor.getTypeUrl = function getTypeUrl(typeUrlPrefix) {\n        if (typeUrlPrefix === undefined) {\n          typeUrlPrefix = 'type.googleapis.com';\n        }\n        return typeUrlPrefix + '/onnx.TypeProto.Tensor';\n      };\n\n      return Tensor;\n    })();\n\n    TypeProto.Sequence = (function () {\n      /**\n       * Properties of a Sequence.\n       * @memberof onnx.TypeProto\n       * @interface ISequence\n       * @property {onnx.ITypeProto|null} [elemType] Sequence elemType\n       */\n\n      /**\n       * Constructs a new Sequence.\n       * @memberof onnx.TypeProto\n       * @classdesc Represents a Sequence.\n       * @implements ISequence\n       * @constructor\n       * @param {onnx.TypeProto.ISequence=} [properties] Properties to set\n       */\n      function Sequence(properties) {\n        if (properties)\n          for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n            if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];\n      }\n\n      /**\n       * Sequence elemType.\n       * @member {onnx.ITypeProto|null|undefined} elemType\n       * @memberof onnx.TypeProto.Sequence\n       * @instance\n       */\n      Sequence.prototype.elemType = null;\n\n      /**\n       * Creates a new Sequence instance using the specified properties.\n       * @function create\n       * @memberof onnx.TypeProto.Sequence\n       * @static\n       * @param {onnx.TypeProto.ISequence=} [properties] Properties to set\n       * @returns {onnx.TypeProto.Sequence} Sequence instance\n       */\n      Sequence.create = function create(properties) {\n        return new Sequence(properties);\n      };\n\n      /**\n       * Encodes the specified Sequence message. Does not implicitly {@link onnx.TypeProto.Sequence.verify|verify} messages.\n       * @function encode\n       * @memberof onnx.TypeProto.Sequence\n       * @static\n       * @param {onnx.TypeProto.ISequence} message Sequence message or plain object to encode\n       * @param {$protobuf.Writer} [writer] Writer to encode to\n       * @returns {$protobuf.Writer} Writer\n       */\n      Sequence.encode = function encode(message, writer) {\n        if (!writer) writer = $Writer.create();\n        if (message.elemType != null && Object.hasOwnProperty.call(message, 'elemType'))\n          $root.onnx.TypeProto.encode(message.elemType, writer.uint32(/* id 1, wireType 2 =*/ 10).fork()).ldelim();\n        return writer;\n      };\n\n      /**\n       * Encodes the specified Sequence message, length delimited. Does not implicitly {@link onnx.TypeProto.Sequence.verify|verify} messages.\n       * @function encodeDelimited\n       * @memberof onnx.TypeProto.Sequence\n       * @static\n       * @param {onnx.TypeProto.ISequence} message Sequence message or plain object to encode\n       * @param {$protobuf.Writer} [writer] Writer to encode to\n       * @returns {$protobuf.Writer} Writer\n       */\n      Sequence.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n      };\n\n      /**\n       * Decodes a Sequence message from the specified reader or buffer.\n       * @function decode\n       * @memberof onnx.TypeProto.Sequence\n       * @static\n       * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n       * @param {number} [length] Message length if known beforehand\n       * @returns {onnx.TypeProto.Sequence} Sequence\n       * @throws {Error} If the payload is not a reader or valid buffer\n       * @throws {$protobuf.util.ProtocolError} If required fields are missing\n       */\n      Sequence.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader)) reader = $Reader.create(reader);\n        var end = length === undefined ? reader.len : reader.pos + length,\n          message = new $root.onnx.TypeProto.Sequence();\n        while (reader.pos < end) {\n          var tag = reader.uint32();\n          switch (tag >>> 3) {\n            case 1: {\n              message.elemType = $root.onnx.TypeProto.decode(reader, reader.uint32());\n              break;\n            }\n            default:\n              reader.skipType(tag & 7);\n              break;\n          }\n        }\n        return message;\n      };\n\n      /**\n       * Decodes a Sequence message from the specified reader or buffer, length delimited.\n       * @function decodeDelimited\n       * @memberof onnx.TypeProto.Sequence\n       * @static\n       * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n       * @returns {onnx.TypeProto.Sequence} Sequence\n       * @throws {Error} If the payload is not a reader or valid buffer\n       * @throws {$protobuf.util.ProtocolError} If required fields are missing\n       */\n      Sequence.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader)) reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n      };\n\n      /**\n       * Verifies a Sequence message.\n       * @function verify\n       * @memberof onnx.TypeProto.Sequence\n       * @static\n       * @param {Object.<string,*>} message Plain object to verify\n       * @returns {string|null} `null` if valid, otherwise the reason why it is not\n       */\n      Sequence.verify = function verify(message) {\n        if (typeof message !== 'object' || message === null) return 'object expected';\n        if (message.elemType != null && message.hasOwnProperty('elemType')) {\n          var error = $root.onnx.TypeProto.verify(message.elemType);\n          if (error) return 'elemType.' + error;\n        }\n        return null;\n      };\n\n      /**\n       * Creates a Sequence message from a plain object. Also converts values to their respective internal types.\n       * @function fromObject\n       * @memberof onnx.TypeProto.Sequence\n       * @static\n       * @param {Object.<string,*>} object Plain object\n       * @returns {onnx.TypeProto.Sequence} Sequence\n       */\n      Sequence.fromObject = function fromObject(object) {\n        if (object instanceof $root.onnx.TypeProto.Sequence) return object;\n        var message = new $root.onnx.TypeProto.Sequence();\n        if (object.elemType != null) {\n          if (typeof object.elemType !== 'object')\n            throw TypeError('.onnx.TypeProto.Sequence.elemType: object expected');\n          message.elemType = $root.onnx.TypeProto.fromObject(object.elemType);\n        }\n        return message;\n      };\n\n      /**\n       * Creates a plain object from a Sequence message. Also converts values to other types if specified.\n       * @function toObject\n       * @memberof onnx.TypeProto.Sequence\n       * @static\n       * @param {onnx.TypeProto.Sequence} message Sequence\n       * @param {$protobuf.IConversionOptions} [options] Conversion options\n       * @returns {Object.<string,*>} Plain object\n       */\n      Sequence.toObject = function toObject(message, options) {\n        if (!options) options = {};\n        var object = {};\n        if (options.defaults) object.elemType = null;\n        if (message.elemType != null && message.hasOwnProperty('elemType'))\n          object.elemType = $root.onnx.TypeProto.toObject(message.elemType, options);\n        return object;\n      };\n\n      /**\n       * Converts this Sequence to JSON.\n       * @function toJSON\n       * @memberof onnx.TypeProto.Sequence\n       * @instance\n       * @returns {Object.<string,*>} JSON object\n       */\n      Sequence.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n      };\n\n      /**\n       * Gets the default type url for Sequence\n       * @function getTypeUrl\n       * @memberof onnx.TypeProto.Sequence\n       * @static\n       * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default \"type.googleapis.com\")\n       * @returns {string} The default type url\n       */\n      Sequence.getTypeUrl = function getTypeUrl(typeUrlPrefix) {\n        if (typeUrlPrefix === undefined) {\n          typeUrlPrefix = 'type.googleapis.com';\n        }\n        return typeUrlPrefix + '/onnx.TypeProto.Sequence';\n      };\n\n      return Sequence;\n    })();\n\n    TypeProto.Map = (function () {\n      /**\n       * Properties of a Map.\n       * @memberof onnx.TypeProto\n       * @interface IMap\n       * @property {number|null} [keyType] Map keyType\n       * @property {onnx.ITypeProto|null} [valueType] Map valueType\n       */\n\n      /**\n       * Constructs a new Map.\n       * @memberof onnx.TypeProto\n       * @classdesc Represents a Map.\n       * @implements IMap\n       * @constructor\n       * @param {onnx.TypeProto.IMap=} [properties] Properties to set\n       */\n      function Map(properties) {\n        if (properties)\n          for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n            if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];\n      }\n\n      /**\n       * Map keyType.\n       * @member {number} keyType\n       * @memberof onnx.TypeProto.Map\n       * @instance\n       */\n      Map.prototype.keyType = 0;\n\n      /**\n       * Map valueType.\n       * @member {onnx.ITypeProto|null|undefined} valueType\n       * @memberof onnx.TypeProto.Map\n       * @instance\n       */\n      Map.prototype.valueType = null;\n\n      /**\n       * Creates a new Map instance using the specified properties.\n       * @function create\n       * @memberof onnx.TypeProto.Map\n       * @static\n       * @param {onnx.TypeProto.IMap=} [properties] Properties to set\n       * @returns {onnx.TypeProto.Map} Map instance\n       */\n      Map.create = function create(properties) {\n        return new Map(properties);\n      };\n\n      /**\n       * Encodes the specified Map message. Does not implicitly {@link onnx.TypeProto.Map.verify|verify} messages.\n       * @function encode\n       * @memberof onnx.TypeProto.Map\n       * @static\n       * @param {onnx.TypeProto.IMap} message Map message or plain object to encode\n       * @param {$protobuf.Writer} [writer] Writer to encode to\n       * @returns {$protobuf.Writer} Writer\n       */\n      Map.encode = function encode(message, writer) {\n        if (!writer) writer = $Writer.create();\n        if (message.keyType != null && Object.hasOwnProperty.call(message, 'keyType'))\n          writer.uint32(/* id 1, wireType 0 =*/ 8).int32(message.keyType);\n        if (message.valueType != null && Object.hasOwnProperty.call(message, 'valueType'))\n          $root.onnx.TypeProto.encode(message.valueType, writer.uint32(/* id 2, wireType 2 =*/ 18).fork()).ldelim();\n        return writer;\n      };\n\n      /**\n       * Encodes the specified Map message, length delimited. Does not implicitly {@link onnx.TypeProto.Map.verify|verify} messages.\n       * @function encodeDelimited\n       * @memberof onnx.TypeProto.Map\n       * @static\n       * @param {onnx.TypeProto.IMap} message Map message or plain object to encode\n       * @param {$protobuf.Writer} [writer] Writer to encode to\n       * @returns {$protobuf.Writer} Writer\n       */\n      Map.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n      };\n\n      /**\n       * Decodes a Map message from the specified reader or buffer.\n       * @function decode\n       * @memberof onnx.TypeProto.Map\n       * @static\n       * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n       * @param {number} [length] Message length if known beforehand\n       * @returns {onnx.TypeProto.Map} Map\n       * @throws {Error} If the payload is not a reader or valid buffer\n       * @throws {$protobuf.util.ProtocolError} If required fields are missing\n       */\n      Map.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader)) reader = $Reader.create(reader);\n        var end = length === undefined ? reader.len : reader.pos + length,\n          message = new $root.onnx.TypeProto.Map();\n        while (reader.pos < end) {\n          var tag = reader.uint32();\n          switch (tag >>> 3) {\n            case 1: {\n              message.keyType = reader.int32();\n              break;\n            }\n            case 2: {\n              message.valueType = $root.onnx.TypeProto.decode(reader, reader.uint32());\n              break;\n            }\n            default:\n              reader.skipType(tag & 7);\n              break;\n          }\n        }\n        return message;\n      };\n\n      /**\n       * Decodes a Map message from the specified reader or buffer, length delimited.\n       * @function decodeDelimited\n       * @memberof onnx.TypeProto.Map\n       * @static\n       * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n       * @returns {onnx.TypeProto.Map} Map\n       * @throws {Error} If the payload is not a reader or valid buffer\n       * @throws {$protobuf.util.ProtocolError} If required fields are missing\n       */\n      Map.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader)) reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n      };\n\n      /**\n       * Verifies a Map message.\n       * @function verify\n       * @memberof onnx.TypeProto.Map\n       * @static\n       * @param {Object.<string,*>} message Plain object to verify\n       * @returns {string|null} `null` if valid, otherwise the reason why it is not\n       */\n      Map.verify = function verify(message) {\n        if (typeof message !== 'object' || message === null) return 'object expected';\n        if (message.keyType != null && message.hasOwnProperty('keyType'))\n          if (!$util.isInteger(message.keyType)) return 'keyType: integer expected';\n        if (message.valueType != null && message.hasOwnProperty('valueType')) {\n          var error = $root.onnx.TypeProto.verify(message.valueType);\n          if (error) return 'valueType.' + error;\n        }\n        return null;\n      };\n\n      /**\n       * Creates a Map message from a plain object. Also converts values to their respective internal types.\n       * @function fromObject\n       * @memberof onnx.TypeProto.Map\n       * @static\n       * @param {Object.<string,*>} object Plain object\n       * @returns {onnx.TypeProto.Map} Map\n       */\n      Map.fromObject = function fromObject(object) {\n        if (object instanceof $root.onnx.TypeProto.Map) return object;\n        var message = new $root.onnx.TypeProto.Map();\n        if (object.keyType != null) message.keyType = object.keyType | 0;\n        if (object.valueType != null) {\n          if (typeof object.valueType !== 'object') throw TypeError('.onnx.TypeProto.Map.valueType: object expected');\n          message.valueType = $root.onnx.TypeProto.fromObject(object.valueType);\n        }\n        return message;\n      };\n\n      /**\n       * Creates a plain object from a Map message. Also converts values to other types if specified.\n       * @function toObject\n       * @memberof onnx.TypeProto.Map\n       * @static\n       * @param {onnx.TypeProto.Map} message Map\n       * @param {$protobuf.IConversionOptions} [options] Conversion options\n       * @returns {Object.<string,*>} Plain object\n       */\n      Map.toObject = function toObject(message, options) {\n        if (!options) options = {};\n        var object = {};\n        if (options.defaults) {\n          object.keyType = 0;\n          object.valueType = null;\n        }\n        if (message.keyType != null && message.hasOwnProperty('keyType')) object.keyType = message.keyType;\n        if (message.valueType != null && message.hasOwnProperty('valueType'))\n          object.valueType = $root.onnx.TypeProto.toObject(message.valueType, options);\n        return object;\n      };\n\n      /**\n       * Converts this Map to JSON.\n       * @function toJSON\n       * @memberof onnx.TypeProto.Map\n       * @instance\n       * @returns {Object.<string,*>} JSON object\n       */\n      Map.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n      };\n\n      /**\n       * Gets the default type url for Map\n       * @function getTypeUrl\n       * @memberof onnx.TypeProto.Map\n       * @static\n       * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default \"type.googleapis.com\")\n       * @returns {string} The default type url\n       */\n      Map.getTypeUrl = function getTypeUrl(typeUrlPrefix) {\n        if (typeUrlPrefix === undefined) {\n          typeUrlPrefix = 'type.googleapis.com';\n        }\n        return typeUrlPrefix + '/onnx.TypeProto.Map';\n      };\n\n      return Map;\n    })();\n\n    TypeProto.Optional = (function () {\n      /**\n       * Properties of an Optional.\n       * @memberof onnx.TypeProto\n       * @interface IOptional\n       * @property {onnx.ITypeProto|null} [elemType] Optional elemType\n       */\n\n      /**\n       * Constructs a new Optional.\n       * @memberof onnx.TypeProto\n       * @classdesc Represents an Optional.\n       * @implements IOptional\n       * @constructor\n       * @param {onnx.TypeProto.IOptional=} [properties] Properties to set\n       */\n      function Optional(properties) {\n        if (properties)\n          for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n            if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];\n      }\n\n      /**\n       * Optional elemType.\n       * @member {onnx.ITypeProto|null|undefined} elemType\n       * @memberof onnx.TypeProto.Optional\n       * @instance\n       */\n      Optional.prototype.elemType = null;\n\n      /**\n       * Creates a new Optional instance using the specified properties.\n       * @function create\n       * @memberof onnx.TypeProto.Optional\n       * @static\n       * @param {onnx.TypeProto.IOptional=} [properties] Properties to set\n       * @returns {onnx.TypeProto.Optional} Optional instance\n       */\n      Optional.create = function create(properties) {\n        return new Optional(properties);\n      };\n\n      /**\n       * Encodes the specified Optional message. Does not implicitly {@link onnx.TypeProto.Optional.verify|verify} messages.\n       * @function encode\n       * @memberof onnx.TypeProto.Optional\n       * @static\n       * @param {onnx.TypeProto.IOptional} message Optional message or plain object to encode\n       * @param {$protobuf.Writer} [writer] Writer to encode to\n       * @returns {$protobuf.Writer} Writer\n       */\n      Optional.encode = function encode(message, writer) {\n        if (!writer) writer = $Writer.create();\n        if (message.elemType != null && Object.hasOwnProperty.call(message, 'elemType'))\n          $root.onnx.TypeProto.encode(message.elemType, writer.uint32(/* id 1, wireType 2 =*/ 10).fork()).ldelim();\n        return writer;\n      };\n\n      /**\n       * Encodes the specified Optional message, length delimited. Does not implicitly {@link onnx.TypeProto.Optional.verify|verify} messages.\n       * @function encodeDelimited\n       * @memberof onnx.TypeProto.Optional\n       * @static\n       * @param {onnx.TypeProto.IOptional} message Optional message or plain object to encode\n       * @param {$protobuf.Writer} [writer] Writer to encode to\n       * @returns {$protobuf.Writer} Writer\n       */\n      Optional.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n      };\n\n      /**\n       * Decodes an Optional message from the specified reader or buffer.\n       * @function decode\n       * @memberof onnx.TypeProto.Optional\n       * @static\n       * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n       * @param {number} [length] Message length if known beforehand\n       * @returns {onnx.TypeProto.Optional} Optional\n       * @throws {Error} If the payload is not a reader or valid buffer\n       * @throws {$protobuf.util.ProtocolError} If required fields are missing\n       */\n      Optional.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader)) reader = $Reader.create(reader);\n        var end = length === undefined ? reader.len : reader.pos + length,\n          message = new $root.onnx.TypeProto.Optional();\n        while (reader.pos < end) {\n          var tag = reader.uint32();\n          switch (tag >>> 3) {\n            case 1: {\n              message.elemType = $root.onnx.TypeProto.decode(reader, reader.uint32());\n              break;\n            }\n            default:\n              reader.skipType(tag & 7);\n              break;\n          }\n        }\n        return message;\n      };\n\n      /**\n       * Decodes an Optional message from the specified reader or buffer, length delimited.\n       * @function decodeDelimited\n       * @memberof onnx.TypeProto.Optional\n       * @static\n       * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n       * @returns {onnx.TypeProto.Optional} Optional\n       * @throws {Error} If the payload is not a reader or valid buffer\n       * @throws {$protobuf.util.ProtocolError} If required fields are missing\n       */\n      Optional.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader)) reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n      };\n\n      /**\n       * Verifies an Optional message.\n       * @function verify\n       * @memberof onnx.TypeProto.Optional\n       * @static\n       * @param {Object.<string,*>} message Plain object to verify\n       * @returns {string|null} `null` if valid, otherwise the reason why it is not\n       */\n      Optional.verify = function verify(message) {\n        if (typeof message !== 'object' || message === null) return 'object expected';\n        if (message.elemType != null && message.hasOwnProperty('elemType')) {\n          var error = $root.onnx.TypeProto.verify(message.elemType);\n          if (error) return 'elemType.' + error;\n        }\n        return null;\n      };\n\n      /**\n       * Creates an Optional message from a plain object. Also converts values to their respective internal types.\n       * @function fromObject\n       * @memberof onnx.TypeProto.Optional\n       * @static\n       * @param {Object.<string,*>} object Plain object\n       * @returns {onnx.TypeProto.Optional} Optional\n       */\n      Optional.fromObject = function fromObject(object) {\n        if (object instanceof $root.onnx.TypeProto.Optional) return object;\n        var message = new $root.onnx.TypeProto.Optional();\n        if (object.elemType != null) {\n          if (typeof object.elemType !== 'object')\n            throw TypeError('.onnx.TypeProto.Optional.elemType: object expected');\n          message.elemType = $root.onnx.TypeProto.fromObject(object.elemType);\n        }\n        return message;\n      };\n\n      /**\n       * Creates a plain object from an Optional message. Also converts values to other types if specified.\n       * @function toObject\n       * @memberof onnx.TypeProto.Optional\n       * @static\n       * @param {onnx.TypeProto.Optional} message Optional\n       * @param {$protobuf.IConversionOptions} [options] Conversion options\n       * @returns {Object.<string,*>} Plain object\n       */\n      Optional.toObject = function toObject(message, options) {\n        if (!options) options = {};\n        var object = {};\n        if (options.defaults) object.elemType = null;\n        if (message.elemType != null && message.hasOwnProperty('elemType'))\n          object.elemType = $root.onnx.TypeProto.toObject(message.elemType, options);\n        return object;\n      };\n\n      /**\n       * Converts this Optional to JSON.\n       * @function toJSON\n       * @memberof onnx.TypeProto.Optional\n       * @instance\n       * @returns {Object.<string,*>} JSON object\n       */\n      Optional.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n      };\n\n      /**\n       * Gets the default type url for Optional\n       * @function getTypeUrl\n       * @memberof onnx.TypeProto.Optional\n       * @static\n       * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default \"type.googleapis.com\")\n       * @returns {string} The default type url\n       */\n      Optional.getTypeUrl = function getTypeUrl(typeUrlPrefix) {\n        if (typeUrlPrefix === undefined) {\n          typeUrlPrefix = 'type.googleapis.com';\n        }\n        return typeUrlPrefix + '/onnx.TypeProto.Optional';\n      };\n\n      return Optional;\n    })();\n\n    TypeProto.SparseTensor = (function () {\n      /**\n       * Properties of a SparseTensor.\n       * @memberof onnx.TypeProto\n       * @interface ISparseTensor\n       * @property {number|null} [elemType] SparseTensor elemType\n       * @property {onnx.ITensorShapeProto|null} [shape] SparseTensor shape\n       */\n\n      /**\n       * Constructs a new SparseTensor.\n       * @memberof onnx.TypeProto\n       * @classdesc Represents a SparseTensor.\n       * @implements ISparseTensor\n       * @constructor\n       * @param {onnx.TypeProto.ISparseTensor=} [properties] Properties to set\n       */\n      function SparseTensor(properties) {\n        if (properties)\n          for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n            if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];\n      }\n\n      /**\n       * SparseTensor elemType.\n       * @member {number} elemType\n       * @memberof onnx.TypeProto.SparseTensor\n       * @instance\n       */\n      SparseTensor.prototype.elemType = 0;\n\n      /**\n       * SparseTensor shape.\n       * @member {onnx.ITensorShapeProto|null|undefined} shape\n       * @memberof onnx.TypeProto.SparseTensor\n       * @instance\n       */\n      SparseTensor.prototype.shape = null;\n\n      /**\n       * Creates a new SparseTensor instance using the specified properties.\n       * @function create\n       * @memberof onnx.TypeProto.SparseTensor\n       * @static\n       * @param {onnx.TypeProto.ISparseTensor=} [properties] Properties to set\n       * @returns {onnx.TypeProto.SparseTensor} SparseTensor instance\n       */\n      SparseTensor.create = function create(properties) {\n        return new SparseTensor(properties);\n      };\n\n      /**\n       * Encodes the specified SparseTensor message. Does not implicitly {@link onnx.TypeProto.SparseTensor.verify|verify} messages.\n       * @function encode\n       * @memberof onnx.TypeProto.SparseTensor\n       * @static\n       * @param {onnx.TypeProto.ISparseTensor} message SparseTensor message or plain object to encode\n       * @param {$protobuf.Writer} [writer] Writer to encode to\n       * @returns {$protobuf.Writer} Writer\n       */\n      SparseTensor.encode = function encode(message, writer) {\n        if (!writer) writer = $Writer.create();\n        if (message.elemType != null && Object.hasOwnProperty.call(message, 'elemType'))\n          writer.uint32(/* id 1, wireType 0 =*/ 8).int32(message.elemType);\n        if (message.shape != null && Object.hasOwnProperty.call(message, 'shape'))\n          $root.onnx.TensorShapeProto.encode(message.shape, writer.uint32(/* id 2, wireType 2 =*/ 18).fork()).ldelim();\n        return writer;\n      };\n\n      /**\n       * Encodes the specified SparseTensor message, length delimited. Does not implicitly {@link onnx.TypeProto.SparseTensor.verify|verify} messages.\n       * @function encodeDelimited\n       * @memberof onnx.TypeProto.SparseTensor\n       * @static\n       * @param {onnx.TypeProto.ISparseTensor} message SparseTensor message or plain object to encode\n       * @param {$protobuf.Writer} [writer] Writer to encode to\n       * @returns {$protobuf.Writer} Writer\n       */\n      SparseTensor.encodeDelimited = function encodeDelimited(message, writer) {\n        return this.encode(message, writer).ldelim();\n      };\n\n      /**\n       * Decodes a SparseTensor message from the specified reader or buffer.\n       * @function decode\n       * @memberof onnx.TypeProto.SparseTensor\n       * @static\n       * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n       * @param {number} [length] Message length if known beforehand\n       * @returns {onnx.TypeProto.SparseTensor} SparseTensor\n       * @throws {Error} If the payload is not a reader or valid buffer\n       * @throws {$protobuf.util.ProtocolError} If required fields are missing\n       */\n      SparseTensor.decode = function decode(reader, length) {\n        if (!(reader instanceof $Reader)) reader = $Reader.create(reader);\n        var end = length === undefined ? reader.len : reader.pos + length,\n          message = new $root.onnx.TypeProto.SparseTensor();\n        while (reader.pos < end) {\n          var tag = reader.uint32();\n          switch (tag >>> 3) {\n            case 1: {\n              message.elemType = reader.int32();\n              break;\n            }\n            case 2: {\n              message.shape = $root.onnx.TensorShapeProto.decode(reader, reader.uint32());\n              break;\n            }\n            default:\n              reader.skipType(tag & 7);\n              break;\n          }\n        }\n        return message;\n      };\n\n      /**\n       * Decodes a SparseTensor message from the specified reader or buffer, length delimited.\n       * @function decodeDelimited\n       * @memberof onnx.TypeProto.SparseTensor\n       * @static\n       * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n       * @returns {onnx.TypeProto.SparseTensor} SparseTensor\n       * @throws {Error} If the payload is not a reader or valid buffer\n       * @throws {$protobuf.util.ProtocolError} If required fields are missing\n       */\n      SparseTensor.decodeDelimited = function decodeDelimited(reader) {\n        if (!(reader instanceof $Reader)) reader = new $Reader(reader);\n        return this.decode(reader, reader.uint32());\n      };\n\n      /**\n       * Verifies a SparseTensor message.\n       * @function verify\n       * @memberof onnx.TypeProto.SparseTensor\n       * @static\n       * @param {Object.<string,*>} message Plain object to verify\n       * @returns {string|null} `null` if valid, otherwise the reason why it is not\n       */\n      SparseTensor.verify = function verify(message) {\n        if (typeof message !== 'object' || message === null) return 'object expected';\n        if (message.elemType != null && message.hasOwnProperty('elemType'))\n          if (!$util.isInteger(message.elemType)) return 'elemType: integer expected';\n        if (message.shape != null && message.hasOwnProperty('shape')) {\n          var error = $root.onnx.TensorShapeProto.verify(message.shape);\n          if (error) return 'shape.' + error;\n        }\n        return null;\n      };\n\n      /**\n       * Creates a SparseTensor message from a plain object. Also converts values to their respective internal types.\n       * @function fromObject\n       * @memberof onnx.TypeProto.SparseTensor\n       * @static\n       * @param {Object.<string,*>} object Plain object\n       * @returns {onnx.TypeProto.SparseTensor} SparseTensor\n       */\n      SparseTensor.fromObject = function fromObject(object) {\n        if (object instanceof $root.onnx.TypeProto.SparseTensor) return object;\n        var message = new $root.onnx.TypeProto.SparseTensor();\n        if (object.elemType != null) message.elemType = object.elemType | 0;\n        if (object.shape != null) {\n          if (typeof object.shape !== 'object') throw TypeError('.onnx.TypeProto.SparseTensor.shape: object expected');\n          message.shape = $root.onnx.TensorShapeProto.fromObject(object.shape);\n        }\n        return message;\n      };\n\n      /**\n       * Creates a plain object from a SparseTensor message. Also converts values to other types if specified.\n       * @function toObject\n       * @memberof onnx.TypeProto.SparseTensor\n       * @static\n       * @param {onnx.TypeProto.SparseTensor} message SparseTensor\n       * @param {$protobuf.IConversionOptions} [options] Conversion options\n       * @returns {Object.<string,*>} Plain object\n       */\n      SparseTensor.toObject = function toObject(message, options) {\n        if (!options) options = {};\n        var object = {};\n        if (options.defaults) {\n          object.elemType = 0;\n          object.shape = null;\n        }\n        if (message.elemType != null && message.hasOwnProperty('elemType')) object.elemType = message.elemType;\n        if (message.shape != null && message.hasOwnProperty('shape'))\n          object.shape = $root.onnx.TensorShapeProto.toObject(message.shape, options);\n        return object;\n      };\n\n      /**\n       * Converts this SparseTensor to JSON.\n       * @function toJSON\n       * @memberof onnx.TypeProto.SparseTensor\n       * @instance\n       * @returns {Object.<string,*>} JSON object\n       */\n      SparseTensor.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n      };\n\n      /**\n       * Gets the default type url for SparseTensor\n       * @function getTypeUrl\n       * @memberof onnx.TypeProto.SparseTensor\n       * @static\n       * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default \"type.googleapis.com\")\n       * @returns {string} The default type url\n       */\n      SparseTensor.getTypeUrl = function getTypeUrl(typeUrlPrefix) {\n        if (typeUrlPrefix === undefined) {\n          typeUrlPrefix = 'type.googleapis.com';\n        }\n        return typeUrlPrefix + '/onnx.TypeProto.SparseTensor';\n      };\n\n      return SparseTensor;\n    })();\n\n    return TypeProto;\n  })();\n\n  onnx.OperatorSetIdProto = (function () {\n    /**\n     * Properties of an OperatorSetIdProto.\n     * @memberof onnx\n     * @interface IOperatorSetIdProto\n     * @property {string|null} [domain] OperatorSetIdProto domain\n     * @property {number|Long|null} [version] OperatorSetIdProto version\n     */\n\n    /**\n     * Constructs a new OperatorSetIdProto.\n     * @memberof onnx\n     * @classdesc Represents an OperatorSetIdProto.\n     * @implements IOperatorSetIdProto\n     * @constructor\n     * @param {onnx.IOperatorSetIdProto=} [properties] Properties to set\n     */\n    function OperatorSetIdProto(properties) {\n      if (properties)\n        for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n          if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * OperatorSetIdProto domain.\n     * @member {string} domain\n     * @memberof onnx.OperatorSetIdProto\n     * @instance\n     */\n    OperatorSetIdProto.prototype.domain = '';\n\n    /**\n     * OperatorSetIdProto version.\n     * @member {number|Long} version\n     * @memberof onnx.OperatorSetIdProto\n     * @instance\n     */\n    OperatorSetIdProto.prototype.version = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;\n\n    /**\n     * Creates a new OperatorSetIdProto instance using the specified properties.\n     * @function create\n     * @memberof onnx.OperatorSetIdProto\n     * @static\n     * @param {onnx.IOperatorSetIdProto=} [properties] Properties to set\n     * @returns {onnx.OperatorSetIdProto} OperatorSetIdProto instance\n     */\n    OperatorSetIdProto.create = function create(properties) {\n      return new OperatorSetIdProto(properties);\n    };\n\n    /**\n     * Encodes the specified OperatorSetIdProto message. Does not implicitly {@link onnx.OperatorSetIdProto.verify|verify} messages.\n     * @function encode\n     * @memberof onnx.OperatorSetIdProto\n     * @static\n     * @param {onnx.IOperatorSetIdProto} message OperatorSetIdProto message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    OperatorSetIdProto.encode = function encode(message, writer) {\n      if (!writer) writer = $Writer.create();\n      if (message.domain != null && Object.hasOwnProperty.call(message, 'domain'))\n        writer.uint32(/* id 1, wireType 2 =*/ 10).string(message.domain);\n      if (message.version != null && Object.hasOwnProperty.call(message, 'version'))\n        writer.uint32(/* id 2, wireType 0 =*/ 16).int64(message.version);\n      return writer;\n    };\n\n    /**\n     * Encodes the specified OperatorSetIdProto message, length delimited. Does not implicitly {@link onnx.OperatorSetIdProto.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof onnx.OperatorSetIdProto\n     * @static\n     * @param {onnx.IOperatorSetIdProto} message OperatorSetIdProto message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    OperatorSetIdProto.encodeDelimited = function encodeDelimited(message, writer) {\n      return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes an OperatorSetIdProto message from the specified reader or buffer.\n     * @function decode\n     * @memberof onnx.OperatorSetIdProto\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {onnx.OperatorSetIdProto} OperatorSetIdProto\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    OperatorSetIdProto.decode = function decode(reader, length) {\n      if (!(reader instanceof $Reader)) reader = $Reader.create(reader);\n      var end = length === undefined ? reader.len : reader.pos + length,\n        message = new $root.onnx.OperatorSetIdProto();\n      while (reader.pos < end) {\n        var tag = reader.uint32();\n        switch (tag >>> 3) {\n          case 1: {\n            message.domain = reader.string();\n            break;\n          }\n          case 2: {\n            message.version = reader.int64();\n            break;\n          }\n          default:\n            reader.skipType(tag & 7);\n            break;\n        }\n      }\n      return message;\n    };\n\n    /**\n     * Decodes an OperatorSetIdProto message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof onnx.OperatorSetIdProto\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {onnx.OperatorSetIdProto} OperatorSetIdProto\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    OperatorSetIdProto.decodeDelimited = function decodeDelimited(reader) {\n      if (!(reader instanceof $Reader)) reader = new $Reader(reader);\n      return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies an OperatorSetIdProto message.\n     * @function verify\n     * @memberof onnx.OperatorSetIdProto\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    OperatorSetIdProto.verify = function verify(message) {\n      if (typeof message !== 'object' || message === null) return 'object expected';\n      if (message.domain != null && message.hasOwnProperty('domain'))\n        if (!$util.isString(message.domain)) return 'domain: string expected';\n      if (message.version != null && message.hasOwnProperty('version'))\n        if (\n          !$util.isInteger(message.version) &&\n          !(message.version && $util.isInteger(message.version.low) && $util.isInteger(message.version.high))\n        )\n          return 'version: integer|Long expected';\n      return null;\n    };\n\n    /**\n     * Creates an OperatorSetIdProto message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof onnx.OperatorSetIdProto\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {onnx.OperatorSetIdProto} OperatorSetIdProto\n     */\n    OperatorSetIdProto.fromObject = function fromObject(object) {\n      if (object instanceof $root.onnx.OperatorSetIdProto) return object;\n      var message = new $root.onnx.OperatorSetIdProto();\n      if (object.domain != null) message.domain = String(object.domain);\n      if (object.version != null)\n        if ($util.Long) (message.version = $util.Long.fromValue(object.version)).unsigned = false;\n        else if (typeof object.version === 'string') message.version = parseInt(object.version, 10);\n        else if (typeof object.version === 'number') message.version = object.version;\n        else if (typeof object.version === 'object')\n          message.version = new $util.LongBits(object.version.low >>> 0, object.version.high >>> 0).toNumber();\n      return message;\n    };\n\n    /**\n     * Creates a plain object from an OperatorSetIdProto message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof onnx.OperatorSetIdProto\n     * @static\n     * @param {onnx.OperatorSetIdProto} message OperatorSetIdProto\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    OperatorSetIdProto.toObject = function toObject(message, options) {\n      if (!options) options = {};\n      var object = {};\n      if (options.defaults) {\n        object.domain = '';\n        if ($util.Long) {\n          var long = new $util.Long(0, 0, false);\n          object.version =\n            options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;\n        } else object.version = options.longs === String ? '0' : 0;\n      }\n      if (message.domain != null && message.hasOwnProperty('domain')) object.domain = message.domain;\n      if (message.version != null && message.hasOwnProperty('version'))\n        if (typeof message.version === 'number')\n          object.version = options.longs === String ? String(message.version) : message.version;\n        else\n          object.version =\n            options.longs === String\n              ? $util.Long.prototype.toString.call(message.version)\n              : options.longs === Number\n                ? new $util.LongBits(message.version.low >>> 0, message.version.high >>> 0).toNumber()\n                : message.version;\n      return object;\n    };\n\n    /**\n     * Converts this OperatorSetIdProto to JSON.\n     * @function toJSON\n     * @memberof onnx.OperatorSetIdProto\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    OperatorSetIdProto.prototype.toJSON = function toJSON() {\n      return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    /**\n     * Gets the default type url for OperatorSetIdProto\n     * @function getTypeUrl\n     * @memberof onnx.OperatorSetIdProto\n     * @static\n     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default \"type.googleapis.com\")\n     * @returns {string} The default type url\n     */\n    OperatorSetIdProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {\n      if (typeUrlPrefix === undefined) {\n        typeUrlPrefix = 'type.googleapis.com';\n      }\n      return typeUrlPrefix + '/onnx.OperatorSetIdProto';\n    };\n\n    return OperatorSetIdProto;\n  })();\n\n  /**\n   * OperatorStatus enum.\n   * @name onnx.OperatorStatus\n   * @enum {number}\n   * @property {number} EXPERIMENTAL=0 EXPERIMENTAL value\n   * @property {number} STABLE=1 STABLE value\n   */\n  onnx.OperatorStatus = (function () {\n    var valuesById = {},\n      values = Object.create(valuesById);\n    values[(valuesById[0] = 'EXPERIMENTAL')] = 0;\n    values[(valuesById[1] = 'STABLE')] = 1;\n    return values;\n  })();\n\n  onnx.FunctionProto = (function () {\n    /**\n     * Properties of a FunctionProto.\n     * @memberof onnx\n     * @interface IFunctionProto\n     * @property {string|null} [name] FunctionProto name\n     * @property {Array.<string>|null} [input] FunctionProto input\n     * @property {Array.<string>|null} [output] FunctionProto output\n     * @property {Array.<string>|null} [attribute] FunctionProto attribute\n     * @property {Array.<onnx.IAttributeProto>|null} [attributeProto] FunctionProto attributeProto\n     * @property {Array.<onnx.INodeProto>|null} [node] FunctionProto node\n     * @property {string|null} [docString] FunctionProto docString\n     * @property {Array.<onnx.IOperatorSetIdProto>|null} [opsetImport] FunctionProto opsetImport\n     * @property {string|null} [domain] FunctionProto domain\n     */\n\n    /**\n     * Constructs a new FunctionProto.\n     * @memberof onnx\n     * @classdesc Represents a FunctionProto.\n     * @implements IFunctionProto\n     * @constructor\n     * @param {onnx.IFunctionProto=} [properties] Properties to set\n     */\n    function FunctionProto(properties) {\n      this.input = [];\n      this.output = [];\n      this.attribute = [];\n      this.attributeProto = [];\n      this.node = [];\n      this.opsetImport = [];\n      if (properties)\n        for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n          if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];\n    }\n\n    /**\n     * FunctionProto name.\n     * @member {string} name\n     * @memberof onnx.FunctionProto\n     * @instance\n     */\n    FunctionProto.prototype.name = '';\n\n    /**\n     * FunctionProto input.\n     * @member {Array.<string>} input\n     * @memberof onnx.FunctionProto\n     * @instance\n     */\n    FunctionProto.prototype.input = $util.emptyArray;\n\n    /**\n     * FunctionProto output.\n     * @member {Array.<string>} output\n     * @memberof onnx.FunctionProto\n     * @instance\n     */\n    FunctionProto.prototype.output = $util.emptyArray;\n\n    /**\n     * FunctionProto attribute.\n     * @member {Array.<string>} attribute\n     * @memberof onnx.FunctionProto\n     * @instance\n     */\n    FunctionProto.prototype.attribute = $util.emptyArray;\n\n    /**\n     * FunctionProto attributeProto.\n     * @member {Array.<onnx.IAttributeProto>} attributeProto\n     * @memberof onnx.FunctionProto\n     * @instance\n     */\n    FunctionProto.prototype.attributeProto = $util.emptyArray;\n\n    /**\n     * FunctionProto node.\n     * @member {Array.<onnx.INodeProto>} node\n     * @memberof onnx.FunctionProto\n     * @instance\n     */\n    FunctionProto.prototype.node = $util.emptyArray;\n\n    /**\n     * FunctionProto docString.\n     * @member {string} docString\n     * @memberof onnx.FunctionProto\n     * @instance\n     */\n    FunctionProto.prototype.docString = '';\n\n    /**\n     * FunctionProto opsetImport.\n     * @member {Array.<onnx.IOperatorSetIdProto>} opsetImport\n     * @memberof onnx.FunctionProto\n     * @instance\n     */\n    FunctionProto.prototype.opsetImport = $util.emptyArray;\n\n    /**\n     * FunctionProto domain.\n     * @member {string} domain\n     * @memberof onnx.FunctionProto\n     * @instance\n     */\n    FunctionProto.prototype.domain = '';\n\n    /**\n     * Creates a new FunctionProto instance using the specified properties.\n     * @function create\n     * @memberof onnx.FunctionProto\n     * @static\n     * @param {onnx.IFunctionProto=} [properties] Properties to set\n     * @returns {onnx.FunctionProto} FunctionProto instance\n     */\n    FunctionProto.create = function create(properties) {\n      return new FunctionProto(properties);\n    };\n\n    /**\n     * Encodes the specified FunctionProto message. Does not implicitly {@link onnx.FunctionProto.verify|verify} messages.\n     * @function encode\n     * @memberof onnx.FunctionProto\n     * @static\n     * @param {onnx.IFunctionProto} message FunctionProto message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    FunctionProto.encode = function encode(message, writer) {\n      if (!writer) writer = $Writer.create();\n      if (message.name != null && Object.hasOwnProperty.call(message, 'name'))\n        writer.uint32(/* id 1, wireType 2 =*/ 10).string(message.name);\n      if (message.input != null && message.input.length)\n        for (var i = 0; i < message.input.length; ++i)\n          writer.uint32(/* id 4, wireType 2 =*/ 34).string(message.input[i]);\n      if (message.output != null && message.output.length)\n        for (var i = 0; i < message.output.length; ++i)\n          writer.uint32(/* id 5, wireType 2 =*/ 42).string(message.output[i]);\n      if (message.attribute != null && message.attribute.length)\n        for (var i = 0; i < message.attribute.length; ++i)\n          writer.uint32(/* id 6, wireType 2 =*/ 50).string(message.attribute[i]);\n      if (message.node != null && message.node.length)\n        for (var i = 0; i < message.node.length; ++i)\n          $root.onnx.NodeProto.encode(message.node[i], writer.uint32(/* id 7, wireType 2 =*/ 58).fork()).ldelim();\n      if (message.docString != null && Object.hasOwnProperty.call(message, 'docString'))\n        writer.uint32(/* id 8, wireType 2 =*/ 66).string(message.docString);\n      if (message.opsetImport != null && message.opsetImport.length)\n        for (var i = 0; i < message.opsetImport.length; ++i)\n          $root.onnx.OperatorSetIdProto.encode(\n            message.opsetImport[i],\n            writer.uint32(/* id 9, wireType 2 =*/ 74).fork(),\n          ).ldelim();\n      if (message.domain != null && Object.hasOwnProperty.call(message, 'domain'))\n        writer.uint32(/* id 10, wireType 2 =*/ 82).string(message.domain);\n      if (message.attributeProto != null && message.attributeProto.length)\n        for (var i = 0; i < message.attributeProto.length; ++i)\n          $root.onnx.AttributeProto.encode(\n            message.attributeProto[i],\n            writer.uint32(/* id 11, wireType 2 =*/ 90).fork(),\n          ).ldelim();\n      return writer;\n    };\n\n    /**\n     * Encodes the specified FunctionProto message, length delimited. Does not implicitly {@link onnx.FunctionProto.verify|verify} messages.\n     * @function encodeDelimited\n     * @memberof onnx.FunctionProto\n     * @static\n     * @param {onnx.IFunctionProto} message FunctionProto message or plain object to encode\n     * @param {$protobuf.Writer} [writer] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    FunctionProto.encodeDelimited = function encodeDelimited(message, writer) {\n      return this.encode(message, writer).ldelim();\n    };\n\n    /**\n     * Decodes a FunctionProto message from the specified reader or buffer.\n     * @function decode\n     * @memberof onnx.FunctionProto\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @param {number} [length] Message length if known beforehand\n     * @returns {onnx.FunctionProto} FunctionProto\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    FunctionProto.decode = function decode(reader, length) {\n      if (!(reader instanceof $Reader)) reader = $Reader.create(reader);\n      var end = length === undefined ? reader.len : reader.pos + length,\n        message = new $root.onnx.FunctionProto();\n      while (reader.pos < end) {\n        var tag = reader.uint32();\n        switch (tag >>> 3) {\n          case 1: {\n            message.name = reader.string();\n            break;\n          }\n          case 4: {\n            if (!(message.input && message.input.length)) message.input = [];\n            message.input.push(reader.string());\n            break;\n          }\n          case 5: {\n            if (!(message.output && message.output.length)) message.output = [];\n            message.output.push(reader.string());\n            break;\n          }\n          case 6: {\n            if (!(message.attribute && message.attribute.length)) message.attribute = [];\n            message.attribute.push(reader.string());\n            break;\n          }\n          case 11: {\n            if (!(message.attributeProto && message.attributeProto.length)) message.attributeProto = [];\n            message.attributeProto.push($root.onnx.AttributeProto.decode(reader, reader.uint32()));\n            break;\n          }\n          case 7: {\n            if (!(message.node && message.node.length)) message.node = [];\n            message.node.push($root.onnx.NodeProto.decode(reader, reader.uint32()));\n            break;\n          }\n          case 8: {\n            message.docString = reader.string();\n            break;\n          }\n          case 9: {\n            if (!(message.opsetImport && message.opsetImport.length)) message.opsetImport = [];\n            message.opsetImport.push($root.onnx.OperatorSetIdProto.decode(reader, reader.uint32()));\n            break;\n          }\n          case 10: {\n            message.domain = reader.string();\n            break;\n          }\n          default:\n            reader.skipType(tag & 7);\n            break;\n        }\n      }\n      return message;\n    };\n\n    /**\n     * Decodes a FunctionProto message from the specified reader or buffer, length delimited.\n     * @function decodeDelimited\n     * @memberof onnx.FunctionProto\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n     * @returns {onnx.FunctionProto} FunctionProto\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    FunctionProto.decodeDelimited = function decodeDelimited(reader) {\n      if (!(reader instanceof $Reader)) reader = new $Reader(reader);\n      return this.decode(reader, reader.uint32());\n    };\n\n    /**\n     * Verifies a FunctionProto message.\n     * @function verify\n     * @memberof onnx.FunctionProto\n     * @static\n     * @param {Object.<string,*>} message Plain object to verify\n     * @returns {string|null} `null` if valid, otherwise the reason why it is not\n     */\n    FunctionProto.verify = function verify(message) {\n      if (typeof message !== 'object' || message === null) return 'object expected';\n      if (message.name != null && message.hasOwnProperty('name'))\n        if (!$util.isString(message.name)) return 'name: string expected';\n      if (message.input != null && message.hasOwnProperty('input')) {\n        if (!Array.isArray(message.input)) return 'input: array expected';\n        for (var i = 0; i < message.input.length; ++i)\n          if (!$util.isString(message.input[i])) return 'input: string[] expected';\n      }\n      if (message.output != null && message.hasOwnProperty('output')) {\n        if (!Array.isArray(message.output)) return 'output: array expected';\n        for (var i = 0; i < message.output.length; ++i)\n          if (!$util.isString(message.output[i])) return 'output: string[] expected';\n      }\n      if (message.attribute != null && message.hasOwnProperty('attribute')) {\n        if (!Array.isArray(message.attribute)) return 'attribute: array expected';\n        for (var i = 0; i < message.attribute.length; ++i)\n          if (!$util.isString(message.attribute[i])) return 'attribute: string[] expected';\n      }\n      if (message.attributeProto != null && message.hasOwnProperty('attributeProto')) {\n        if (!Array.isArray(message.attributeProto)) return 'attributeProto: array expected';\n        for (var i = 0; i < message.attributeProto.length; ++i) {\n          var error = $root.onnx.AttributeProto.verify(message.attributeProto[i]);\n          if (error) return 'attributeProto.' + error;\n        }\n      }\n      if (message.node != null && message.hasOwnProperty('node')) {\n        if (!Array.isArray(message.node)) return 'node: array expected';\n        for (var i = 0; i < message.node.length; ++i) {\n          var error = $root.onnx.NodeProto.verify(message.node[i]);\n          if (error) return 'node.' + error;\n        }\n      }\n      if (message.docString != null && message.hasOwnProperty('docString'))\n        if (!$util.isString(message.docString)) return 'docString: string expected';\n      if (message.opsetImport != null && message.hasOwnProperty('opsetImport')) {\n        if (!Array.isArray(message.opsetImport)) return 'opsetImport: array expected';\n        for (var i = 0; i < message.opsetImport.length; ++i) {\n          var error = $root.onnx.OperatorSetIdProto.verify(message.opsetImport[i]);\n          if (error) return 'opsetImport.' + error;\n        }\n      }\n      if (message.domain != null && message.hasOwnProperty('domain'))\n        if (!$util.isString(message.domain)) return 'domain: string expected';\n      return null;\n    };\n\n    /**\n     * Creates a FunctionProto message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof onnx.FunctionProto\n     * @static\n     * @param {Object.<string,*>} object Plain object\n     * @returns {onnx.FunctionProto} FunctionProto\n     */\n    FunctionProto.fromObject = function fromObject(object) {\n      if (object instanceof $root.onnx.FunctionProto) return object;\n      var message = new $root.onnx.FunctionProto();\n      if (object.name != null) message.name = String(object.name);\n      if (object.input) {\n        if (!Array.isArray(object.input)) throw TypeError('.onnx.FunctionProto.input: array expected');\n        message.input = [];\n        for (var i = 0; i < object.input.length; ++i) message.input[i] = String(object.input[i]);\n      }\n      if (object.output) {\n        if (!Array.isArray(object.output)) throw TypeError('.onnx.FunctionProto.output: array expected');\n        message.output = [];\n        for (var i = 0; i < object.output.length; ++i) message.output[i] = String(object.output[i]);\n      }\n      if (object.attribute) {\n        if (!Array.isArray(object.attribute)) throw TypeError('.onnx.FunctionProto.attribute: array expected');\n        message.attribute = [];\n        for (var i = 0; i < object.attribute.length; ++i) message.attribute[i] = String(object.attribute[i]);\n      }\n      if (object.attributeProto) {\n        if (!Array.isArray(object.attributeProto))\n          throw TypeError('.onnx.FunctionProto.attributeProto: array expected');\n        message.attributeProto = [];\n        for (var i = 0; i < object.attributeProto.length; ++i) {\n          if (typeof object.attributeProto[i] !== 'object')\n            throw TypeError('.onnx.FunctionProto.attributeProto: object expected');\n          message.attributeProto[i] = $root.onnx.AttributeProto.fromObject(object.attributeProto[i]);\n        }\n      }\n      if (object.node) {\n        if (!Array.isArray(object.node)) throw TypeError('.onnx.FunctionProto.node: array expected');\n        message.node = [];\n        for (var i = 0; i < object.node.length; ++i) {\n          if (typeof object.node[i] !== 'object') throw TypeError('.onnx.FunctionProto.node: object expected');\n          message.node[i] = $root.onnx.NodeProto.fromObject(object.node[i]);\n        }\n      }\n      if (object.docString != null) message.docString = String(object.docString);\n      if (object.opsetImport) {\n        if (!Array.isArray(object.opsetImport)) throw TypeError('.onnx.FunctionProto.opsetImport: array expected');\n        message.opsetImport = [];\n        for (var i = 0; i < object.opsetImport.length; ++i) {\n          if (typeof object.opsetImport[i] !== 'object')\n            throw TypeError('.onnx.FunctionProto.opsetImport: object expected');\n          message.opsetImport[i] = $root.onnx.OperatorSetIdProto.fromObject(object.opsetImport[i]);\n        }\n      }\n      if (object.domain != null) message.domain = String(object.domain);\n      return message;\n    };\n\n    /**\n     * Creates a plain object from a FunctionProto message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof onnx.FunctionProto\n     * @static\n     * @param {onnx.FunctionProto} message FunctionProto\n     * @param {$protobuf.IConversionOptions} [options] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    FunctionProto.toObject = function toObject(message, options) {\n      if (!options) options = {};\n      var object = {};\n      if (options.arrays || options.defaults) {\n        object.input = [];\n        object.output = [];\n        object.attribute = [];\n        object.node = [];\n        object.opsetImport = [];\n        object.attributeProto = [];\n      }\n      if (options.defaults) {\n        object.name = '';\n        object.docString = '';\n        object.domain = '';\n      }\n      if (message.name != null && message.hasOwnProperty('name')) object.name = message.name;\n      if (message.input && message.input.length) {\n        object.input = [];\n        for (var j = 0; j < message.input.length; ++j) object.input[j] = message.input[j];\n      }\n      if (message.output && message.output.length) {\n        object.output = [];\n        for (var j = 0; j < message.output.length; ++j) object.output[j] = message.output[j];\n      }\n      if (message.attribute && message.attribute.length) {\n        object.attribute = [];\n        for (var j = 0; j < message.attribute.length; ++j) object.attribute[j] = message.attribute[j];\n      }\n      if (message.node && message.node.length) {\n        object.node = [];\n        for (var j = 0; j < message.node.length; ++j)\n          object.node[j] = $root.onnx.NodeProto.toObject(message.node[j], options);\n      }\n      if (message.docString != null && message.hasOwnProperty('docString')) object.docString = message.docString;\n      if (message.opsetImport && message.opsetImport.length) {\n        object.opsetImport = [];\n        for (var j = 0; j < message.opsetImport.length; ++j)\n          object.opsetImport[j] = $root.onnx.OperatorSetIdProto.toObject(message.opsetImport[j], options);\n      }\n      if (message.domain != null && message.hasOwnProperty('domain')) object.domain = message.domain;\n      if (message.attributeProto && message.attributeProto.length) {\n        object.attributeProto = [];\n        for (var j = 0; j < message.attributeProto.length; ++j)\n          object.attributeProto[j] = $root.onnx.AttributeProto.toObject(message.attributeProto[j], options);\n      }\n      return object;\n    };\n\n    /**\n     * Converts this FunctionProto to JSON.\n     * @function toJSON\n     * @memberof onnx.FunctionProto\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    FunctionProto.prototype.toJSON = function toJSON() {\n      return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    /**\n     * Gets the default type url for FunctionProto\n     * @function getTypeUrl\n     * @memberof onnx.FunctionProto\n     * @static\n     * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default \"type.googleapis.com\")\n     * @returns {string} The default type url\n     */\n    FunctionProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {\n      if (typeUrlPrefix === undefined) {\n        typeUrlPrefix = 'type.googleapis.com';\n      }\n      return typeUrlPrefix + '/onnx.FunctionProto';\n    };\n\n    return FunctionProto;\n  })();\n\n  return onnx;\n})();\n\nmodule.exports = $root;\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport Long from 'long';\n\nimport { Graph } from './graph';\nimport * as ortFbs from './ort-schema/flatbuffers/ort-generated';\nimport { onnx } from './ort-schema/protobuf/onnx';\nimport { Tensor } from './tensor';\n\n// check the inputs shape before running an OP.\n// return true when the inputs pass the check\n// return false when the inputs do not fit the requirement\n// throw exception when fatal error or not implemented\nexport function checkInputsShape(inputs: Tensor[], ...expectedDimensions: number[]): boolean {\n  if (!inputs || inputs.length !== expectedDimensions.length) {\n    return false;\n  }\n  for (let i = 0; i < inputs.length; i++) {\n    if (!inputs[i].dims || inputs[i].dims.length !== expectedDimensions[i]) {\n      return false;\n    }\n  }\n  return true;\n}\n\n// Evaluates the given expression and asserts error message if condition is unmet.\nexport function assert(expr: boolean, msg: () => string) {\n  if (!expr) {\n    throw new Error(typeof msg === 'string' ? msg : msg());\n  }\n}\n\nexport class ArrayUtil {\n  /**\n   * Verifies if 2 input arrays contain the same elements.\n   * @param n1 Array 1\n   * @param n2 Array 2\n   * @returns Whether these 2 are equal\n   */\n  static arraysEqual(\n    n1:\n      | readonly number[]\n      | Int8Array\n      | Uint8Array\n      | Int16Array\n      | Uint16Array\n      | Int32Array\n      | Uint32Array\n      | Uint8ClampedArray\n      | Float32Array\n      | Float64Array,\n    n2:\n      | readonly number[]\n      | Int8Array\n      | Uint8Array\n      | Int16Array\n      | Uint16Array\n      | Int32Array\n      | Uint32Array\n      | Uint8ClampedArray\n      | Float32Array\n      | Float64Array,\n  ) {\n    if (n1.length !== n2.length) {\n      return false;\n    }\n    for (let i = 0; i < n1.length; i++) {\n      if (n1[i] !== n2[i]) {\n        return false;\n      }\n    }\n    return true;\n  }\n}\n\nexport class MatMulUtil {\n  /**\n   * Fix the input shapes for MatMul operation if they need fixing\n   * @param dimsA The shape of tensor A. Should be an array of positive integers\n   * @param dimsB The shape of tensor B. Should be an array of positive integers\n   * @returns A tuple containing the preprocessed input shapes as required by ONNX specifications\n   */\n  static preprocessInputShapes(\n    dimsA: readonly number[],\n    dimsB: readonly number[],\n  ): [readonly number[], readonly number[]] {\n    // If the first argument is 1-D, it is promoted to a matrix by prepending\n    // a 1 to its dimensions. After matrix multiplication the prepended 1 is\n    // removed.\n    const a = dimsA.length === 1 ? [1, dimsA[0]] : dimsA;\n\n    // If the second argument is 1-D, it is promoted to a matrix by appending\n    // a 1 to its dimensions. After matrix multiplication the appended 1 is\n    // removed.\n    const b = dimsB.length === 1 ? [dimsB[0], 1] : dimsB;\n\n    return [a, b];\n  }\n\n  /**\n   * Fix the output shape computed for MatMul operation if it needs fixing\n   * @param outputShape The computed outputShape. Should be an array (at least of length 2) of positive integers.\n   * This will be mutated.\n   * @param aRank The rank of tensor A.\n   * @param bRank The rank of tensor B.\n   */\n  static postprocessOutputShape(outputShape: number[], aRank: number, bRank: number) {\n    // Remove prepended dimension if first input is 1d\n    if (aRank === 1) {\n      // outputShape = outputShape.slice(0, outputShape.length - 2).concat(outputShape.slice(outputShape.length - 1));\n      outputShape.splice(outputShape.length - 2, 1);\n    }\n    // Remove appended dimension if second input is 1d\n    if (bRank === 1) {\n      outputShape.pop();\n    }\n  }\n\n  /**\n   * Calculate the expected shape when matrix multiplication\n   * @param a The shape of tensor A. Should be a tuple of 2 positive integers\n   * @param b The shape of tensor B. Should be a tuple of 2 positive integers\n   * @returns The expected shape of the result, or undefined if N/A\n   */\n  static calcMatMulShape(a: [number, number], b: [number, number]): [number, number] | undefined {\n    return a[1] !== b[0] ? undefined : [a[0], b[1]];\n  }\n}\n\nexport class BroadcastUtil {\n  /**\n   * Calculate the expected shape when broadcasting 2 tensors\n   * @param a The shape of tensor A. Should be an array of positive integers\n   * @param b The shape of tensor B. Should be an array of positive integers\n   * @param isMatMul Whether the operation is MatMul\n   * @returns The expected shape of the result, or undefined if N/A\n   */\n  static calcShape(\n    adims: readonly number[],\n    bdims: readonly number[],\n    isMatMul = false,\n  ): readonly number[] | undefined {\n    const arank = adims.length;\n    const brank = bdims.length;\n    if (arank === 0) {\n      return bdims;\n    }\n    if (brank === 0) {\n      return adims;\n    }\n    const crank = Math.max(adims.length, bdims.length);\n    const cdims = new Array<number>(crank);\n\n    // calculate the last 2 dimension if it is MatMul\n    if (isMatMul) {\n      if (arank < 2 || brank < 2) {\n        return undefined;\n      }\n      const cShapeMatMul = MatMulUtil.calcMatMulShape(\n        [adims[arank - 2], adims[arank - 1]],\n        [bdims[brank - 2], bdims[brank - 1]],\n      );\n      if (cShapeMatMul === undefined) {\n        return undefined;\n      }\n      [cdims[crank - 2], cdims[crank - 1]] = cShapeMatMul;\n    }\n\n    for (let i = isMatMul ? 3 : 1; i <= crank; i++) {\n      const aLen = arank - i < 0 ? 1 : adims[arank - i];\n      const bLen = brank - i < 0 ? 1 : bdims[brank - i];\n\n      if (aLen !== bLen && aLen > 1 && bLen > 1) {\n        return undefined;\n      }\n      cdims[crank - i] = Math.max(aLen, bLen);\n    }\n\n    return cdims;\n  }\n\n  /**\n   * Given the indices of a broadcasted tensor, calculate the original indices\n   * @param broadcastedIndices The given indices of the broadcasted tensor.\n   * @param originalShape The original shape of the tensor before broadcast\n   * @returns The calculated indices that maps to the original tensor.\n   */\n  static index(broadcastedIndices: readonly number[], originalShape: readonly number[]): number[] {\n    // NOTE 1: we assume the parameter broadcastedIndices is valid. ie. it should have the same\n    // length as the broadcasted shape, and for each dimension the index should\n    // not be out of range.\n    const originalIndices = new Array(originalShape.length);\n    BroadcastUtil.fillIndex(broadcastedIndices, originalShape, originalIndices);\n    return originalIndices;\n  }\n\n  /**\n   * Given the indices of a broadcasted tensor, calculate the original indices\n   * @param broadcastedIndices The given indices of the broadcasted tensor.\n   * @param originalShape The original shape of the tensor before broadcast\n   * @param originalIndices The mapping of broadcastedIndices to the originalIndices (output parameter - will be\n   *     mutated).\n   */\n  static fillIndex(broadcastedIndices: readonly number[], originalShape: readonly number[], originalIndices: number[]) {\n    // NOTE 1: we assume the parameter broadcastedIndices is valid. ie. it should have the same length as the\n    // broadcasted shape, and for each dimension the index should not be out of range.\n    // NOTE 2: we assume the parameter originalIndices has the same length as the originalShape\n    const dimOffset = broadcastedIndices.length - originalShape.length;\n    for (let i = 0; i < originalShape.length; i++) {\n      originalIndices[i] = broadcastedIndices[dimOffset + i] % originalShape[i];\n    }\n  }\n\n  /**\n   * Perform the broadcasting operation on the specific operator\n   * @param a The input tensor A\n   * @param b The input tensor B\n   * @param op The operator lambda function\n   * @param inplace Whether to write the result back to A.\n   * @returns The result tensor, or undefined if input not broadcastable.\n   */\n  static calc(\n    a: Tensor,\n    b: Tensor,\n    op: (a: string | number, b: string | number) => string | number,\n    inplace: boolean,\n    resultType?: Tensor.DataType,\n  ): Tensor | undefined {\n    const outputShape = BroadcastUtil.calcShape(a.dims, b.dims);\n\n    if (outputShape) {\n      if (inplace && !ShapeUtil.areEqual(outputShape, a.dims)) {\n        // B is not broadcastable to A, failed to calculate inplace.\n        return undefined;\n      }\n\n      const size = ShapeUtil.size(outputShape);\n      const c = inplace ? a : new Tensor(outputShape, resultType || a.type);\n\n      // both inputs are scalars\n      if (outputShape.length === 0) {\n        c.set([], op(a.get([]) as number, b.get([]) as number));\n      }\n\n      // at least one input is a non-scalar\n      else {\n        const outputIndices = new Array<number>(outputShape.length);\n        const originalIndicesA = new Array(a.dims.length);\n        const originalIndicesB = new Array(b.dims.length);\n        let valA: string | number = 0;\n        let valB: string | number = 0;\n        let isAScalar = false;\n        let isBScalar = false;\n        if (a.dims.length === 0) {\n          valA = a.get([]) as number;\n          isAScalar = true;\n        }\n        if (b.dims.length === 0) {\n          valB = b.get([]) as number;\n          isBScalar = true;\n        }\n        let rest: number;\n        for (let i = 0; i < size; i++) {\n          // traversal indices\n          rest = i;\n          for (let j = outputShape.length - 1; j >= 0; j--) {\n            outputIndices[j] = rest % outputShape[j];\n            rest = Math.floor(rest / outputShape[j]);\n          }\n\n          if (!isAScalar) {\n            // map outputIndices (which is actually broadcasted) to the originalIndices\n            BroadcastUtil.fillIndex(outputIndices, a.dims, originalIndicesA);\n            valA = a.get(originalIndicesA) as number;\n          }\n          if (!isBScalar) {\n            BroadcastUtil.fillIndex(outputIndices, b.dims, originalIndicesB);\n            valB = b.get(originalIndicesB) as number;\n          }\n\n          c.set(outputIndices, op(valA, valB));\n        }\n      }\n\n      return c;\n    }\n\n    return undefined;\n  }\n\n  /**\n   * Determine if a shape is unidirectional broadcastable to another shape\n   * @param shape The input shape\n   * @param finalShape The desired shape after broadcasting\n   */\n  static isValidBroadcast(shape: readonly number[], finalShape: readonly number[]): boolean {\n    // align shape to the right\n    const inputRank = shape.length;\n    const finalRank = finalShape.length;\n    if (inputRank > finalRank) {\n      return false;\n    }\n    for (let i = 1; i <= inputRank; i++) {\n      if (shape[inputRank - i] !== 1 && shape[inputRank - i] !== finalShape[finalRank - i]) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  /**\n   * Determine the broadcasted dims in input shape based on the given output shape.\n   * Note that this function only returns the broadcasted dims.\n   * @param inputShape The input shape\n   * @param outputShape The output shape\n   * @returns The broadcasted dims in input shape.\n   */\n  static getBroadcastDims(inputShape: readonly number[], outputShape: readonly number[]): number[] {\n    const inRank = inputShape.length;\n    const dims: number[] = [];\n    for (let i = 0; i < inRank; i++) {\n      const dim = inRank - 1 - i;\n      const a = inputShape[dim] || 1;\n      const b = outputShape[outputShape.length - 1 - i] || 1;\n      if (b > 1 && a === 1) {\n        dims.unshift(dim);\n      }\n    }\n    return dims;\n  }\n}\n\n// copy array helper\n// mimics memcpy as much as possible\nexport function arrayCopyHelper(\n  target: number[] | Tensor.NumberType,\n  source: number[] | Tensor.NumberType,\n  targetIndex: number,\n  sourceIndex: number,\n  blockSize: number,\n) {\n  if (sourceIndex < 0 || sourceIndex >= source.length) {\n    throw new Error('sourceIndex out of bounds');\n  }\n  if (targetIndex < 0 || targetIndex >= target.length) {\n    throw new Error('targetIndex out of bounds');\n  }\n  if (sourceIndex + blockSize > source.length) {\n    throw new Error('source indices to be copied are outside bounds');\n  }\n  if (targetIndex + blockSize > target.length) {\n    throw new Error('target array is too small to hold result');\n  }\n\n  for (let offset = 0; offset < blockSize; offset++) {\n    target[targetIndex + offset] = source[sourceIndex + offset];\n  }\n}\n\nexport class GemmUtil {\n  // will make sure input shapes are compatible for this op\n  // and return back the shape of the output in the form of a tuple\n  // will throw exception if the input shapes are not compatible\n  static getShapeOfGemmResult(\n    leftShape: readonly number[],\n    transLeft: boolean,\n    rightShape: readonly number[],\n    transRight: boolean,\n    biasShape?: readonly number[],\n  ): readonly number[] {\n    if (leftShape.length !== 2 || rightShape.length !== 2) {\n      throw new Error('shape need to be of size 2');\n    }\n\n    let M: number;\n    let K: number;\n    let N: number;\n\n    if (transLeft) {\n      M = leftShape[1];\n      K = leftShape[0];\n    } else {\n      M = leftShape[0];\n      K = leftShape[1];\n    }\n\n    let kDim = -1;\n\n    if (transRight) {\n      N = rightShape[0];\n      kDim = 1;\n    } else {\n      N = rightShape[1];\n      kDim = 0;\n    }\n\n    if (rightShape[kDim] !== K) {\n      throw new Error('dimension mismatch');\n    }\n\n    if (M <= 0 || N <= 0 || K <= 0) {\n      throw new Error('invalid shape specified');\n    }\n\n    if (biasShape && !BroadcastUtil.isValidBroadcast(biasShape, [M, N])) {\n      throw new Error('gemm: invalid bias shape for broadcast');\n    }\n\n    return [M, N, K];\n  }\n}\n\nexport class ProtoUtil {\n  static tensorDataTypeFromProto(typeProto: onnx.TensorProto.DataType | ortFbs.TensorDataType): Tensor.DataType {\n    switch (typeProto) {\n      case onnx.TensorProto.DataType.INT8:\n        return 'int8';\n      case onnx.TensorProto.DataType.UINT8:\n        return 'uint8';\n      case onnx.TensorProto.DataType.BOOL:\n        return 'bool';\n      case onnx.TensorProto.DataType.INT16:\n        return 'int16';\n      case onnx.TensorProto.DataType.UINT16:\n        return 'uint16';\n      case onnx.TensorProto.DataType.INT32:\n        return 'int32';\n      case onnx.TensorProto.DataType.UINT32:\n        return 'uint32';\n      case onnx.TensorProto.DataType.FLOAT:\n        return 'float32';\n      case onnx.TensorProto.DataType.DOUBLE:\n        return 'float64';\n      case onnx.TensorProto.DataType.STRING:\n        return 'string';\n\n      // For INT64/UINT64, reduce their value to 32-bits.\n      // Should throw exception when overflow\n      case onnx.TensorProto.DataType.INT64:\n        return 'int32';\n      case onnx.TensorProto.DataType.UINT64:\n        return 'uint32';\n\n      default:\n        throw new Error(`unsupported data type: ${onnx.TensorProto.DataType[typeProto]}`);\n    }\n  }\n\n  static tensorDataTypeStringToEnum(type: string): onnx.TensorProto.DataType {\n    switch (type) {\n      case 'int8':\n        return onnx.TensorProto.DataType.INT8;\n      case 'uint8':\n        return onnx.TensorProto.DataType.UINT8;\n      case 'bool':\n        return onnx.TensorProto.DataType.BOOL;\n      case 'int16':\n        return onnx.TensorProto.DataType.INT16;\n      case 'uint16':\n        return onnx.TensorProto.DataType.UINT16;\n      case 'int32':\n        return onnx.TensorProto.DataType.INT32;\n      case 'uint32':\n        return onnx.TensorProto.DataType.UINT32;\n      case 'float32':\n        return onnx.TensorProto.DataType.FLOAT;\n      case 'float64':\n        return onnx.TensorProto.DataType.DOUBLE;\n      case 'string':\n        return onnx.TensorProto.DataType.STRING;\n      case 'int64':\n        return onnx.TensorProto.DataType.INT64;\n      case 'uint64':\n        return onnx.TensorProto.DataType.UINT64;\n\n      default:\n        throw new Error(`unsupported data type: ${type}`);\n    }\n  }\n\n  static tensorDimsFromProto(dims: Array<number | Long>): number[] {\n    // get rid of Long type for dims\n    return dims.map((d) => (Long.isLong(d) ? d.toNumber() : d));\n  }\n\n  static tensorValueTypeFromProto(valueType: onnx.TypeProto.ITensor): Graph.ValueType {\n    return {\n      tensorType: ProtoUtil.tensorDataTypeFromProto(valueType.elemType!),\n      shape: { dims: ProtoUtil.tensorDimsFromProto(valueType.shape!.dim!.map((d) => d.dimValue!)) },\n    };\n  }\n\n  static tensorDimsFromORTFormat(tensor: ortFbs.Tensor) {\n    const dims = [];\n    for (let i = 0; i < tensor.dimsLength(); i++) {\n      dims.push(LongUtil.longToNumber(tensor.dims(i)!));\n    }\n    return dims;\n  }\n\n  static tensorAttributesFromORTFormat(node: ortFbs.Node) {\n    const attributes = [];\n    for (let i = 0; i < node.attributesLength(); i++) {\n      attributes.push(node.attributes(i)!);\n    }\n    return attributes;\n  }\n}\n\nexport class LongUtil {\n  // This function is called to get a number from long type of data for attribute, dim, and ir version,\n  // which values are signed integers.\n  // To make it more generic, add an optional parameter to convert to a unsigned number.\n  static longToNumber(n: Long | bigint | number) {\n    if (Long.isLong(n)) {\n      return n.toNumber();\n    } else if (typeof n === 'bigint') {\n      return Number(n);\n    }\n    return n;\n  }\n  static isLong(n: unknown) {\n    return Long.isLong(n) || typeof n === 'bigint';\n  }\n}\n\nexport class ShapeUtil {\n  static size(dims: readonly number[]): number {\n    return ShapeUtil.getSizeFromDimensionRange(dims, 0, dims.length);\n  }\n\n  // `axis` inclusive\n  static sizeFromDimension(dims: readonly number[], axis: number): number {\n    if (axis < 0 || axis > dims.length) {\n      throw new Error(`invalid dimension of ${axis} for sizeFromDimension as Tensor has ${dims.length} dimensions.`);\n    }\n    return ShapeUtil.getSizeFromDimensionRange(dims, axis, dims.length);\n  }\n\n  // `axis` exclusive\n  static sizeToDimension(dims: readonly number[], axis: number): number {\n    if (axis < 0 || axis > dims.length) {\n      throw new Error(`invalid dimension of ${axis} for sizeToDimension as Tensor has ${dims.length} dimensions.`);\n    }\n    return ShapeUtil.getSizeFromDimensionRange(dims, 0, axis);\n  }\n\n  static getSizeFromDimensionRange(dims: readonly number[], start: number, end: number): number {\n    let size = 1;\n    for (let i = start; i < end; i++) {\n      // safety check as this method is called by multiple other methods requiring size.\n      // size cannot be 0 or negative.\n      if (dims[i] <= 0) {\n        throw new Error(\n          'cannot get valid size from specified dimension range. Most likely the range contains 0 or negative values in them.',\n        );\n      }\n      size *= dims[i];\n    }\n    return size;\n  }\n\n  static computeStrides(dims: readonly number[]): readonly number[] {\n    const rank = dims.length;\n    if (rank === 0) {\n      return [];\n    } else if (rank === 1) {\n      return [1];\n    }\n    const strides = new Array(rank);\n    strides[rank - 1] = 1;\n    strides[rank - 2] = dims[rank - 1];\n    for (let i = rank - 3; i >= 0; --i) {\n      strides[i] = strides[i + 1] * dims[i + 1];\n    }\n    return strides;\n  }\n\n  static transpose(dims: readonly number[]): readonly number[] {\n    const copy = dims.slice();\n    return copy.reverse();\n  }\n\n  static indicesToOffset(indices: readonly number[], strides: readonly number[], axis?: number): number {\n    if (axis === undefined) {\n      axis = indices.length;\n    }\n    let offset = 0;\n    for (let i = 0; i < axis; ++i) {\n      offset += strides[i] * indices[i];\n    }\n    return offset;\n  }\n\n  static offsetToIndices(offset: number, strides: readonly number[]): readonly number[] {\n    const rank = strides.length;\n    if (rank === 0) {\n      return [];\n    } else if (rank === 1) {\n      return [offset * strides[0]];\n    }\n    const indices: number[] = new Array(strides.length);\n    for (let i = 0; i < indices.length - 1; ++i) {\n      indices[i] = Math.floor(offset / strides[i]);\n      offset -= indices[i] * strides[i];\n    }\n    indices[indices.length - 1] = offset;\n    return indices;\n  }\n\n  /**\n   * normalize axis of range [-r, r) into [0, r).\n   */\n  static normalizeAxis(axis: number, tensorRank: number): number {\n    if (axis < -tensorRank && axis >= tensorRank) {\n      throw new Error('unsupported axis for this operation.');\n    }\n    return axis < 0 ? axis + tensorRank : axis;\n  }\n\n  static normalizeAxes(axes: readonly number[], tensorRank: number): number[] {\n    return axes.map((x) => this.normalizeAxis(x, tensorRank));\n  }\n\n  // Increment an index into a tensor (in lexicographic\n  // ordering), wrapping around the specified upper_bound.\n  /**\n   * Increment an index into a tensor (in lexicographic ordering), wrapping around the specified upper_bound.\n   * @param index Given index to increment (Will be mutated)\n   * @param dims The dimensions of the tensor for which the given index corresponds to\n   * @param axisToIncrementOn The 1-indexed axis to increment on. If undefined, axisToIncrementOn == rank\n   */\n  static incrementIndex(index: number[], dims: readonly number[], axisToIncrementOn?: number) {\n    if (dims.length === 0 || index.length === 0) {\n      throw new Error('Index incrementing unsupported for scalar Tensor');\n    }\n    if (axisToIncrementOn === undefined) {\n      axisToIncrementOn = dims.length;\n    } else {\n      if (axisToIncrementOn <= 0 || axisToIncrementOn > dims.length) {\n        throw new Error('Incorrect axis to increment on');\n      }\n    }\n\n    for (let k = axisToIncrementOn - 1; k >= 0; --k) {\n      index[k]++;\n      if (index[k] < dims[k]) {\n        break;\n      }\n      index[k] = 0;\n    }\n  }\n\n  /**\n   * Produces a new dimensions array based on the values in the 'originalDimensions' and 'shape' array\n   * Used in Reshape\n   * @param originalDims Original Shape array\n   * @param shapeHints array containing values to compute the new dimensions\n   * For example:\n   * originalDims = [2,2] and shapeHints = [0,-1] will return [2,2]\n   * originalDims = [2,2] and shapeHints = [4] will return [4]\n   * originalDims = [2,2] and shapeHints = [5] will throw an exception\n   * https://github.com/onnx/onnx/blob/main/docs/Operators.md#Reshape\n   */\n\n  static calculateReshapedDims(originalDims: readonly number[], shapeHints: ArrayLike<number>): number[] {\n    // reshape to a Scalar Tensor\n    if (shapeHints.length === 0) {\n      if (originalDims.length === 0 || ShapeUtil.size(originalDims) === 1) {\n        return [];\n      } else {\n        throw new Error('cannot reshape to a scalar Tensor');\n      }\n    }\n\n    const nDims = shapeHints.length;\n    const reshapedDims = new Array<number>(nDims);\n    let unknownDimension = -1;\n    let newTensorSize = 1;\n    for (let i = 0; i < nDims; i++) {\n      if (shapeHints[i] < -1) {\n        throw new Error('a dimension in shape hints cannot be less than -1');\n      }\n      if (shapeHints[i] === -1) {\n        if (unknownDimension !== -1) {\n          throw new Error('at most one dimension in shape hints can be -1');\n        }\n        unknownDimension = i;\n      } else {\n        if (shapeHints[i] === 0) {\n          if (i >= originalDims.length) {\n            throw new Error('the dimension with value zero exceeds the dimension size of the input tensor');\n          }\n          reshapedDims[i] = originalDims[i];\n        } else {\n          reshapedDims[i] = shapeHints[i];\n        }\n        newTensorSize *= reshapedDims[i];\n      }\n    }\n\n    const oldTensorSize = ShapeUtil.size(originalDims);\n    if (unknownDimension !== -1) {\n      if (oldTensorSize % newTensorSize !== 0) {\n        throw new Error(\n          `the input tensor cannot be reshaped to the requested shape. Input shape: [${\n            originalDims\n          }] Output shape: [${shapeHints}]`,\n        );\n      }\n      reshapedDims[unknownDimension] = oldTensorSize / newTensorSize;\n    }\n    // validate sizes from originalDims and reshapedDims match\n    else {\n      if (newTensorSize !== oldTensorSize) {\n        throw new Error(\"reshapedDims and originalDims don't have matching sizes\");\n      }\n    }\n    return reshapedDims;\n  }\n\n  /**\n   * Sorts a given array based on the indices in the Perm array\n   * Used in Transpose\n   * @param a Array to be sorted such as dims or strides\n   * @param perm Perm given; if null a will be reversed\n   */\n  static sortBasedOnPerm(a: readonly number[], perm?: readonly number[]): readonly number[] {\n    if (perm) {\n      return perm.map((v) => a[v]);\n    } else {\n      return a.slice().reverse();\n    }\n  }\n\n  /**\n   * Pads a given shape according to the padding values\n   * @param dims shape of the Tensor to be padded\n   * @param pad pad values\n   */\n  static padShape(dims: readonly number[], pad: readonly number[]): readonly number[] {\n    const rank = dims.length;\n    return dims.map((v, i) => v + pad[i] + pad[i + rank]);\n  }\n\n  /**\n   * Determines if the two shapes are identical\n   * @param shape1\n   * @param shape2\n   */\n  static areEqual(shape1: readonly number[], shape2: readonly number[]): boolean {\n    if (shape1.length !== shape2.length) {\n      return false;\n    }\n    return shape1.every((v, i) => v === shape2[i]);\n  }\n\n  /**\n   * Validates if the given `dims` or `shape` is valid in ONNX.js context and returns data size\n   * @param dims - input `dims` that needs to be checked\n   */\n  static validateDimsAndCalcSize(dims: readonly number[]): number {\n    if (dims.length > 6) {\n      throw new TypeError('Only rank 0 to 6 is supported for tensor shape.');\n    }\n    let size = 1;\n    for (const n of dims) {\n      if (!Number.isInteger(n)) {\n        throw new TypeError(`Invalid shape: ${n} is not an integer`);\n      }\n      if (n < 0 || n > 2147483647) {\n        throw new TypeError(`Invalid shape: length ${n} is not allowed`);\n      }\n      size *= n;\n    }\n    return size;\n  }\n\n  /**\n   * Determines the shape of output tensor y = flatten(x, axis)\n   * @param dims - shape of input tensor\n   * @param axis - flatten axis, in the range [-r, r]\n   */\n  static flattenShape(dims: readonly number[], axis: number): readonly number[] {\n    if (axis < 0) {\n      axis += dims.length;\n    }\n    const total = dims.reduce((x, y) => x * y, 1);\n    const right = dims.slice(axis).reduce((x, y) => x * y, 1);\n    const outputDims = [total / right, right];\n\n    return outputDims;\n  }\n\n  /**\n   * Determines the shape of output tensor y = squeeze(x, axes)\n   * @param dims - shape of input tensor\n   * @param axes - squeeze axes\n   */\n  static squeezeShape(dims: readonly number[], axes: readonly number[]): readonly number[] {\n    const outputDims = new Array<number>();\n\n    // sanity check\n    axes = ShapeUtil.normalizeAxes(axes, dims.length);\n\n    for (let i = 0; i < dims.length; i++) {\n      const inSqueezeList = axes.indexOf(i) >= 0;\n      if (inSqueezeList && dims[i] !== 1) {\n        throw new Error('squeeze an axis of size different than 1');\n      }\n\n      if ((axes.length === 0 && dims[i] > 1) || (axes.length > 0 && !inSqueezeList)) {\n        outputDims.push(dims[i]);\n      }\n    }\n\n    return outputDims;\n  }\n\n  /**\n   * Determines the shape of output tensor y = unsqueeze(x, axes)\n   * @param dims - shape of input tensor\n   * @param axes - unsqueeze axes\n   */\n  static unsqueezeShape(dims: readonly number[], axes: readonly number[]): readonly number[] {\n    const outputDims = new Array<number>(dims.length + axes.length);\n\n    // initialize the array elements to 0\n    outputDims.fill(0);\n\n    // set all axes indices to 1 in outputDims and check for duplicates\n    for (let i = 0; i < axes.length; i++) {\n      const axis = ShapeUtil.normalizeAxis(axes[i], outputDims.length);\n      if (axis >= outputDims.length) {\n        throw new Error(\"'axes' has an out of range axis\");\n      }\n      if (outputDims[axis] !== 0) {\n        throw new Error(\"'axes' has a duplicate axis\");\n      }\n\n      outputDims[axis] = 1;\n    }\n\n    // fill in the zero entries of outputDims with the input tensor's shape\n    let inputDimsIterator = 0;\n    for (let i = 0; i < outputDims.length; i++) {\n      if (outputDims[i] === 0) {\n        outputDims[i] = dims[inputDimsIterator++];\n      }\n    }\n\n    // sanity check assertion. 'inputDimsIterator'\n    // should be equal to the length of 'dims'\n    if (inputDimsIterator !== dims.length) {\n      throw new Error('the unsqueezed dimension could not be established');\n    }\n\n    return outputDims;\n  }\n}\n\n// bunch of helper methods that do a variety of math operations\nexport class MathUtil {\n  // y = (x*x) + y\n  static sqr(\n    target: number[] | Tensor.NumberType,\n    source: number[] | Tensor.NumberType,\n    targetIndex: number,\n    sourceIndex: number,\n    blockSize: number,\n  ) {\n    if (sourceIndex < 0 || sourceIndex >= source.length) {\n      throw new Error('sourceIndex out of bounds');\n    }\n    if (targetIndex < 0 || targetIndex >= target.length) {\n      throw new Error('targetIndex out of bounds');\n    }\n    if (sourceIndex + blockSize > source.length) {\n      throw new Error('source indices to be copied are outside bounds');\n    }\n    if (targetIndex + blockSize > target.length) {\n      throw new Error('target array is too small to hold result');\n    }\n\n    for (let offset = 0; offset < blockSize; offset++) {\n      target[targetIndex + offset] += Math.pow(source[sourceIndex + offset], 2);\n    }\n  }\n\n  // y = ax + y\n  static axpy(\n    target: number[] | Tensor.NumberType,\n    source: number[] | Tensor.NumberType,\n    targetIndex: number,\n    sourceIndex: number,\n    blockSize: number,\n    alpha: number,\n  ) {\n    if (sourceIndex < 0 || sourceIndex >= source.length) {\n      throw new Error('sourceIndex out of bounds');\n    }\n    if (targetIndex < 0 || targetIndex >= target.length) {\n      throw new Error('targetIndex out of bounds');\n    }\n    if (sourceIndex + blockSize > source.length) {\n      throw new Error('source indices to be copied are outside bounds');\n    }\n    if (targetIndex + blockSize > target.length) {\n      throw new Error('target array is too small to hold result');\n    }\n\n    for (let offset = 0; offset < blockSize; offset++) {\n      target[targetIndex + offset] += alpha * source[sourceIndex + offset];\n    }\n  }\n\n  // y = pow(x, b)\n  static powx(\n    target: number[] | Tensor.NumberType,\n    source: number[] | Tensor.NumberType,\n    targetIndex: number,\n    sourceIndex: number,\n    blockSize: number,\n    b: number,\n  ) {\n    if (sourceIndex < 0 || sourceIndex >= source.length) {\n      throw new Error('sourceIndex out of bounds');\n    }\n    if (targetIndex < 0 || targetIndex >= target.length) {\n      throw new Error('targetIndex out of bounds');\n    }\n    if (sourceIndex + blockSize > source.length) {\n      throw new Error('source indices to be copied are outside bounds');\n    }\n    if (targetIndex + blockSize > target.length) {\n      throw new Error('target array is too small to hold result');\n    }\n\n    for (let offset = 0; offset < blockSize; offset++) {\n      target[targetIndex + offset] = Math.pow(source[sourceIndex + offset], b);\n    }\n  }\n\n  // y = x * y\n  static mul(\n    target: number[] | Tensor.NumberType,\n    source: number[] | Tensor.NumberType,\n    targetIndex: number,\n    sourceIndex: number,\n    blockSize: number,\n  ) {\n    if (sourceIndex < 0 || sourceIndex >= source.length) {\n      throw new Error('sourceIndex out of bounds');\n    }\n    if (targetIndex < 0 || targetIndex >= target.length) {\n      throw new Error('targetIndex out of bounds');\n    }\n    if (sourceIndex + blockSize > source.length) {\n      throw new Error('source indices to be copied are outside bounds');\n    }\n    if (targetIndex + blockSize > target.length) {\n      throw new Error('target array is too small to hold result');\n    }\n\n    for (let offset = 0; offset < blockSize; offset++) {\n      target[targetIndex + offset] = source[sourceIndex + offset] * target[targetIndex + offset];\n    }\n  }\n}\n\nexport class SplitUtil {\n  /**\n   * Calculates new Shapes from existing one and the splits given along the axis provides\n   * @param dims Shape of the Tensor to be splitted into two or more Shapes\n   * @param axis The dimension along which the Tensor will be split\n   * @param splits Offsets for the start of each split\n   */\n  static splitShape(\n    dims: readonly number[],\n    axis: number,\n    split: number[],\n    numOutputs?: number,\n  ): [number[][], number[]] {\n    if (split.length === 0) {\n      if (!numOutputs) {\n        throw new Error(\"need to know number of outputs when the 'split' attribute is not specified\");\n      }\n      SplitUtil.determineSplit(dims[axis], numOutputs, split);\n    }\n\n    const shapes: number[][] = [];\n    const offsets = [0];\n    for (let i = 0; i < split.length; ++i) {\n      if (i !== 0) {\n        offsets.push(offsets[i - 1] + split[i - 1]);\n      }\n      const shape = dims.slice();\n      shape[axis] = split[i];\n      shapes.push(shape);\n    }\n    return [shapes, offsets];\n  }\n\n  static determineSplit(numElementsAlongAxis: number, numOutputs: number, split: number[]) {\n    // If 'split' is not specified by the user, we need to partition the number of elements equally among the outputs\n    if (numElementsAlongAxis % numOutputs !== 0) {\n      throw new Error('cannot split tensor to equal sized parts');\n    }\n    for (let i = 0; i < numOutputs; ++i) {\n      split.push(numElementsAlongAxis / numOutputs);\n    }\n  }\n}\n\nexport class ReduceUtil {\n  /**\n   * Perform reduce operations on the specific operator\n   * @param a Input tensor data\n   * @param axes The dimensions along which the Tensor will be reduced\n   * @param keepdims If set to true, the axes which are reduced are left in the\n   *    result as dimensions with size one.\n   * @param op1 The operation to be performed on each element in the tensor\n   * @param op2 The operation to be performed between elements in the tensor\n   */\n  static calcReduce(\n    a: Tensor,\n    axes: number[],\n    keepdims: boolean,\n    op1: (b: number) => number,\n    op2: (a: number, b: number) => number,\n  ): Tensor {\n    const dims = a.dims.slice(0);\n    // if axes is not set, perform reduce on all axes\n    if (axes.length === 0) {\n      dims.forEach((_d, ind) => axes.push(ind));\n    }\n    // get a temporary broadcastable output shape\n    const outputDims = ReduceUtil.calcReduceShape(dims, axes, true);\n\n    // loop through the output and calculate result one by one\n    const size = ShapeUtil.size(outputDims);\n    const y = new Tensor(outputDims, a.type);\n    const strides = ShapeUtil.computeStrides(outputDims);\n    const inputStrides = ShapeUtil.computeStrides(dims);\n    const indicesY = new Array(dims.length);\n    for (let i = 0; i < size; i++) {\n      const indices = ShapeUtil.offsetToIndices(i, strides);\n      // map index\n      BroadcastUtil.fillIndex(indices, dims, indicesY);\n      y.set(\n        indices,\n        ReduceUtil.calcReduceByAxis(\n          a.numberData,\n          axes,\n          dims,\n          0,\n          ShapeUtil.indicesToOffset(indicesY, inputStrides),\n          op1,\n          op2,\n        ),\n      );\n    }\n\n    if (keepdims) {\n      return y;\n    } else {\n      // keepdims == 0, calculate the expected shape\n      return new Tensor(\n        ReduceUtil.calcReduceShape(dims, axes, keepdims),\n        y.type,\n        undefined,\n        undefined,\n        y.data,\n        y.dataId,\n      );\n    }\n  }\n\n  /**\n   * Perform reduce operations on the specific operator on specific axes\n   * @param a Input tensor data\n   * @param axes The dimensions along which the Tensor will be reduced\n   * @param dims The input dimension.\n   * @param curAxisInd Index in axes specifying the current dimension along\n   *      which the tensor will be reduced\n   * @param pos The current index of element to perform operation\n   * @param op1 The operation to be performed on each element in the tensor\n   * @param op2 The operation to be performed between elements in the tensor\n   */\n  static calcReduceByAxis(\n    input: Tensor.NumberType,\n    axes: number[],\n    dims: number[],\n    curAxisInd: number,\n    pos: number,\n    op1: (b: number) => number,\n    op2: (a: number, b: number) => number,\n  ): number {\n    let res = 0;\n    if (curAxisInd >= axes.length) {\n      return op1(input[pos]);\n    }\n    const axis = axes[curAxisInd];\n    const step = axis >= dims.length ? 1 : ShapeUtil.size(dims.slice(axis + 1));\n    for (let i = 0; i < dims[axis]; i++) {\n      res =\n        i === 0\n          ? ReduceUtil.calcReduceByAxis(input, axes, dims, curAxisInd + 1, pos, op1, op2)\n          : op2(res, ReduceUtil.calcReduceByAxis(input, axes, dims, curAxisInd + 1, pos, op1, op2));\n      pos += step;\n    }\n    return res;\n  }\n\n  /**\n   * Calculate the expected shape of a reduce operation\n   * @param dims The input tensor dimension\n   * @param axes The dimensions along which the Tensor will be reduced\n   * @param keepdims If set to true, the axes which are reduced are left in the\n   *    result as dimensions with size one.\n   */\n  static calcReduceShape(dims: readonly number[], axes: readonly number[], keepDims: boolean): number[] {\n    const outputDims = dims.slice();\n    for (let i = 0; i < axes.length; i++) {\n      if (keepDims) {\n        outputDims[axes[i]] = 1;\n      } else {\n        outputDims[axes[i]] = 0;\n      }\n    }\n    return outputDims.filter((dim) => dim !== 0);\n  }\n}\n\nexport class PoolConvUtil {\n  /**\n   * Adjust the kernel, strides, pads to correct rank. Set to default value if not present\n   * @param isGlobalOperator If true, perform global pooling.\n   * @param inputDims The input tensor dimension.\n   * @param kernelShape The size of the kernel along each axis.\n   * @param strides Stride along each axis.\n   * @param dilations Dilation along each axis.\n   * @param pads Padding for the beginning and ending along each axis.\n   */\n  static adjustPoolAttributes(\n    isGlobalOperator: boolean,\n    inputDims: readonly number[],\n    kernelShape: number[],\n    strides: number[],\n    dilations: number[],\n    pads: number[],\n  ) {\n    if (!isGlobalOperator && kernelShape.length !== inputDims.length - 2) {\n      throw new Error('length of specified kernel shapes should be 2 less than length of input dimensions');\n    }\n\n    if (isGlobalOperator) {\n      // adjust kernel shape to cover the input dims\n      for (let dim = 0; dim < inputDims.length - 2; dim++) {\n        if (dim >= kernelShape.length) {\n          kernelShape.push(inputDims[dim + 2]);\n        } else {\n          kernelShape[dim] = inputDims[dim + 2];\n        }\n      }\n    }\n\n    // adjust strides length to match kernel shape length\n    for (let dim = 0; dim < kernelShape.length; dim++) {\n      if (dim < strides.length) {\n        if (strides[dim] < 0) {\n          throw new Error('strides should be greater than or equal to 1');\n        }\n      } else {\n        strides.push(1);\n      }\n    }\n\n    // adjust dilation value\n    for (let dim = 0; dim < kernelShape.length; dim++) {\n      if (dim < dilations.length) {\n        if (dilations[dim] < 0) {\n          throw new Error('dilations should be greater than or equal to 1');\n        }\n      } else {\n        dilations.push(1);\n      }\n    }\n\n    // adjust pads length to match 2 * kernel shape length\n    for (let dim = 0; dim < kernelShape.length * 2; dim++) {\n      if (dim < pads.length) {\n        if (pads[dim] < 0) {\n          throw new Error('pad should be greater than or equal to 1');\n        }\n      } else {\n        pads.push(0);\n      }\n    }\n\n    // sanity checks for values in kernel shapes and pads\n    for (let dim = 0; dim < kernelShape.length; dim++) {\n      if (kernelShape[dim] <= 0) {\n        throw new Error('kernel shapes need to be greater than 0');\n      }\n\n      if (pads[dim] >= kernelShape[dim] || pads[dim + kernelShape.length] >= kernelShape[dim]) {\n        throw new Error('pads should be smaller than kernel');\n      }\n    }\n  }\n\n  // adjust pad values based on 'autoPad' attribute\n  static adjustPadsBasedOnAutoPad(\n    inputDims: readonly number[],\n    strides: readonly number[],\n    dilations: readonly number[],\n    kernelShape: readonly number[],\n    pads: number[],\n    autoPad?: string,\n  ) {\n    if (!autoPad) {\n      return;\n    }\n\n    if (pads.length !== 2 * (inputDims.length - 2)) {\n      throw new Error('length of pads should be twice the length of data dimensions');\n    }\n\n    if (strides.length !== inputDims.length - 2) {\n      throw new Error('length of strides should be the length of data dimensions');\n    }\n\n    if (kernelShape.length !== inputDims.length - 2) {\n      throw new Error('length of kernel shapes should be the length of data dimensions');\n    }\n\n    for (let dim = 0; dim < inputDims.length - 2; dim++) {\n      PoolConvUtil.adjustPadAndReturnShape(\n        inputDims[dim + 2],\n        strides[dim],\n        dilations[dim],\n        kernelShape[dim],\n        pads,\n        dim,\n        dim + inputDims.length - 2,\n        autoPad,\n      );\n    }\n  }\n\n  /**\n   * Calculate the output shape for Pool ops based on input attributes. (Should be used only for Pool ops)\n   * @param isGlobalOperator If true, perform global pooling.\n   * @param inputDims The input tensor dimension. (inputs[0].dims)\n   * @param strides Stride along each axis.\n   * @param dilations Dilation along each axis.\n   * @param kernelShape The size of the kernel along each axis.\n   * @param pads Padding for the beginning and ending along each axis.\n   * @param autoPad DEPRECATED attribute supported for legacy models. Specifies how to implicitly calculate pads in each\n   *     dimension. Can take values NOTSET, SAME_UPPER, SAME_LOWER, or VALID.\n   * @param ceilMode When set to 1, use ceil() instead of floor() to compute the output spatial size (and apply the\n   *     \"shrink the last window if it starts entirely in padding\" rule). Defaults to 0 (floor).\n   */\n  static computePoolOutputShape(\n    isGlobalOperator: boolean,\n    inputDims: readonly number[],\n    strides: number[],\n    dilations: number[],\n    kernelShape: number[],\n    pads: number[],\n    autoPad?: string,\n    ceilMode = 0,\n  ): number[] {\n    if (inputDims.length <= 0) {\n      throw new Error('input shape must be of size greater than 0');\n    }\n\n    // Add batch size and number of channels of output\n    const outputDims = [inputDims[0], inputDims[1]];\n\n    PoolConvUtil.computeShapeHelper(\n      isGlobalOperator,\n      inputDims,\n      outputDims,\n      strides,\n      dilations,\n      kernelShape,\n      pads,\n      autoPad,\n      ceilMode,\n    );\n    return outputDims;\n  }\n\n  /**\n   * Calculate the output shape for Conv op based on input attributes. (Should be used only for Conv op)\n   * @param inputDims The input tensor dimension. (inputs[0].dims)\n   * @param filterDims The filter tensor dimension. (inputs[1].dims)\n   * @param strides Stride along each axis.\n   * @param kernelShape The size of the kernel along each axis.\n   * @param pads Padding for the beginning and ending along each axis.\n   * @param autoPad DEPRECATED attribute supported for legacy models. Specifies how to implicitly calculate pads in each\n   *     dimension. Can take values NOTSET, SAME_UPPER, SAME_LOWER, or VALID.\n   */\n  static computeConvOutputShape(\n    inputDims: readonly number[],\n    filterDims: readonly number[],\n    strides: number[],\n    dilations: number[],\n    kernelShape: number[],\n    pads: number[],\n    autoPad?: string,\n  ): number[] {\n    if (inputDims.length <= 0 || filterDims.length <= 0) {\n      throw new Error('invalid input tensor dims or invalid filter tensor dims');\n    }\n\n    // Add batch size and number of channels of output\n    const outputDims = [inputDims[0], filterDims[0]];\n\n    PoolConvUtil.computeShapeHelper(false, inputDims, outputDims, strides, dilations, kernelShape, pads, autoPad);\n    return outputDims;\n  }\n\n  // will compute output shapes for data dimensions ONLY (i.e.) no batch size and channels\n  // called by computePoolOutputShape() and computeConvOutputShape()\n  // adjust pads based on 'autoPad' attribute prior to shape computation\n  private static computeShapeHelper(\n    isGlobalOperator: boolean,\n    inputDims: readonly number[],\n    outputDims: number[],\n    strides: readonly number[],\n    dilations: readonly number[],\n    kernelShape: readonly number[],\n    pads: number[],\n    autoPad?: string,\n    ceilMode = 0,\n  ) {\n    if (isGlobalOperator) {\n      for (let dim = 0; dim < inputDims.length - 2; dim++) {\n        outputDims.push(1);\n      }\n    } else {\n      for (let dim = 0; dim < inputDims.length - 2; dim++) {\n        outputDims.push(\n          PoolConvUtil.adjustPadAndReturnShape(\n            inputDims[dim + 2],\n            strides[dim],\n            dilations[dim],\n            kernelShape[dim],\n            pads,\n            dim,\n            dim + inputDims.length - 2,\n            autoPad,\n            ceilMode,\n          ),\n        );\n      }\n    }\n  }\n\n  // Computes the output spatial size for a single dimension.\n  // Produces results identical to the C++ PoolAttributes::ComputeOutputSize\n  // (onnxruntime/core/providers/cpu/nn/pool_attributes.h), including the ceil_mode\n  // \"shrink the last window if it starts entirely in the trailing padding\" rule. The JS\n  // signature takes a pre-computed `numerator` (equal to `inSize + padHead + padTail - dkernel`,\n  // matching the C++ `in_size + pad_head + pad_tail - dilation * (kernel - 1) - 1`) instead of\n  // the raw pooling attributes, but the computed output size is the same.\n  // Keep in sync with the onnxjs/jsep copy.\n  // NOTE: In this onnxjs copy the ceilMode path exists for shape-test parity with the jsep copy;\n  // the onnxjs WebGL pooling caller (backends/webgl/ops/pool.ts) intentionally does NOT pass\n  // ceilMode (legacy path still throws on ceil_mode != 0), so it always uses the floor default.\n  private static computeOutputSize(\n    numerator: number,\n    stride: number,\n    inSize: number,\n    padHead: number,\n    ceilMode: number,\n  ): number {\n    let outSize = Math.floor(numerator / stride) + 1;\n    // Match C++ `ceil_mode == 1` exactly so out-of-spec ceil_mode values do not diverge.\n    if (ceilMode === 1) {\n      outSize = Math.ceil(numerator / stride) + 1;\n      // Ensure the last pooling window starts inside the image (ref: https://github.com/onnx/onnx/pull/5741).\n      // inSize and padHead are needed here to reconstruct the last window's start position.\n      if ((outSize - 1) * stride >= inSize + padHead) {\n        outSize -= 1;\n      }\n    }\n    return outSize;\n  }\n\n  // helper for computeShapeHelper() and adjustPadsBasedOnAutoPad()\n  // adjusts pad value for given 'autoPad' string and computes output shape along a particular dimension\n  private static adjustPadAndReturnShape(\n    inSize: number,\n    stride: number,\n    dilation: number,\n    kernel: number,\n    pads: number[],\n    padHeadIndex: number,\n    padTailIndex: number,\n    autoPad?: string,\n    ceilMode = 0,\n  ): number {\n    const dkernel = dilation * (kernel - 1) + 1;\n    if (autoPad && autoPad !== 'NOTSET') {\n      switch (autoPad) {\n        case 'VALID':\n          pads[padHeadIndex] = 0;\n          pads[padTailIndex] = 0;\n          return PoolConvUtil.computeOutputSize(inSize - dkernel, stride, inSize, 0, ceilMode);\n        case 'SAME_LOWER':\n        case 'SAME_UPPER':\n          if (dilation !== 1) {\n            throw new Error('Dilation not supported for SAME_UPPER or SAME_LOWER');\n          } else {\n            // Integer division to match C++ pool_attributes.h ComputeSizePadDilations; float division mis-rounds SAME_* pads.\n            const legacyTargetSize = Math.floor((inSize + stride - 1) / stride);\n            const padNeeded = (legacyTargetSize - 1) * stride + kernel - inSize;\n            pads[padHeadIndex] = autoPad === 'SAME_LOWER' ? Math.floor((padNeeded + 1) / 2) : Math.floor(padNeeded / 2);\n            pads[padTailIndex] = padNeeded - pads[padHeadIndex];\n            return PoolConvUtil.computeOutputSize(\n              inSize + pads[padHeadIndex] + pads[padTailIndex] - dkernel,\n              stride,\n              inSize,\n              pads[padHeadIndex],\n              ceilMode,\n            );\n          }\n        default:\n          throw new Error('Unsupported AutoPad type');\n      }\n    } else {\n      return PoolConvUtil.computeOutputSize(\n        inSize + pads[padHeadIndex] + pads[padTailIndex] - dkernel,\n        stride,\n        inSize,\n        pads[padHeadIndex],\n        ceilMode,\n      );\n    }\n  }\n}\n\nexport const MIN_CLIP = -3.4028234663852886e38;\nexport const MAX_CLIP = 3.4028234663852886e38;\n\nexport function decodeUtf8String(buffer: Uint8Array): string {\n  return new TextDecoder().decode(buffer);\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Guid } from 'guid-typescript';\nimport Long from 'long';\n\nimport * as ortFbs from './ort-schema/flatbuffers/ort-generated';\nimport { onnx } from './ort-schema/protobuf/onnx';\nimport { decodeUtf8String, ProtoUtil, ShapeUtil } from './util';\n\nexport declare namespace Tensor {\n  export interface DataTypeMap {\n    bool: Uint8Array;\n    float32: Float32Array;\n    float64: Float64Array;\n    string: string[];\n    int8: Int8Array;\n    uint8: Uint8Array;\n    int16: Int16Array;\n    uint16: Uint16Array;\n    int32: Int32Array;\n    uint32: Uint32Array;\n    int64: BigInt64Array;\n  }\n\n  export type DataType = keyof DataTypeMap;\n\n  export type StringType = Tensor.DataTypeMap['string'];\n  export type BooleanType = Tensor.DataTypeMap['bool'];\n  export type IntegerType =\n    | Tensor.DataTypeMap['int8']\n    | Tensor.DataTypeMap['uint8']\n    | Tensor.DataTypeMap['int16']\n    | Tensor.DataTypeMap['uint16']\n    | Tensor.DataTypeMap['int32']\n    | Tensor.DataTypeMap['uint32'];\n  export type FloatType = Tensor.DataTypeMap['float32'] | Tensor.DataTypeMap['float64'];\n  export type NumberType = BooleanType | IntegerType | FloatType;\n\n  export type Id = Guid;\n}\n\ntype TensorData = Tensor.DataTypeMap[Tensor.DataType];\n\ntype DataProvider = (id: Tensor.Id) => TensorData;\ntype AsyncDataProvider = (id: Tensor.Id) => Promise<TensorData>;\n\nexport class Tensor {\n  /**\n   * get the underlying tensor data\n   */\n  get data(): TensorData {\n    if (this.cache === undefined) {\n      const data = this.dataProvider!(this.dataId);\n      if (data.length !== this.size) {\n        throw new Error('Length of data provided by the Data Provider is inconsistent with the dims of this Tensor.');\n      }\n      this.cache = data;\n    }\n    return this.cache;\n  }\n\n  /**\n   * get the underlying string tensor data. Should only use when type is STRING\n   */\n  get stringData() {\n    if (this.type !== 'string') {\n      throw new TypeError('data type is not string');\n    }\n\n    return this.data as Tensor.StringType;\n  }\n\n  /**\n   * get the underlying integer tensor data. Should only use when type is one of the following: (UINT8, INT8, UINT16,\n   * INT16, INT32, UINT32, BOOL)\n   */\n  get integerData() {\n    switch (this.type) {\n      case 'uint8':\n      case 'int8':\n      case 'uint16':\n      case 'int16':\n      case 'int32':\n      case 'uint32':\n      case 'bool':\n        return this.data as Tensor.IntegerType;\n\n      default:\n        throw new TypeError('data type is not integer (uint8, int8, uint16, int16, int32, uint32, bool)');\n    }\n  }\n\n  /**\n   * get the underlying float tensor data. Should only use when type is one of the following: (FLOAT, DOUBLE)\n   */\n  get floatData() {\n    switch (this.type) {\n      case 'float32':\n      case 'float64':\n        return this.data as Tensor.FloatType;\n\n      default:\n        throw new TypeError('data type is not float (float32, float64)');\n    }\n  }\n\n  /**\n   * get the underlying number tensor data. Should only use when type is one of the following: (UINT8, INT8, UINT16,\n   * INT16, INT32, UINT32, BOOL, FLOAT, DOUBLE)\n   */\n  get numberData() {\n    if (this.type !== 'string') {\n      return this.data as Tensor.NumberType;\n    }\n    throw new TypeError('type cannot be non-number (string)');\n  }\n\n  /**\n   * get value of an element at the given indices\n   */\n  get(indices: readonly number[]): Tensor.DataTypeMap[Tensor.DataType][number] {\n    return this.data[ShapeUtil.indicesToOffset(indices, this.strides)];\n  }\n\n  /**\n   * set value of an element at the given indices\n   */\n  set(indices: readonly number[], value: Tensor.DataTypeMap[Tensor.DataType][number]) {\n    this.data[ShapeUtil.indicesToOffset(indices, this.strides)] = value;\n  }\n\n  /**\n   * get the underlying tensor data asynchronously\n   */\n  async getData(): Promise<TensorData> {\n    if (this.cache === undefined) {\n      this.cache = await this.asyncDataProvider!(this.dataId);\n    }\n    return this.cache;\n  }\n\n  /**\n   * get the number of elements in the tensor\n   */\n  public readonly size: number;\n\n  private _strides: readonly number[];\n  /**\n   * get the strides for each dimension\n   */\n  get strides(): readonly number[] {\n    if (!this._strides) {\n      this._strides = ShapeUtil.computeStrides(this.dims);\n    }\n    return this._strides;\n  }\n\n  constructor(\n    /**\n     * get the dimensions of the tensor\n     */\n    public readonly dims: readonly number[],\n    /**\n     * get the type of the tensor\n     */\n    public readonly type: Tensor.DataType,\n    private dataProvider?: DataProvider,\n    private asyncDataProvider?: AsyncDataProvider,\n    private cache?: TensorData,\n    /**\n     * get the data ID that used to map to a tensor data\n     */\n    public readonly dataId: Guid = Guid.create(),\n  ) {\n    this.size = ShapeUtil.validateDimsAndCalcSize(dims);\n    const size = this.size;\n    const empty = dataProvider === undefined && asyncDataProvider === undefined && cache === undefined;\n\n    if (cache !== undefined) {\n      if (cache.length !== size) {\n        throw new RangeError(\"Input dims doesn't match data length.\");\n      }\n    }\n\n    if (type === 'string') {\n      if (cache !== undefined && (!Array.isArray(cache) || !cache.every((i) => typeof i === 'string'))) {\n        throw new TypeError('cache should be a string array');\n      }\n\n      if (empty) {\n        this.cache = new Array<string>(size);\n      }\n    } else {\n      if (cache !== undefined) {\n        const constructor = dataviewConstructor(type);\n        if (!(cache instanceof constructor)) {\n          throw new TypeError(`cache should be type ${constructor.name}`);\n        }\n      }\n\n      if (empty) {\n        const buf = new ArrayBuffer(size * sizeof(type));\n        this.cache = createView(buf, type);\n      }\n    }\n  }\n\n  /**\n   * Construct new Tensor from a ONNX Tensor object\n   * @param tensorProto the ONNX Tensor\n   */\n  static fromProto(tensorProto: onnx.ITensorProto): Tensor {\n    if (!tensorProto) {\n      throw new Error('cannot construct Value from an empty tensor');\n    }\n    const type = ProtoUtil.tensorDataTypeFromProto(tensorProto.dataType!);\n    const dims = ProtoUtil.tensorDimsFromProto(tensorProto.dims!);\n\n    const value = new Tensor(dims, type);\n\n    if (type === 'string') {\n      // When it's STRING type, the value should always be stored in field\n      // 'stringData'\n      tensorProto.stringData!.forEach((str, i) => {\n        value.data[i] = decodeUtf8String(str);\n      });\n    } else if (\n      tensorProto.rawData &&\n      typeof tensorProto.rawData.byteLength === 'number' &&\n      tensorProto.rawData.byteLength > 0\n    ) {\n      // NOT considering segment for now (IMPORTANT)\n\n      // populate value from rawData\n      const dataDest = value.data;\n      const dataSource = new DataView(\n        tensorProto.rawData.buffer,\n        tensorProto.rawData.byteOffset,\n        tensorProto.rawData.byteLength,\n      );\n      const elementSize = sizeofProto(tensorProto.dataType!);\n      const length = tensorProto.rawData.byteLength / elementSize;\n\n      if (tensorProto.rawData.byteLength % elementSize !== 0) {\n        throw new Error('invalid buffer length');\n      }\n      if (dataDest.length !== length) {\n        throw new Error('buffer length mismatch');\n      }\n\n      for (let i = 0; i < length; i++) {\n        const n = readProto(dataSource, tensorProto.dataType!, i * elementSize);\n        dataDest[i] = n;\n      }\n    } else {\n      // populate value from array\n      let array: Array<number | Long>;\n      switch (tensorProto.dataType) {\n        case onnx.TensorProto.DataType.FLOAT:\n          array = tensorProto.floatData!;\n          break;\n        case onnx.TensorProto.DataType.INT32:\n        case onnx.TensorProto.DataType.INT16:\n        case onnx.TensorProto.DataType.UINT16:\n        case onnx.TensorProto.DataType.INT8:\n        case onnx.TensorProto.DataType.UINT8:\n        case onnx.TensorProto.DataType.BOOL:\n          array = tensorProto.int32Data!;\n          break;\n        case onnx.TensorProto.DataType.INT64:\n          array = tensorProto.int64Data!;\n          break;\n        case onnx.TensorProto.DataType.DOUBLE:\n          array = tensorProto.doubleData!;\n          break;\n        case onnx.TensorProto.DataType.UINT32:\n        case onnx.TensorProto.DataType.UINT64:\n          array = tensorProto.uint64Data!;\n          break;\n        default:\n          // should never run here\n          throw new Error('unspecific error');\n      }\n\n      if (array === null || array === undefined) {\n        throw new Error('failed to populate data from a tensorproto value');\n      }\n\n      const data = value.data;\n      if (data.length !== array.length) {\n        throw new Error('array length mismatch');\n      }\n\n      for (let i = 0; i < array.length; i++) {\n        const element = array[i];\n        if (Long.isLong(element)) {\n          data[i] = longToNumber(element, tensorProto.dataType);\n        } else {\n          data[i] = element;\n        }\n      }\n    }\n\n    return value;\n  }\n\n  /**\n   * Construct new Tensor from raw data\n   * @param data the raw data object. Should be a string array for 'string' tensor, and the corresponding typed array\n   * for other types of tensor.\n   * @param dims the dimensions of the tensor\n   * @param type the type of the tensor\n   */\n  static fromData(data: Tensor.DataTypeMap[Tensor.DataType], dims: readonly number[], type: Tensor.DataType) {\n    return new Tensor(dims, type, undefined, undefined, data);\n  }\n\n  static fromOrtTensor(ortTensor: ortFbs.Tensor) {\n    if (!ortTensor) {\n      throw new Error('cannot construct Value from an empty tensor');\n    }\n    const dims = ProtoUtil.tensorDimsFromORTFormat(ortTensor);\n    const type = ProtoUtil.tensorDataTypeFromProto(ortTensor.dataType());\n\n    const value = new Tensor(dims, type);\n\n    if (type === 'string') {\n      // When it's STRING type, the value should always be stored in field\n      // 'stringData'\n      for (let i = 0; i < ortTensor.stringDataLength(); i++) {\n        value.data[i] = ortTensor.stringData(i);\n      }\n    } else if (\n      ortTensor.rawDataArray() &&\n      typeof ortTensor.rawDataLength() === 'number' &&\n      ortTensor.rawDataLength() > 0\n    ) {\n      // NOT considering segment for now (IMPORTANT)\n\n      // populate value from rawData\n      const dataDest = value.data;\n      const dataSource = new DataView(\n        ortTensor.rawDataArray()!.buffer,\n        ortTensor.rawDataArray()!.byteOffset,\n        ortTensor.rawDataLength(),\n      );\n      const elementSize = sizeofProto(ortTensor.dataType());\n      const length = ortTensor.rawDataLength() / elementSize;\n\n      if (ortTensor.rawDataLength() % elementSize !== 0) {\n        throw new Error('invalid buffer length');\n      }\n      if (dataDest.length !== length) {\n        throw new Error('buffer length mismatch');\n      }\n\n      for (let i = 0; i < length; i++) {\n        const n = readProto(dataSource, ortTensor.dataType(), i * elementSize);\n        dataDest[i] = n;\n      }\n    }\n    return value;\n  }\n}\n\nfunction sizeof(type: Tensor.DataType): number {\n  switch (type) {\n    case 'bool':\n    case 'int8':\n    case 'uint8':\n      return 1;\n    case 'int16':\n    case 'uint16':\n      return 2;\n    case 'int32':\n    case 'uint32':\n    case 'float32':\n      return 4;\n    case 'float64':\n      return 8;\n    default:\n      throw new Error(`cannot calculate sizeof() on type ${type}`);\n  }\n}\n\nfunction sizeofProto(type: onnx.TensorProto.DataType | ortFbs.TensorDataType): number {\n  switch (type) {\n    case onnx.TensorProto.DataType.UINT8:\n    case onnx.TensorProto.DataType.INT8:\n    case onnx.TensorProto.DataType.BOOL:\n      return 1;\n    case onnx.TensorProto.DataType.UINT16:\n    case onnx.TensorProto.DataType.INT16:\n      return 2;\n    case onnx.TensorProto.DataType.FLOAT:\n    case onnx.TensorProto.DataType.INT32:\n    case onnx.TensorProto.DataType.UINT32:\n      return 4;\n    case onnx.TensorProto.DataType.INT64:\n    case onnx.TensorProto.DataType.DOUBLE:\n    case onnx.TensorProto.DataType.UINT64:\n      return 8;\n    default:\n      throw new Error(`cannot calculate sizeof() on type ${onnx.TensorProto.DataType[type]}`);\n  }\n}\n\nfunction createView(dataBuffer: ArrayBuffer, type: Tensor.DataType) {\n  return new (dataviewConstructor(type))(dataBuffer);\n}\n\nfunction dataviewConstructor(type: Tensor.DataType) {\n  switch (type) {\n    case 'bool':\n    case 'uint8':\n      return Uint8Array;\n    case 'int8':\n      return Int8Array;\n    case 'int16':\n      return Int16Array;\n    case 'uint16':\n      return Uint16Array;\n    case 'int32':\n      return Int32Array;\n    case 'uint32':\n      return Uint32Array;\n    case 'int64':\n      return BigInt64Array;\n    case 'float32':\n      return Float32Array;\n    case 'float64':\n      return Float64Array;\n    default:\n      // should never run to here\n      throw new Error('unspecified error');\n  }\n}\n\n// convert a long number to a 32-bit integer (cast-down)\nfunction longToNumber(i: Long, type: onnx.TensorProto.DataType | ortFbs.TensorDataType): number {\n  // INT64, UINT32, UINT64\n  if (type === onnx.TensorProto.DataType.INT64 || type === ortFbs.TensorDataType.INT64) {\n    if (i.greaterThanOrEqual(2147483648) || i.lessThan(-2147483648)) {\n      throw new TypeError('int64 is not supported');\n    }\n  } else if (\n    type === onnx.TensorProto.DataType.UINT32 ||\n    type === ortFbs.TensorDataType.UINT32 ||\n    type === onnx.TensorProto.DataType.UINT64 ||\n    type === ortFbs.TensorDataType.UINT64\n  ) {\n    if (i.greaterThanOrEqual(4294967296) || i.lessThan(0)) {\n      throw new TypeError('uint64 is not supported');\n    }\n  } else {\n    throw new TypeError(`not a LONG type: ${onnx.TensorProto.DataType[type]}`);\n  }\n\n  return i.toNumber();\n}\n\n// read one value from TensorProto\nfunction readProto(\n  view: DataView,\n  type: onnx.TensorProto.DataType | ortFbs.TensorDataType,\n  byteOffset: number,\n): number {\n  switch (type) {\n    case onnx.TensorProto.DataType.BOOL:\n    case onnx.TensorProto.DataType.UINT8:\n      return view.getUint8(byteOffset);\n    case onnx.TensorProto.DataType.INT8:\n      return view.getInt8(byteOffset);\n    case onnx.TensorProto.DataType.UINT16:\n      return view.getUint16(byteOffset, true);\n    case onnx.TensorProto.DataType.INT16:\n      return view.getInt16(byteOffset, true);\n    case onnx.TensorProto.DataType.FLOAT:\n      return view.getFloat32(byteOffset, true);\n    case onnx.TensorProto.DataType.INT32:\n      return view.getInt32(byteOffset, true);\n    case onnx.TensorProto.DataType.UINT32:\n      return view.getUint32(byteOffset, true);\n    case onnx.TensorProto.DataType.INT64:\n      return longToNumber(\n        Long.fromBits(view.getUint32(byteOffset, true), view.getUint32(byteOffset + 4, true), false),\n        type,\n      );\n    case onnx.TensorProto.DataType.DOUBLE:\n      return view.getFloat64(byteOffset, true);\n    case onnx.TensorProto.DataType.UINT64:\n      return longToNumber(\n        Long.fromBits(view.getUint32(byteOffset, true), view.getUint32(byteOffset + 4, true), true),\n        type,\n      );\n    default:\n      throw new Error(`cannot read from DataView for type ${onnx.TensorProto.DataType[type]}`);\n  }\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n/**\n * represent a version irrelevant abstraction of for GLSL source code\n */\nexport interface Glsl {\n  readonly version: string;\n  readonly attribute: string;\n  readonly varyingVertex: string;\n  readonly varyingFrag: string;\n  readonly texture2D: string;\n  readonly output: string;\n  readonly outputDeclaration: string;\n}\n\nconst GLSL_ES_2_0: Glsl = {\n  version: '',\n  attribute: 'attribute',\n  varyingVertex: 'varying',\n  varyingFrag: 'varying',\n  texture2D: 'texture2D',\n  output: 'gl_FragColor',\n  outputDeclaration: '',\n};\nconst GLSL_ES_3_0: Glsl = {\n  version: '#version 300 es',\n  attribute: 'in',\n  varyingVertex: 'out',\n  varyingFrag: 'in',\n  texture2D: 'texture',\n  output: 'outputColor',\n  outputDeclaration: 'out vec4 outputColor;',\n};\n\nexport function getGlsl(version: 1 | 2) {\n  return version === 1 ? GLSL_ES_2_0 : GLSL_ES_3_0;\n}\n\nexport function getVertexShaderSource(version: 1 | 2): string {\n  const glsl = getGlsl(version);\n  return `${glsl.version}\n      precision highp float;\n      ${glsl.attribute} vec3 position;\n      ${glsl.attribute} vec2 textureCoord;\n\n      ${glsl.varyingVertex} vec2 TexCoords;\n\n      void main()\n      {\n          gl_Position = vec4(position, 1.0);\n          TexCoords = textureCoord;\n      }`;\n}\n\nexport function getFragShaderPreamble(version: 1 | 2): string {\n  const glsl = getGlsl(version);\n  return `${glsl.version}\n    precision highp float;\n    precision highp int;\n    precision highp sampler2D;\n    ${glsl.varyingFrag} vec2 TexCoords;\n    ${glsl.outputDeclaration}\n    const vec2 halfCR = vec2(0.5, 0.5);\n\n    // Custom vector types to handle higher dimenalities.\n    struct ivec5\n    {\n      int x;\n      int y;\n      int z;\n      int w;\n      int u;\n    };\n\n    struct ivec6\n    {\n      int x;\n      int y;\n      int z;\n      int w;\n      int u;\n      int v;\n    };\n\n    int imod(int x, int y) {\n      return x - y * (x / y);\n    }\n\n    `;\n}\n\nexport function getDefaultFragShaderMain(version: 1 | 2, outputShapeLength: number): string {\n  const glsl = getGlsl(version);\n  return `\n  void main() {\n    int indices[${outputShapeLength}];\n    toVec(TexCoords, indices);\n    vec4 result = vec4(process(indices));\n    ${glsl.output} = result;\n  }\n  `;\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Tensor } from '../../tensor';\n\n/**\n * Layout info is used for mapping n-dimensional array to 2D textures\n * The layout is created by the TextureLayoutStrategy based on\n * the Tensor's dimensions and strides\n */\nexport interface TextureLayout {\n  width: number;\n  height: number;\n  /**\n   * specify the number of value that encoded in a single pixel\n   */\n  channels: 1 | 2 | 3 | 4;\n  /**\n   * whether in packed mode or not\n   */\n  isPacked?: boolean;\n  /**\n   * the normalized shape\n   */\n  shape: readonly number[];\n  /**\n   * the stride of each dimensions, calculated according to shape\n   */\n  strides: readonly number[];\n  /**\n   * the original shape(dims) of the corresponding tensor\n   */\n  unpackedShape: readonly number[];\n\n  reversedWH?: boolean;\n}\nexport interface TextureData extends TextureLayout {\n  tensor: Tensor;\n  texture: WebGLTexture;\n}\n\nexport enum TextureType {\n  unpacked, // <-- normal unpacked texture\n  unpackedReversed, // <-- unpacked texture used in old ONNX.js implementation (deprecated)\n  packed, // <-- normal packed texture\n  downloadUint8AsFloat, // <-- ONLY used in texture downloading for iOS devices\n  packedLastDimension, // <-- ONLY used in old ONNX.js Conv implementation for input W (deprecated)\n}\n\nexport interface TensorInfo {\n  id?: Tensor.Id;\n  dims: readonly number[];\n  type: Tensor.DataType;\n  textureType: TextureType;\n}\n\nexport interface ProgramVariable {\n  type: 'float' | 'int';\n  name: string;\n  arrayLength?: number;\n  data: number | number[];\n}\n\n/**\n * A set of metadata of a shader program.\n */\nexport interface ProgramMetadata {\n  /**\n   * the name of the program. used for debugging and profiling\n   */\n  name: string;\n  /**\n   * texture types for each input\n   */\n  inputTypes: TextureType[];\n  /**\n   * names of each input\n   */\n  inputNames: string[];\n  /**\n   * an optional string as a cache hint in the artifact cache\n   */\n  cacheHint?: string;\n}\n\n/**\n * A ProgramInfoLoader allows\n */\nexport interface ProgramInfoLoader extends ProgramMetadata {\n  /**\n   * a function to get the program info\n   */\n  get(): ProgramInfo;\n}\n\n/**\n * A set of data that represent a shader program\n */\nexport interface ProgramInfo extends ProgramMetadata {\n  /**\n   * information of uniform variables\n   */\n  variables?: ProgramVariable[];\n  /**\n   * tensor info for output\n   */\n  output: TensorInfo;\n  /**\n   * the shader's processing source code\n   */\n  shaderSource: string;\n  /**\n   * whether the shader source contains a customized main function implementation\n   */\n  hasMain?: boolean;\n}\n\nexport interface VariableInfo {\n  type: 'float' | 'int';\n  name: string;\n  arrayLength?: number;\n}\n\nexport interface ProgramVariable {\n  type: 'float' | 'int';\n  name: string;\n  arrayLength?: number;\n  data: number | number[];\n}\n\n/**\n * Information of uniforms that shader uses\n */\nexport interface UniformInfo {\n  type: 'sampler2D' | VariableInfo['type'];\n  name: string;\n  arrayLength?: number;\n}\n\nexport interface UniformLocation extends UniformInfo {\n  location: WebGLUniformLocation;\n}\n\n/**\n * Artifact is the result of compilation\n * It does not contain input of output data\n * However anything that could be run as a \"program\"\n */\nexport interface Artifact {\n  programInfo: ProgramInfo;\n  program: WebGLProgram;\n  uniformLocations: UniformLocation[];\n  attribLocations: { position: number; textureCoord: number };\n}\nexport declare namespace Artifact {\n  type UniformLocations = Artifact['uniformLocations'];\n  type AttribLocations = Artifact['attribLocations'];\n}\n\nexport interface UniformData {\n  [name: string]: number | number[];\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { assert } from '../../util';\n/**\n * Given a non RGBA shape calculate the R version\n * It is assumed that the dimensions are multiples of given channels\n * NOTE: it is always the last dim that gets packed.\n * @param unpackedShape original shape to create a packed version from\n */\nexport function getPackedShape(unpackedShape: readonly number[]): readonly number[] {\n  const len = unpackedShape.length;\n  return unpackedShape.slice(0, len - 1).concat(unpackedShape[len - 1] / 4);\n}\n\nexport async function repeatedTry(\n  checkFn: () => boolean,\n  delayFn = (_counter: number) => 0,\n  maxCounter?: number,\n): Promise<void> {\n  return new Promise<void>((resolve, reject) => {\n    let tryCount = 0;\n\n    const tryFn = () => {\n      if (checkFn()) {\n        resolve();\n        return;\n      }\n\n      tryCount++;\n\n      const nextBackoff = delayFn(tryCount);\n\n      if (maxCounter != null && tryCount >= maxCounter) {\n        reject();\n        return;\n      }\n      setTimeout(tryFn, nextBackoff);\n    };\n\n    tryFn();\n  });\n}\n\n/**\n * Generates the function name from an input sampler name.\n * @param samplerName Name of the sampler.\n */\nexport function generateShaderFuncNameFromInputSamplerName(samplerName: string): string {\n  assert(typeof samplerName !== 'undefined' && samplerName.length !== 0, () => 'empty string found for sampler name');\n  return 'get' + samplerName.charAt(0).toUpperCase() + samplerName.slice(1);\n}\n\n/**\n * Generates the function name from an input sampler name at output coordinates.\n * @param samplerName Name of the sampler.\n */\nexport function generateShaderFuncNameFromInputSamplerNameAtOutCoords(samplerName: string): string {\n  assert(typeof samplerName !== 'undefined' && samplerName.length !== 0, () => 'empty string found for sampler name');\n  return 'get' + samplerName.charAt(0).toUpperCase() + samplerName.slice(1) + 'AtOutCoords';\n}\n\n/** Returns a new input shape (a copy) that has a squeezed logical shape. */\nexport function squeezeInputShape(inputShape: readonly number[], squeezedShape: number[]): number[] {\n  // Deep copy.\n  let newInputShape: number[] = JSON.parse(JSON.stringify(inputShape));\n  newInputShape = squeezedShape;\n  return newInputShape;\n}\n\n/** Returns a list of squeezed parameters for shader functions */\nexport function getSqueezedParams(params: string[], keptDims: number[]): string {\n  return keptDims.map((d) => params[d]).join(', ');\n}\n\n/** Returns the data type for different ranks. */\nexport function getCoordsDataType(rank: number): string {\n  if (rank <= 1) {\n    return 'int';\n  } else if (rank === 2) {\n    return 'ivec2';\n  } else if (rank === 3) {\n    return 'ivec3';\n  } else if (rank === 4) {\n    return 'ivec4';\n  } else if (rank === 5) {\n    return 'ivec5';\n  } else if (rank === 6) {\n    return 'ivec6';\n  } else {\n    throw Error(`GPU for rank ${rank} is not yet supported`);\n  }\n}\n\nexport function getGlChannels(rank = 6): string[] {\n  return ['x', 'y', 'z', 'w', 'u', 'v'].slice(0, rank);\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { getGlChannels } from '../utils';\n\nexport function getVecChannels(name: string, rank: number): string[] {\n  return getGlChannels(rank).map((d) => `${name}.${d}`);\n}\n\nexport function getChannels(name: string, rank: number): string[] {\n  if (rank === 1) {\n    return [name];\n  }\n  return getVecChannels(name, rank);\n}\n\nexport function unpackFromChannel(): string {\n  return `\n    float getChannel(vec4 frag, int dim) {\n      int modCoord = imod(dim, 2);\n      return modCoord == 0 ? frag.r : frag.g;\n    }\n\n    float getChannel(vec4 frag, vec2 innerDims) {\n      vec2 modCoord = mod(innerDims, 2.);\n      return modCoord.x == 0. ?\n        (modCoord.y == 0. ? frag.r : frag.g) :\n        (modCoord.y == 0. ? frag.b : frag.a);\n    }\n  `;\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Tensor } from '../../../tensor';\nimport { getGlsl } from '../glsl-source';\nimport { WebGLInferenceHandler } from '../inference-handler';\nimport { ProgramInfo, ProgramInfoLoader, TextureType } from '../types';\nimport { getCoordsDataType } from '../utils';\n\nimport { getChannels } from './packing-utils';\n\nconst packProgramMetadata = {\n  name: 'pack',\n  inputNames: ['A'],\n  inputTypes: [TextureType.unpackedReversed],\n};\n\nconst createPackProgramInfo = (handler: WebGLInferenceHandler, input: Tensor): ProgramInfo => {\n  const glsl = getGlsl(handler.session.backend.glContext.version);\n  const inputShape = input.dims;\n\n  const inputRank = inputShape.length;\n  // createTextureLayoutFromShape won't change output rank. Need to verify by running tests\n  const outputRank = input.dims.length;\n\n  const coordsDataType = getCoordsDataType(outputRank);\n  const channels = getChannels('rc', outputRank);\n  const setup = getSetup(outputRank, channels, inputShape[inputShape.length - 2], inputShape[inputShape.length - 1]);\n\n  let reversedInputWH;\n  if (inputRank === 0) {\n    reversedInputWH = [1, 1];\n  } else if (inputRank === 1) {\n    reversedInputWH = [inputShape[0], 1];\n  } else {\n    reversedInputWH = [inputShape[outputRank - 1], inputShape[outputRank - 2]];\n  }\n  const outOfBoundsCondition = getOutOfBoundsCondition(outputRank, reversedInputWH, channels);\n  const output = getOutput(inputShape, channels);\n\n  const shaderSource = `\n        void main() {\n          ${coordsDataType} rc = getOutputCoords();\n\n          if(${outOfBoundsCondition}) {\n            ${glsl.output} = vec4(0);\n          } else {\n            ${setup}\n\n            ${glsl.output} = vec4(${output});\n          }\n        }\n      `;\n  return {\n    ...packProgramMetadata,\n    hasMain: true,\n    output: { dims: input.dims, type: input.type, textureType: TextureType.packed },\n    shaderSource,\n  };\n};\n\nexport const createPackProgramInfoLoader = (handler: WebGLInferenceHandler, input: Tensor): ProgramInfoLoader => ({\n  ...packProgramMetadata,\n  get: () => createPackProgramInfo(handler, input),\n});\n\n/**\n * check output coordinate location and return false if it is outside input's width/height boundary\n */\nfunction getOutOfBoundsCondition(rank: number, shape: readonly number[], dims: string[]): string {\n  if (rank === 0) {\n    return 'false';\n  }\n  if (rank === 1) {\n    return `rc > ${shape[0]}`;\n  }\n\n  let cond = '';\n  for (let i = rank - 2; i < rank; i++) {\n    cond += `${dims[i]} >= ${shape[i - rank + 2]}`;\n    if (i < rank - 1) {\n      cond += '||';\n    }\n  }\n\n  return cond;\n}\n\n/**\n * code snippet to sample input texture with output coordinates\n */\nfunction getOutput(shape: readonly number[], dims: string[]): string {\n  const rank = shape.length;\n\n  if (rank === 0) {\n    return 'getA(), 0, 0, 0';\n  }\n\n  if (rank === 1) {\n    return `getA(rc),\n            rc + 1 >= ${shape[0]} ? 0. : getA(rc + 1),\n            0, 0`;\n  }\n\n  const coord00 = 'r, c';\n  const coord01 = 'r, cp1';\n  const coord10 = 'rp1, c';\n  const coord11 = 'rp1, cp1';\n  let D = '';\n  if (rank > 2) {\n    for (let i = 0; i < rank - 2; ++i) {\n      D = D + `${dims[i]},`;\n    }\n  }\n  return `getA(${D}${coord00}),\n          rEdge ? 0. : getA(${D}${coord10}),\n          cEdge ? 0. : getA(${D}${coord01}),\n          rEdge || cEdge ? 0. : getA(${D}${coord11})`;\n}\n\n/**\n * code snippet to setup 4 coordinates and edge conditions\n */\nfunction getSetup(rank: number, dims: string[], rows: number, cols: number): string {\n  if (rank === 0 || rank === 1) {\n    return '';\n  }\n  // rank >= 2 for width+height pack.\n  else {\n    const setup = `\n    int r = ${dims[rank - 2]};\n    int c = ${dims[rank - 1]};\n    int rp1 = ${dims[rank - 2]} + 1;\n    int cp1 = ${dims[rank - 1]} + 1;\n    bool rEdge = rp1 >= ${cols};\n    bool cEdge = cp1 >= ${rows};\n    `;\n    return setup;\n  }\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Tensor } from '../../../tensor';\nimport { ShapeUtil } from '../../../util';\nimport { getGlsl } from '../glsl-source';\nimport { WebGLInferenceHandler } from '../inference-handler';\nimport { ProgramInfo, ProgramInfoLoader, ProgramMetadata, TextureType } from '../types';\n\nimport { unpackFromChannel } from './packing-utils';\n\nconst createPackedReshape3DProgramMetadata = (outputShape3D: readonly number[]) => ({\n  name: 'Reshape (packed)',\n  inputTypes: [TextureType.packed],\n  inputNames: ['A'],\n  cacheHint: `${outputShape3D}`,\n});\n\nconst createPackedReshape3DProgramInfo = (\n  handler: WebGLInferenceHandler,\n  input3D: Tensor,\n  metadata: ProgramMetadata,\n  outputShape3D: readonly number[],\n): ProgramInfo => {\n  const inputShape3D = input3D.dims as [number, number, number];\n  const squeezedOutputShape = outputShape3D as [number, number, number];\n\n  let mainLoop = '';\n  for (let i = 0; i < 4; i++) {\n    let outputCoords = '';\n    switch (i) {\n      case 0:\n        outputCoords = 'outputCoords = rc;';\n        break;\n      case 1:\n        outputCoords = 'outputCoords = ivec3(rc.x, rc.y+1, rc.z);';\n        break;\n      case 2:\n        outputCoords = 'outputCoords = ivec3(rc.x, rc.y, rc.z+1);';\n        break;\n      case 3:\n        outputCoords = 'outputCoords = ivec3(rc.x, rc.y+1, rc.z+1);';\n        break;\n      default:\n        throw new Error();\n    }\n\n    mainLoop += `\n        ${outputCoords}\n        ${i > 0 ? 'if(outputCoords.y < rows && outputCoords.z < cols){' : ''}\n          int flattenedIndex = getFlattenedIndex(outputCoords);\n\n          ivec3 inputRC = inputCoordsFromReshapedOutCoords(flattenedIndex);\n          vec2 innerDims = vec2(float(inputRC.y),float(inputRC.z));\n\n          result[${i}] = getChannel(getA(inputRC.x, inputRC.y, inputRC.z), innerDims);\n\n        ${i > 0 ? '}' : ''}\n      `;\n  }\n  const glsl = getGlsl(handler.session.backend.glContext.version);\n\n  const shaderSource = `\n      ${getReshapedInputCoords(inputShape3D)}\n      ${getFlattenedIndexFrom3D(squeezedOutputShape)}\n      ${unpackFromChannel()}\n\n      void main() {\n        ivec3 rc = getOutputCoords();\n\n        vec4 result = vec4(0.0);\n\n        ivec3 outputCoords;\n        int rows = ${squeezedOutputShape[2]};\n        int cols = ${squeezedOutputShape[1]};\n\n        ${mainLoop}\n        ${glsl.output} = result;\n      }\n    `;\n\n  return {\n    ...metadata,\n    output: { dims: squeezedOutputShape, type: input3D.type, textureType: TextureType.packed },\n    shaderSource,\n    hasMain: true,\n  };\n};\n\nexport const createPackedReshape3DProgramInfoLoader = (\n  handler: WebGLInferenceHandler,\n  input3D: Tensor,\n  outputShape3D: readonly number[],\n): ProgramInfoLoader => {\n  const metadata = createPackedReshape3DProgramMetadata(outputShape3D);\n  return { ...metadata, get: () => createPackedReshape3DProgramInfo(handler, input3D, metadata, outputShape3D) };\n};\n\nexport function processDims3D(shape: ArrayLike<number>): [number, number, number] {\n  if (shape.length === 0) {\n    return [1, 1, 1];\n  }\n  // TODO: squeeze other shapes to 2D case\n  let batch = 1;\n  for (let i = 0; i < shape.length - 2; ++i) {\n    batch *= shape[i];\n  }\n  return [batch, shape.length > 1 ? shape[shape.length - 2] : 1, shape[shape.length - 1]];\n}\n\n// For packed reshape, we need to re-arrange texel data for output shape.\n// Our pack is designed to pack a 2x2 tile in last h and w dimension, so\n// for the reshaped new tensor, we just need to re-arrange the last h and\n// w dimension. For any shape that is not in 3D, i.e. [batch, W, H], we\n// first convert it to 3D by collapsing other dimension to batch dim, then\n// process with the last two dimensions.\n// Note: we only need the shape tensor to calculate output shape, so the\n// content in shape tensor is never uploaded to GPU. It is always kept in CPU.\n// TODO: optimize the algorithm -- in some cases, if the last two dims are\n// the same between input shape and output shape, the packed reshape can be\n// treated as no-op.\nexport function isReshapeCheap(dims: readonly number[], reshapedDims: readonly number[]) {\n  let isCheapReshape = false;\n  if (dims.length === 0 || reshapedDims.length === 0) {\n    // scalar\n    isCheapReshape = true;\n  } else if (dims.length < 2 || reshapedDims.length < 2) {\n    // 1D\n    isCheapReshape = dims[dims.length - 1] === reshapedDims[reshapedDims.length - 1];\n  } else {\n    // 2D +\n    isCheapReshape =\n      dims[dims.length - 1] === reshapedDims[reshapedDims.length - 1] &&\n      dims[dims.length - 2] === reshapedDims[reshapedDims.length - 2];\n  }\n\n  return isCheapReshape;\n}\n\nfunction getReshapedInputCoords(shape: [number, number, number]): string {\n  const strides = ShapeUtil.computeStrides(shape);\n  const coords = ['b', 'r', 'c'];\n  const index = 'index';\n  const coordsFromIndexSnippet = strides\n    .map((stride, i) => {\n      const line1 = `int ${coords[i]} = ${index} / ${stride}`;\n      const line2 =\n        i === strides.length - 1\n          ? `int ${coords[i + 1]} = ${index} - ${coords[i]} * ${stride}`\n          : `index -= ${coords[i]} * ${stride}`;\n      return `${line1}; ${line2};`;\n    })\n    .join('');\n\n  return `\n    ivec3 inputCoordsFromReshapedOutCoords(int index) {\n      ${coordsFromIndexSnippet}\n      return ivec3(b, r, c);\n    }\n  `;\n}\n\nfunction getFlattenedIndexFrom3D(shape: [number, number, number]): string {\n  const strides = ShapeUtil.computeStrides(shape);\n\n  return `\n  int getFlattenedIndex(ivec3 coords) {\n    // reverse y, z order\n    return coords.x * ${strides[0]} + coords.z * ${strides[1]} + coords.y;\n  }\n`;\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { getGlsl } from '../glsl-source';\nimport { WebGLInferenceHandler } from '../inference-handler';\nimport { TextureData, TextureType } from '../types';\n\nexport const encodeAsUint8 = (inferenceHandler: WebGLInferenceHandler, input: TextureData): TextureData => {\n  const outputShape = input.shape;\n  const glsl = getGlsl(inferenceHandler.session.backend.glContext.version);\n  /**\n   * https://github.com/tensorflow/tfjs-core/blob/master/src/kernels/webgl/encode_float_gpu.ts\n   */\n  const shaderSource = `\n    const float FLOAT_MAX = 1.70141184e38;\n    const float FLOAT_MIN = 1.17549435e-38;\n\n    bool isNaN(float val) {\n      return (val < 1.0 || 0.0 < val || val == 0.0) ? false : true;\n    }\n\n    highp vec4 encodeAsUint8(highp float v) {\n      if (isNaN(v)) {\n        return vec4(255, 255, 255, 255);\n      }\n\n      highp float av = abs(v);\n\n      if(av < FLOAT_MIN) {\n        return vec4(0.0, 0.0, 0.0, 0.0);\n      } else if(v > FLOAT_MAX) {\n        return vec4(0.0, 0.0, 128.0, 127.0) / 255.0;\n      } else if(v < -FLOAT_MAX) {\n        return vec4(0.0, 0.0,  128.0, 255.0) / 255.0;\n      }\n\n      highp vec4 c = vec4(0,0,0,0);\n\n      highp float e = floor(log2(av));\n      highp float m = exp2(fract(log2(av))) - 1.0;\n\n      c[2] = floor(128.0 * m);\n      m -= c[2] / 128.0;\n      c[1] = floor(32768.0 * m);\n      m -= c[1] / 32768.0;\n      c[0] = floor(8388608.0 * m);\n\n      highp float ebias = e + 127.0;\n      c[3] = floor(ebias / 2.0);\n      ebias -= c[3] * 2.0;\n      c[2] += floor(ebias) * 128.0;\n\n      c[3] += 128.0 * step(0.0, -v);\n\n      return c / 255.0;\n    }\n\n    void main() {\n      float value = ${glsl.texture2D}(X,TexCoords).r;\n      ${glsl.output} = encodeAsUint8(value);\n    }`;\n  const programInfo = {\n    name: 'Uint8Encode',\n    inputTypes: [TextureType.unpacked],\n    inputNames: ['X'],\n    output: { dims: outputShape, type: input.tensor.type, textureType: TextureType.downloadUint8AsFloat },\n    shaderSource,\n    hasMain: true,\n  };\n  return inferenceHandler.executeProgram(programInfo, [input.tensor]);\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Tensor } from '../../../tensor';\nimport { getGlsl } from '../glsl-source';\nimport { WebGLInferenceHandler } from '../inference-handler';\nimport { ProgramInfo, ProgramInfoLoader, TextureType } from '../types';\nimport { getCoordsDataType } from '../utils';\n\nimport { getChannels, unpackFromChannel } from './packing-utils';\n\nconst unpackProgramMetadata = {\n  name: 'unpack',\n  inputNames: ['A'],\n  inputTypes: [TextureType.packed],\n};\n\nexport const createUnpackProgramInfo = (handler: WebGLInferenceHandler, input: Tensor): ProgramInfo => {\n  const rank = input.dims.length;\n\n  const channels = getChannels('rc', rank);\n  const innerDims = channels.slice(-2);\n  const coordsDataType = getCoordsDataType(rank);\n  const unpackChannel = unpackFromChannel();\n  const isScalar = input.dims.length === 0;\n  const sourceCoords = isScalar ? '' : getSourceCoords(rank, channels);\n  const coords = rank <= 1 ? 'rc' : `vec2(${innerDims.join(',')})`;\n  const glsl = getGlsl(handler.session.backend.glContext.version);\n  const shaderSource = `\n    ${unpackChannel}\n    void main() {\n      ${coordsDataType} rc = getOutputCoords();\n\n       // Sample the texture with the coords to get the rgba channel value.\n       vec4 packedInput = getA(${sourceCoords});\n\n       ${glsl.output} = vec4(getChannel(packedInput, ${coords}), 0, 0, 0);\n     }\n   `;\n\n  return {\n    ...unpackProgramMetadata,\n    hasMain: true,\n    output: { dims: input.dims, type: input.type, textureType: TextureType.unpacked },\n    shaderSource,\n  };\n};\n\nexport const createUnpackProgramInfoLoader = (handler: WebGLInferenceHandler, input: Tensor): ProgramInfoLoader => ({\n  ...unpackProgramMetadata,\n  get: () => createUnpackProgramInfo(handler, input),\n});\n\nfunction getSourceCoords(rank: number, dims: string[]): string {\n  if (rank === 1) {\n    return 'rc';\n  }\n\n  let coords = '';\n  for (let i = 0; i < rank; i++) {\n    coords += dims[i];\n    if (i < rank - 1) {\n      coords += ',';\n    }\n  }\n  return coords;\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Logger } from '../../instrument';\n\nexport declare namespace Encoder {\n  export interface DataTypeMap {\n    float: Float32Array;\n    byte: Uint8Array;\n    int: Uint32Array;\n  }\n  export type DataType = keyof DataTypeMap;\n  type DataArrayType = DataTypeMap[DataType];\n}\n\n/* eslint-disable @typescript-eslint/naming-convention */\nexport const enum EncoderUsage {\n  Default = 0,\n  UploadOnly,\n  Download4BytesAsFloat32,\n}\n/* eslint-enable @typescript-eslint/naming-convention */\n\n/**\n * Abstraction for mapping data types to texture texlets\n * Encoding means how a Float32 is mapped to 1 or 4 channels for each texlet\n * Decoding means how a texlet's channels are mapped to a resulting Float32\n */\nexport interface DataEncoder {\n  internalFormat: number;\n  format: number;\n  textureType: number;\n  channelSize: number;\n  encode(src: Encoder.DataArrayType, textureSize: number): Encoder.DataArrayType;\n  allocate(size: number): Encoder.DataArrayType;\n  decode(buffer: Encoder.DataArrayType, dataSize: number): Encoder.DataArrayType;\n}\n/**\n * WebGL2 data encoder\n * Uses R32F as the format for texlet\n */\nexport class RedFloat32DataEncoder implements DataEncoder {\n  internalFormat: number;\n  format: number;\n  textureType: number;\n  channelSize: number;\n  constructor(gl: WebGL2RenderingContext, channels = 1) {\n    if (channels === 1) {\n      this.internalFormat = gl.R32F;\n      this.format = gl.RED;\n      this.textureType = gl.FLOAT;\n      this.channelSize = channels;\n    } else if (channels === 4) {\n      this.internalFormat = gl.RGBA32F;\n      this.format = gl.RGBA;\n      this.textureType = gl.FLOAT;\n      this.channelSize = channels;\n    } else {\n      throw new Error(`Invalid number of channels: ${channels}`);\n    }\n  }\n  encode(src: Encoder.DataArrayType, textureSize: number): Encoder.DataArrayType {\n    let result: Float32Array;\n    let source: Float32Array;\n    if (src.constructor !== Float32Array) {\n      Logger.warning('Encoder', 'data was not of type Float32; creating new Float32Array');\n      source = new Float32Array(src);\n    }\n    if (textureSize * this.channelSize > src.length) {\n      Logger.warning('Encoder', 'Source data too small. Allocating larger array');\n      source = src as Float32Array;\n      result = this.allocate(textureSize * this.channelSize) as Float32Array;\n      source.forEach((v, i) => (result[i] = v));\n    } else {\n      source = src as Float32Array;\n      result = source;\n    }\n    return result;\n  }\n  allocate(size: number): Encoder.DataArrayType {\n    return new Float32Array(size * 4);\n  }\n  decode(buffer: Encoder.DataArrayType, dataSize: number): Float32Array {\n    if (this.channelSize === 1) {\n      const filteredData = (buffer as Float32Array).filter((_value, index) => index % 4 === 0).subarray(0, dataSize);\n      return filteredData;\n    }\n    return buffer.subarray(0, dataSize) as Float32Array;\n  }\n}\n/**\n * Data encoder for WebGL 1 with support for floating point texture\n */\nexport class RGBAFloatDataEncoder implements DataEncoder {\n  internalFormat: number;\n  format: number;\n  textureType: number;\n  channelSize: number;\n  constructor(gl: WebGLRenderingContext, channels = 1, textureType?: number) {\n    if (channels !== 1 && channels !== 4) {\n      throw new Error(`Invalid number of channels: ${channels}`);\n    }\n    this.internalFormat = gl.RGBA;\n    this.format = gl.RGBA;\n    this.channelSize = channels;\n    this.textureType = textureType || gl.FLOAT;\n  }\n  encode(src: Float32Array, textureSize: number): Encoder.DataArrayType {\n    let dest = src;\n    if (this.channelSize === 1) {\n      Logger.verbose('Encoder', 'Exploding into a larger array');\n      dest = this.allocate(textureSize) as Float32Array;\n      src.forEach((v, i) => (dest[i * 4] = v));\n    }\n    return dest;\n  }\n  allocate(size: number): Encoder.DataArrayType {\n    return new Float32Array(size * 4);\n  }\n  decode(buffer: Encoder.DataArrayType, dataSize: number): Float32Array {\n    if (this.channelSize === 1) {\n      const filteredData = (buffer as Float32Array).filter((_value, index) => index % 4 === 0).subarray(0, dataSize);\n      return filteredData;\n    }\n    return buffer.subarray(0, dataSize) as Float32Array;\n  }\n}\n\nexport class Uint8DataEncoder implements DataEncoder {\n  internalFormat: number;\n  format: number;\n  textureType: number;\n  channelSize = 4;\n  constructor(gl: WebGLRenderingContext, channels = 1) {\n    if (channels === 1) {\n      this.internalFormat = gl.ALPHA;\n      this.format = gl.ALPHA; // not tested\n      this.textureType = gl.UNSIGNED_BYTE;\n      this.channelSize = channels;\n    } else if (channels === 4) {\n      this.internalFormat = gl.RGBA;\n      this.format = gl.RGBA;\n      this.textureType = gl.UNSIGNED_BYTE;\n      this.channelSize = channels;\n    } else {\n      throw new Error(`Invalid number of channels: ${channels}`);\n    }\n  }\n  encode(src: Uint8Array, _textureSize: number): Encoder.DataArrayType {\n    return new Uint8Array(src.buffer, src.byteOffset, src.byteLength);\n  }\n  allocate(size: number): Encoder.DataArrayType {\n    return new Uint8Array(size * this.channelSize);\n  }\n  decode(buffer: Encoder.DataArrayType, dataSize: number): Uint8Array {\n    if (buffer instanceof Uint8Array) {\n      return buffer.subarray(0, dataSize);\n    }\n    throw new Error(`Invalid array type: ${buffer.constructor}`);\n  }\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { ShapeUtil } from '../../util';\n\nimport { TextureLayoutStrategy, WidthHeightPrefs } from './texture-layout-strategy';\nimport { TextureLayout, TextureType } from './types';\n\nexport const createTextureLayoutFromTextureType = (\n  textureLayoutStrategy: TextureLayoutStrategy,\n  shape: readonly number[],\n  textureType: TextureType,\n): TextureLayout => {\n  const channel = textureType === TextureType.unpacked || textureType === TextureType.unpackedReversed ? 1 : 4;\n  const isPacked = textureType === TextureType.packed;\n  const reverseWH = textureType === TextureType.unpackedReversed || textureType === TextureType.packed;\n  const breakAxis = textureType === TextureType.packedLastDimension ? shape.length - 1 : undefined;\n  const unpackedShape =\n    textureType === TextureType.packedLastDimension\n      ? shape.map((d, i) => (i === shape.length - 1 ? d * 4 : d))\n      : undefined;\n  return createTextureLayoutFromShape(textureLayoutStrategy, shape, channel, unpackedShape, {\n    isPacked,\n    reverseWH,\n    breakAxis,\n  });\n};\n\nexport const calculateTextureWidthAndHeight = (\n  textureLayoutStrategy: TextureLayoutStrategy,\n  shape: readonly number[],\n  textureType: TextureType,\n): [number, number] => {\n  const layout = createTextureLayoutFromTextureType(textureLayoutStrategy, shape, textureType);\n  return [layout.width, layout.height];\n};\n\n/**\n * Create a TextureLayout object from shape.\n */\nexport const createTextureLayoutFromShape = (\n  textureLayoutStrategy: TextureLayoutStrategy,\n  shape: readonly number[],\n  channels: 1 | 4 = 1,\n  unpackedShape?: readonly number[],\n  prefs?: WidthHeightPrefs,\n): TextureLayout => {\n  const isPacked = !!(prefs && prefs.isPacked);\n  const [width, height] = textureLayoutStrategy.computeTextureWH(isPacked ? unpackedShape || shape : shape, prefs);\n  const rank = shape.length;\n  let inferredDims = shape.slice(0);\n  if (rank === 0) {\n    inferredDims = [1];\n  }\n  if (channels === 1) {\n    // unpackedShape will take `shape` and not `inferredDims` so as to create a scalar Tensor if need be\n    unpackedShape = shape;\n  } else if (isPacked) {\n    if (channels !== 4) {\n      throw new Error('a packed texture must be 4-channel');\n    }\n    unpackedShape = shape;\n    if (rank > 0) {\n      inferredDims[rank - 1] = Math.ceil(inferredDims[rank - 1] / 2);\n    }\n    if (rank > 1) {\n      inferredDims[rank - 2] = Math.ceil(inferredDims[rank - 2] / 2);\n    }\n  } else if (!unpackedShape) {\n    throw new Error('Unpacked shape is needed when using channels > 1');\n  }\n  return {\n    width,\n    height,\n    channels,\n    isPacked,\n    shape: inferredDims,\n    strides: ShapeUtil.computeStrides(inferredDims),\n    unpackedShape,\n    reversedWH: prefs && prefs.reverseWH,\n  };\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { InferenceHandler } from '../../backend';\nimport { Logger } from '../../instrument';\nimport { Tensor } from '../../tensor';\nimport { ShapeUtil } from '../../util';\n\nimport { createPackProgramInfoLoader } from './ops/pack';\nimport { createPackedReshape3DProgramInfoLoader, isReshapeCheap, processDims3D } from './ops/reshape-packed';\nimport { encodeAsUint8 } from './ops/uint8-encode';\nimport { createUnpackProgramInfoLoader } from './ops/unpack';\nimport { WebGLSessionHandler } from './session-handler';\nimport { EncoderUsage } from './texture-data-encoder';\nimport {\n  calculateTextureWidthAndHeight,\n  createTextureLayoutFromShape,\n  createTextureLayoutFromTextureType,\n} from './texture-layout';\nimport { Artifact, ProgramInfo, ProgramInfoLoader, TextureData, TextureLayout, TextureType } from './types';\n\nconst getProgramInfoUniqueKey = (\n  programInfo: ProgramInfo | ProgramInfoLoader,\n  inputTextureDatas: TextureData[],\n): string => {\n  const inputs = inputTextureDatas\n    .map((texture) => `${texture.unpackedShape.join(',')};${texture.width}x${texture.height}`)\n    .join('_');\n  let key = programInfo.name;\n  if (programInfo.cacheHint) {\n    key += '[' + programInfo.cacheHint + ']';\n  }\n  key += ':' + inputs;\n  return key;\n};\n\nexport class WebGLInferenceHandler implements InferenceHandler {\n  private packedTextureDataCache: Map<Tensor.Id, TextureData>;\n  private unpackedTextureDataCache: Map<Tensor.Id, TextureData>;\n  constructor(public session: WebGLSessionHandler) {\n    this.packedTextureDataCache = new Map();\n    this.unpackedTextureDataCache = new Map();\n  }\n\n  /**\n   * @returns [width, height]\n   */\n  calculateTextureWidthAndHeight(shape: readonly number[], textureType: TextureType): [number, number] {\n    return calculateTextureWidthAndHeight(this.session.layoutStrategy, shape, textureType);\n  }\n\n  executeProgram(program: ProgramInfo | ProgramInfoLoader, inputs: readonly Tensor[]): TextureData {\n    if (inputs.length < program.inputNames.length) {\n      throw new Error(`Input size mustn't be less than ${program.inputNames.length}.`);\n    }\n    if (program.inputNames.length !== program.inputTypes.length) {\n      throw new Error('input names size does not match input types');\n    }\n\n    // create texture info for input\n    const inputTextureDatas: TextureData[] = [];\n    for (let i = 0; i < program.inputNames.length; ++i) {\n      inputTextureDatas[i] = this.getOrCreateTextureData(inputs[i], program.inputTypes[i]);\n    }\n\n    const key = getProgramInfoUniqueKey(program, inputTextureDatas);\n    let artifact = this.session.programManager.getArtifact(key);\n    const programInfo = artifact\n      ? artifact.programInfo\n      : typeof (program as ProgramInfoLoader).get === 'function'\n        ? (program as ProgramInfoLoader).get()\n        : (program as ProgramInfo);\n\n    // create texture info for output\n    const outputTextureLayout = createTextureLayoutFromTextureType(\n      this.session.layoutStrategy,\n      programInfo.output.dims,\n      programInfo.output.textureType,\n    );\n    const outputTextureData = this.createTextureData(outputTextureLayout, programInfo.output.type);\n\n    if (!artifact) {\n      artifact = this.session.programManager.build(programInfo, inputTextureDatas, outputTextureData);\n      this.session.programManager.setArtifact(key, artifact);\n    }\n\n    this.runProgram(artifact, inputTextureDatas, outputTextureData);\n    return outputTextureData;\n  }\n\n  run(program: ProgramInfoLoader, inputs: readonly Tensor[]): Tensor {\n    const outputTextureData = this.executeProgram(program, inputs);\n    return outputTextureData.tensor;\n  }\n\n  private runProgram(artifact: Artifact, inputs: TextureData[], output: TextureData): void {\n    // input should match\n    for (let i = 0; i < inputs.length; ++i) {\n      if (!!inputs[i].isPacked !== (artifact.programInfo.inputTypes[i] === TextureType.packed)) {\n        throw new Error(`input[${i}] property packed inconsistent`);\n      }\n    }\n\n    // output should match\n    if (!!output.isPacked !== (artifact.programInfo.output.textureType === TextureType.packed)) {\n      throw new Error('output property packed inconsistent');\n    }\n\n    this.session.programManager.run(artifact, inputs, output);\n  }\n\n  /**\n   * Create a TextureData object from a tensor.\n   * Usage = EncoderUsage.UploadOnly.\n   * If a related texture data is found in cache, returns it;\n   * Otherwise:\n   *   Creates a new texture layout if not provided;\n   *   Creates WebGLTexture with the layout;\n   *   Upload tensor data to the texture;\n   *   Creates a texture data object associated with the given tensor.\n   * @param tensor the tensor with data to upload\n   */\n  private getOrCreateTextureData(tensor: Tensor, textureType: TextureType) {\n    let td = this.getTextureData(tensor.dataId, textureType === TextureType.packed);\n\n    if (!td) {\n      // check if we have texture data in different type\n      td = this.getTextureData(tensor.dataId, textureType !== TextureType.packed);\n      if (td) {\n        if (textureType === TextureType.packed) {\n          return this.pack(td);\n        } else {\n          return this.unpack(td);\n        }\n      }\n    }\n\n    if (!td) {\n      const layout = createTextureLayoutFromTextureType(this.session.layoutStrategy, tensor.dims, textureType);\n\n      if (textureType === TextureType.packedLastDimension) {\n        const group = 1;\n        const channels = 4;\n        const shape = tensor.dims;\n        if (shape.length === 4) {\n          // pre-processing for kernel data of Conv.\n          //\n          // TODO: currently this is a hacking to overwrite Conv's weight. The correct way to do this should be:\n          // 1. implement texture based const-folding\n          // 2. create a WebGL program \"preprocessConvWeight\" to do the same work as below\n          // 3. run the program before dotProduct.\n          //\n          const adjustedKernelShape = [shape[0], Math.ceil((shape[1] * shape[2] * shape[3]) / channels)];\n          const adjustedLayout = createTextureLayoutFromTextureType(\n            this.session.layoutStrategy,\n            adjustedKernelShape,\n            textureType,\n          );\n          let buffer = tensor.numberData;\n          if ((shape[1] * shape[2] * shape[3]) % channels !== 0) {\n            const numFeatureMaps = shape[0];\n            const oldRowSize = shape[1] * shape[2] * shape[3];\n            const newRowSize = Math.ceil((oldRowSize * group) / channels) * channels;\n            const newSize = numFeatureMaps * newRowSize;\n            buffer = new Float32Array(newSize);\n            for (let f = 0; f < numFeatureMaps; ++f) {\n              const oldOffset = f * oldRowSize;\n              const newOffset = f * newRowSize + (f % group) * oldRowSize;\n              buffer.set(tensor.numberData.subarray(oldOffset, oldOffset + oldRowSize), newOffset);\n            }\n          }\n          return this.createTextureData(adjustedLayout, tensor.type, buffer, tensor, EncoderUsage.UploadOnly);\n        }\n      }\n\n      if (textureType === TextureType.packed) {\n        const unpackedTextureLayout = createTextureLayoutFromShape(this.session.layoutStrategy, tensor.dims, 1, [], {\n          reverseWH: true,\n        });\n        const unpackedTextureData = this.createTextureData(\n          unpackedTextureLayout,\n          tensor.type,\n          tensor.numberData,\n          tensor,\n          EncoderUsage.UploadOnly,\n        );\n        td = this.pack(unpackedTextureData);\n      } else {\n        td = this.createTextureData(layout, tensor.type, tensor.numberData, tensor, EncoderUsage.UploadOnly);\n      }\n    }\n    return td;\n  }\n\n  /**\n   * Create a TextureData object using the given data and bind to the given tensor.\n   * Usage = EncoderUsage.UploadOnly.\n   * NOTE: this function is a hack for Conv implementation. should remove this function, after rewriting Conv\n   * implementation by Graph.Transformer\n   * @param dataType the tensor data type\n   * @param data the actual data to upload\n   * @param tensor the tensor to bind. tensor's data is ignored.\n   */\n  createTextureDataFromLayoutBindTensor(\n    layout: TextureLayout,\n    dataType: Tensor.DataType,\n    data: Tensor.NumberType,\n    tensor: Tensor,\n  ): TextureData {\n    return this.createTextureData(layout, dataType, data, tensor, EncoderUsage.UploadOnly);\n  }\n\n  private createTextureData(\n    layout: TextureLayout,\n    dataType: Tensor.DataType,\n    data?: Tensor.NumberType,\n    tensor?: Tensor,\n    usage?: EncoderUsage,\n  ): TextureData {\n    Logger.verbose('InferenceHandler', `Creating TextureData: layout:[${JSON.stringify(layout)}]`);\n    const texture = this.session.textureManager.createTextureFromLayout(dataType, layout, data, usage);\n    return this.createTextureDataFromTexture(layout, dataType, texture, tensor);\n  }\n\n  reshapeUnpacked(input: Tensor, reshapedDims: readonly number[]): Tensor {\n    const inputTD = this.getOrCreateTextureData(input, TextureType.unpacked);\n    const newTextureLayout: TextureLayout = {\n      channels: inputTD.channels,\n      height: inputTD.height,\n      width: inputTD.width,\n      // handle reshaping into scalar Tensors\n      shape: reshapedDims.length !== 0 ? reshapedDims : [1],\n      strides: ShapeUtil.computeStrides(reshapedDims),\n      unpackedShape: reshapedDims,\n    };\n    const newTextureData = this.createTextureDataFromTexture(newTextureLayout, input.type, inputTD.texture);\n    return newTextureData.tensor;\n  }\n\n  reshapePacked(input: Tensor, reshapedDims: readonly number[]): Tensor {\n    const inputTD = this.getOrCreateTextureData(input, TextureType.packed);\n\n    // check if the reshape is 'cheap'\n    if (isReshapeCheap(input.dims, reshapedDims)) {\n      const newTextureLayout: TextureLayout = {\n        channels: inputTD.channels,\n        height: inputTD.height,\n        width: inputTD.width,\n        // handle reshaping into scalar Tensors\n        shape: reshapedDims.length !== 0 ? reshapedDims : [1],\n        strides: ShapeUtil.computeStrides(reshapedDims),\n        unpackedShape: reshapedDims,\n        isPacked: true,\n      };\n      const newTextureData = this.createTextureDataFromTexture(newTextureLayout, input.type, inputTD.texture);\n      return newTextureData.tensor;\n    }\n\n    const squeezedInputShape = processDims3D(input.dims);\n    const squeezedOutputShape = processDims3D(reshapedDims);\n\n    const squeezedInputTensor = this.reshapePacked(input, squeezedInputShape);\n    const squeezedOutputTensor = this.run(\n      createPackedReshape3DProgramInfoLoader(this, squeezedInputTensor, squeezedOutputShape),\n      [squeezedInputTensor],\n    );\n    const outputTensor = this.reshapePacked(squeezedOutputTensor, reshapedDims);\n    return outputTensor;\n  }\n\n  cast(input: Tensor, type: Tensor.DataType): Tensor {\n    const inputTD = this.getOrCreateTextureData(input, TextureType.unpacked);\n    const newTextureData = this.createTextureDataFromTexture(inputTD as TextureLayout, type, inputTD.texture);\n    return newTextureData.tensor;\n  }\n\n  private createTextureDataFromTexture(\n    layout: TextureLayout,\n    dataType: Tensor.DataType,\n    texture: WebGLTexture,\n    tensor?: Tensor,\n    tensorId?: Tensor.Id,\n  ) {\n    const textureData: TextureData = {\n      ...layout,\n      tensor:\n        tensor ||\n        new Tensor(\n          layout.unpackedShape,\n          dataType,\n          (_id: Tensor.Id) => this.readTexture(textureData),\n          async (_id: Tensor.Id) => this.readTextureAsync(textureData),\n          undefined,\n          tensorId,\n        ),\n      texture,\n    };\n    this.setTextureData(textureData.tensor.dataId, textureData, layout.isPacked);\n    return textureData;\n  }\n\n  private getTextureData(tensorId: Tensor.Id, isPacked = false): TextureData | undefined {\n    return this.session.isInitializer(tensorId)\n      ? this.session.getTextureData(tensorId, isPacked)\n      : isPacked\n        ? this.packedTextureDataCache.get(tensorId)\n        : this.unpackedTextureDataCache.get(tensorId);\n  }\n  setTextureData(tensorId: Tensor.Id, td: TextureData, isPacked = false): void {\n    if (this.session.isInitializer(tensorId)) {\n      this.session.setTextureData(tensorId, td, isPacked);\n    } else {\n      (isPacked ? this.packedTextureDataCache : this.unpackedTextureDataCache).set(tensorId, td);\n    }\n  }\n  isTextureLayoutCached(tensor: Tensor, isPacked = false): boolean {\n    return !!this.getTextureData(tensor.dataId, isPacked);\n  }\n\n  dispose(): void {\n    this.session.textureManager.clearActiveTextures();\n    this.packedTextureDataCache.forEach((td) => this.session.textureManager.releaseTexture(td));\n    this.packedTextureDataCache = new Map();\n    this.unpackedTextureDataCache.forEach((td) => this.session.textureManager.releaseTexture(td));\n    this.unpackedTextureDataCache = new Map();\n  }\n\n  readTexture(textureData: TextureData): Tensor.NumberType {\n    if (textureData.isPacked) {\n      return this.readTexture(this.unpack(textureData));\n    }\n    if (!this.session.backend.glContext.isFloat32DownloadSupported) {\n      return this.session.textureManager.readUint8TextureAsFloat(encodeAsUint8(this, textureData));\n    }\n    return this.session.textureManager.readTexture(textureData, textureData.tensor.type, textureData.channels);\n  }\n\n  async readTextureAsync(textureData: TextureData): Promise<Tensor.NumberType> {\n    if (textureData.isPacked) {\n      return this.readTextureAsync(this.unpack(textureData));\n    }\n    if (!this.session.backend.glContext.isFloat32DownloadSupported) {\n      return this.session.textureManager.readUint8TextureAsFloat(encodeAsUint8(this, textureData));\n    }\n    return this.session.textureManager.readTextureAsync(textureData, textureData.tensor.type, textureData.channels);\n  }\n\n  pack(input: TextureData): TextureData {\n    const outputTextureData = this.executeProgram(createPackProgramInfoLoader(this, input.tensor), [input.tensor]);\n    return outputTextureData;\n  }\n\n  unpack(input: TextureData): TextureData {\n    const outputTextureData = this.executeProgram(createUnpackProgramInfoLoader(this, input.tensor), [input.tensor]);\n    return outputTextureData;\n  }\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nclass AttributeWithCacheKeyImpl {\n  constructor(attribute: Record<string, unknown>) {\n    Object.assign(this, attribute);\n  }\n\n  private key: string;\n  public get cacheKey(): string {\n    if (!this.key) {\n      this.key = Object.getOwnPropertyNames(this)\n        .sort()\n        .map((name) => `${(this as Record<string, unknown>)[name]}`)\n        .join(';');\n    }\n    return this.key;\n  }\n}\n\nexport interface AttributeWithCacheKey {\n  readonly cacheKey: string;\n}\n\nexport const createAttributeWithCacheKey = <T extends Record<string, unknown>>(\n  attribute: T,\n): T & AttributeWithCacheKey => new AttributeWithCacheKeyImpl(attribute) as unknown as T & AttributeWithCacheKey;\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { AttributeWithCacheKey, createAttributeWithCacheKey } from '../../../attribute-with-cache-key';\nimport { Graph } from '../../../graph';\nimport { OperatorImplementation, OperatorInitialization } from '../../../operators';\nimport { Tensor } from '../../../tensor';\nimport { getGlsl } from '../glsl-source';\nimport { WebGLInferenceHandler } from '../inference-handler';\nimport { ProgramInfo, TextureType } from '../types';\n\nexport interface BatchNormalizationAttributes extends AttributeWithCacheKey {\n  epsilon: number;\n  momentum: number;\n  spatial: number;\n}\n\nconst batchNormalizationProgramMetadata = {\n  name: 'BatchNormalization',\n  inputNames: ['A', 'Scale', 'B', 'Mean', 'Variance'],\n  inputTypes: [\n    TextureType.unpacked,\n    TextureType.unpacked,\n    TextureType.unpacked,\n    TextureType.unpacked,\n    TextureType.unpacked,\n  ],\n};\n\nexport const batchNormalization: OperatorImplementation<BatchNormalizationAttributes> = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  attributes: BatchNormalizationAttributes,\n): Tensor[] => {\n  validateInputs(inputs);\n  const output = inferenceHandler.run(\n    {\n      ...batchNormalizationProgramMetadata,\n      cacheHint: attributes.cacheKey,\n      get: () => createBatchNormalizationProgramInfo(inferenceHandler, inputs, attributes),\n    },\n    inputs,\n  );\n  return [output];\n};\n\nexport const parseBatchNormalizationAttributes: OperatorInitialization<BatchNormalizationAttributes> = (\n  node: Graph.Node,\n): BatchNormalizationAttributes => {\n  const epsilon = node.attributes.getFloat('epsilon', 1e-5);\n  const momentum = node.attributes.getFloat('momentum', 0.9);\n  const spatial = node.attributes.getInt('spatial', 1);\n  return createAttributeWithCacheKey({ epsilon, momentum, spatial });\n};\n\nconst createBatchNormalizationProgramInfo = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  attributes: BatchNormalizationAttributes,\n): ProgramInfo => {\n  const glsl = getGlsl(inferenceHandler.session.backend.glContext.version);\n  const rank = inputs[0].dims.length;\n  const [scaleWidth, scaleHeight] = inferenceHandler.calculateTextureWidthAndHeight(\n    inputs[1].dims,\n    TextureType.unpacked,\n  );\n  const shaderSource = `\n  float process(int[${rank}] indices) {\n    vec2 position = offsetToCoords(indices[1], ${scaleWidth}, ${scaleHeight});\n    float scale = getColorAsFloat(${glsl.texture2D}(Scale, position));\n    float mean = getColorAsFloat(${glsl.texture2D}(Mean, position));\n    float variance = getColorAsFloat(${glsl.texture2D}(Variance, position));\n    float b = getColorAsFloat(${glsl.texture2D}(B, position));\n\n    return scale * ( (_A(indices) - mean) / sqrt(variance + float(${attributes.epsilon})) ) + b;\n  }`;\n  return {\n    ...batchNormalizationProgramMetadata,\n    output: { dims: inputs[0].dims, type: inputs[0].type, textureType: TextureType.unpacked },\n    shaderSource,\n  };\n};\n\nconst validateInputs = (inputs: Tensor[]): void => {\n  if (!inputs || inputs.length !== 5) {\n    throw new Error('BatchNormalization requires 5 inputs.');\n  }\n\n  const X = inputs[0];\n  const scale = inputs[1];\n  const B = inputs[2];\n  const mean = inputs[3];\n  const var_ = inputs[4];\n\n  // input should atleast have three dimensions - N,C,dim1,...,dimn\n  // other inputs can have only one dimensions\n  if (\n    X.dims.length < 3 ||\n    scale.dims.length !== 1 ||\n    B.dims.length !== 1 ||\n    mean.dims.length !== 1 ||\n    var_.dims.length !== 1\n  ) {\n    throw new Error('invalid input shape.');\n  }\n  if (\n    scale.dims[0] !== X.dims[1] ||\n    B.dims[0] !== X.dims[1] ||\n    mean.dims[0] !== X.dims[1] ||\n    var_.dims[0] !== X.dims[1]\n  ) {\n    throw new Error('invalid input shape.');\n  }\n  if (\n    (X.type !== 'float32' && X.type !== 'float64') ||\n    (scale.type !== 'float32' && scale.type !== 'float64') ||\n    (B.type !== 'float32' && B.type !== 'float64') ||\n    (mean.type !== 'float32' && mean.type !== 'float64') ||\n    (var_.type !== 'float32' && var_.type !== 'float64')\n  ) {\n    throw new Error('invalid input tensor types.');\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { ProgramInfo, TextureLayout } from './types';\nimport { WebGLContext } from './webgl-context';\n\n/* eslint-disable @typescript-eslint/naming-convention */\nexport enum FunctionType {\n  ValueBased,\n  Positional,\n}\nexport interface GlslFunction<T extends FunctionType> {\n  body: string;\n  name: string;\n  type: T;\n}\nexport type GlslValueFunction = GlslFunction<FunctionType.ValueBased>;\nexport interface GlslPositionalFunction extends GlslFunction<FunctionType.Positional> {\n  inputShape: readonly number[];\n  outputShape: readonly number[];\n}\n\nexport class GlslContext {\n  constructor(\n    public glContext: WebGLContext,\n    public programInfo: ProgramInfo,\n    public inputTextureLayouts: TextureLayout[],\n    public outputTextureLayout: TextureLayout,\n  ) {}\n}\nexport abstract class GlslLib {\n  constructor(public context: GlslContext) {}\n  abstract getFunctions(): { [name: string]: GlslLibRoutine };\n  abstract getCustomTypes(): { [name: string]: string };\n}\n\n// abstraction to represent a GLSL library routine and it's dependencies\nexport class GlslLibRoutine {\n  constructor(\n    public routineBody: string,\n    public dependencies?: string[],\n  ) {}\n}\n\n// abstraction to represent a GLSL library routine and it's dependencies AS GRAPH Nodes\n// this level of abstraction is used to topologically sort routines before fragment shade inclusion\nexport class GlslLibRoutineNode {\n  dependencies: GlslLibRoutineNode[];\n  routineBody: string;\n  constructor(\n    public name: string,\n    routineBody?: string,\n    dependencies?: GlslLibRoutineNode[],\n  ) {\n    if (dependencies) {\n      this.dependencies = dependencies;\n    } else {\n      this.dependencies = [];\n    }\n\n    if (routineBody) {\n      this.routineBody = routineBody;\n    }\n  }\n  addDependency(node: GlslLibRoutineNode) {\n    if (node) {\n      this.dependencies.push(node);\n    }\n  }\n}\n\n// topologically sort GLSL library routines (graph nodes abstraction) before shader script inclusion\nexport class TopologicalSortGlslRoutines {\n  static returnOrderedNodes(nodes: GlslLibRoutineNode[]): GlslLibRoutineNode[] {\n    if (!nodes || nodes.length === 0) {\n      return [];\n    }\n\n    if (nodes.length === 1) {\n      return nodes;\n    }\n\n    const cycleCheck = new Set<string>();\n    const alreadyTraversed = new Set<string>();\n    const result = new Array<GlslLibRoutineNode>();\n\n    this.createOrderedNodes(nodes, cycleCheck, alreadyTraversed, result);\n    return result;\n  }\n\n  private static createOrderedNodes(\n    graphNodes: GlslLibRoutineNode[],\n    cycleCheck: Set<string>,\n    alreadyTraversed: Set<string>,\n    result: GlslLibRoutineNode[],\n  ) {\n    for (let i = 0; i < graphNodes.length; ++i) {\n      this.dfsTraverse(graphNodes[i], cycleCheck, alreadyTraversed, result);\n    }\n  }\n\n  private static dfsTraverse(\n    root: GlslLibRoutineNode,\n    cycleCheck: Set<string>,\n    alreadyTraversed: Set<string>,\n    result: GlslLibRoutineNode[],\n  ) {\n    // if this root has already been traversed return\n    if (!root || alreadyTraversed.has(root.name)) {\n      return;\n    }\n\n    // cyclic dependency has been detected\n    if (cycleCheck.has(root.name)) {\n      throw new Error(\"Cyclic dependency detected. Can't topologically sort routines needed for shader.\");\n    }\n\n    // hold this node to detect cycles if any\n    cycleCheck.add(root.name);\n\n    // traverse children in a dfs fashion\n    const dependencies = root.dependencies;\n    if (dependencies && dependencies.length > 0) {\n      for (let i = 0; i < dependencies.length; ++i) {\n        this.dfsTraverse(dependencies[i], cycleCheck, alreadyTraversed, result);\n      }\n    }\n\n    // add to result holder\n    result.push(root);\n\n    // mark this node as traversed so that we don't traverse from this again\n    alreadyTraversed.add(root.name);\n\n    // release the hold\n    cycleCheck.delete(root.name);\n  }\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Tensor } from '../../../tensor';\nimport { BroadcastUtil, ShapeUtil } from '../../../util';\nimport { FunctionType, GlslValueFunction } from '../glsl-definitions';\nimport { getGlsl } from '../glsl-source';\nimport { WebGLInferenceHandler } from '../inference-handler';\nimport { ProgramInfo, ProgramInfoLoader, TextureType } from '../types';\n\nexport function glslAdd(): GlslValueFunction {\n  const name = 'add_';\n  const body = `\n  float ${name}(float a, float b) {\n    return a + b;\n  }\n  vec4 ${name}(vec4 v1, vec4 v2) {\n    return v1 + v2;\n  }\n  `;\n  return { body, name, type: FunctionType.ValueBased };\n}\nexport function glslDiv(): GlslValueFunction {\n  const name = 'div_';\n  const body = `\n  float ${name}(float a, float b) {\n    return a / b;\n  }\n  vec4 ${name}(vec4 v1, vec4 v2) {\n    return v1 / v2;\n  }\n  `;\n  return { body, name, type: FunctionType.ValueBased };\n}\nexport function glslMul(): GlslValueFunction {\n  const name = 'mul_';\n  const body = `\n  float ${name}(float a, float b) {\n    return a * b;\n  }\n  vec4 ${name}(vec4 v1, vec4 v2) {\n    return v1 * v2;\n  }\n  `;\n  return { body, name, type: FunctionType.ValueBased };\n}\nexport function glslSub(): GlslValueFunction {\n  const name = 'sub_';\n  const body = `\n  float ${name}(float a, float b) {\n    return a - b;\n  }\n  vec4 ${name}(vec4 v1, vec4 v2) {\n    return v1 - v2;\n  }\n  `;\n  return { body, name, type: FunctionType.ValueBased };\n}\nexport function glslEqual(): GlslValueFunction {\n  const name = 'equal_';\n  const body = `\n  float ${name}(float a, float b) {\n    return float(a == b);\n  }\n  vec4 ${name}(vec4 v1, vec4 v2) {\n    return vec4(equal(v1, v2));\n  }\n  `;\n  return { body, name, type: FunctionType.ValueBased };\n}\nexport function glslGreater(): GlslValueFunction {\n  const name = 'greater_';\n  const body = `\n  float ${name}(float a, float b) {\n    return float(a > b);\n  }\n  vec4 ${name}(vec4 v1, vec4 v2) {\n    return vec4( v1.r > v2.r ,\n      v1.g > v2.g,\n      v1.b > v2.b,\n      v1.a > v2.a );\n  }\n  `;\n  return { body, name, type: FunctionType.ValueBased };\n}\nexport function glslLess(): GlslValueFunction {\n  const name = 'less_';\n  const body = `\n  float ${name}(float a, float b) {\n    return float(a < b);\n  }\n  vec4 ${name}(vec4 v1, vec4 v2) {\n    return vec4( v1.r < v2.r ,\n                v1.g < v2.g,\n                v1.b < v2.b,\n                v1.a < v2.a );\n  }\n  `;\n  return { body, name, type: FunctionType.ValueBased };\n}\nexport function glslAnd(): GlslValueFunction {\n  const name = 'and_';\n  const body = `\n  float ${name}(float a, float b) {\n    return float( bool(a) && bool(b) );\n  }\n  vec4 ${name}(vec4 v1, vec4 v2) {\n    bvec4 b1 = bvec4(v1);\n    bvec4 b2 = bvec4(v2);\n    return vec4( b1.r && b2.r ,\n                b1.g && b2.g,\n                b1.b && b2.b,\n                b1.a && b2.a );\n  }\n  `;\n  return { body, name, type: FunctionType.ValueBased };\n}\nexport function glslOr(): GlslValueFunction {\n  const name = 'or_';\n  const body = `\n  float ${name}(float a, float b) {\n    return float( bool(a) || bool(b) );\n  }\n  vec4 ${name}(vec4 v1, vec4 v2) {\n    bvec4 b1 = bvec4(v1);\n    bvec4 b2 = bvec4(v2);\n    return vec4( b1.r || b2.r ,\n                b1.g || b2.g,\n                b1.b || b2.b,\n                b1.a || b2.a );\n  }\n  `;\n  return { body, name, type: FunctionType.ValueBased };\n}\nexport function glslXor(): GlslValueFunction {\n  const name = 'xor_';\n  const body = `\n  float ${name}(float a, float b) {\n    return float( bool(a) ^^ bool(b) );\n  }\n  vec4 ${name}(vec4 v1, vec4 v2) {\n    bvec4 b1 = bvec4(v1);\n    bvec4 b2 = bvec4(v2);\n    return vec4( b1.r ^^ b2.r ,\n                b1.g ^^ b2.g,\n                b1.b ^^ b2.b,\n                b1.a ^^ b2.a );\n  }\n  `;\n  return { body, name, type: FunctionType.ValueBased };\n}\nexport function glslPow(): GlslValueFunction {\n  return glslBuiltinBinary('pow');\n}\nexport function glslPRelu(): GlslValueFunction {\n  const name = 'prelu_';\n  const body = `\n  float ${name}(float a, float b) {\n    return a < 0.0 ? a * b: a;\n  }\n  vec4 ${name}(vec4 v1, vec4 v2) {\n    return vec4(\n      v1.r < 0.0 ? v1.r * v2.r: v1.r,\n      v1.g < 0.0 ? v1.g * v2.g: v1.g,\n      v1.b < 0.0 ? v1.b * v2.b: v1.b,\n      v1.a < 0.0 ? v1.a * v2.a: v1.a\n      );\n  }\n  `;\n  return { body, name, type: FunctionType.ValueBased };\n}\n\nfunction glslBuiltinBinary(fname: string): GlslValueFunction {\n  const name = `${fname}_`;\n  const body = `\n  float ${name}(float a, float b) {\n    return ${fname}(a, b);\n  }\n  vec4 ${name}(vec4 v1, vec4 v2) {\n    return ${fname}(v1, v2);\n  }\n  `;\n  return { body, name, type: FunctionType.ValueBased };\n}\n\nconst createBinaryProgramInfoLoader = (\n  handler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  glslFunc: GlslValueFunction,\n  outputTensorType: Tensor.DataType = inputs[0].type,\n  cacheKey?: string,\n): ProgramInfoLoader => {\n  const textureType = handler.session.pack ? TextureType.packed : TextureType.unpacked;\n  return {\n    name: glslFunc.name,\n    inputNames: ['A', 'B'],\n    inputTypes: [textureType, textureType],\n    cacheHint: cacheKey,\n    get: () => createBinaryProgramInfo(handler, inputs, glslFunc, outputTensorType),\n  };\n};\n\nconst createBinaryProgramInfo = (\n  handler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  glslFunc: GlslValueFunction,\n  outputTensorType: Tensor.DataType = inputs[0].type,\n): ProgramInfo => {\n  const textureType = handler.session.pack ? TextureType.packed : TextureType.unpacked;\n  const isBroadcast = !ShapeUtil.areEqual(inputs[0].dims, inputs[1].dims);\n  let outputShape = inputs[0].dims;\n\n  const usePackedTexture = handler.session.pack;\n\n  if (isBroadcast) {\n    const calculatedShape = BroadcastUtil.calcShape(inputs[0].dims, inputs[1].dims, false);\n    if (!calculatedShape) {\n      throw new Error(\"Can't perform binary op on the given tensors\");\n    }\n    outputShape = calculatedShape;\n    const outputRank = outputShape.length;\n    const aRank = inputs[0].dims.length !== 0 ? inputs[0].dims.length : 1;\n    const bRank = inputs[1].dims.length !== 0 ? inputs[1].dims.length : 1;\n    const aBcast = inputs[0].dims.length !== 0 ? 'bcastIndices_A(indices, aindices);' : 'aindices[0] = 0;';\n    const bBcast = inputs[1].dims.length !== 0 ? 'bcastIndices_B(indices, bindices);' : 'bindices[0] = 0;';\n\n    const glsl = getGlsl(handler.session.backend.glContext.version);\n    const shaderSource = usePackedTexture\n      ? `\n      ${glslFunc.body}\n      void main() {\n        vec4 a = getAAtOutCoords();\n        vec4 b = getBAtOutCoords();\n        vec4 result = ${glslFunc.name}(a, b);\n        ${glsl.output} = result;\n      }`\n      : `\n      ${glslFunc.body}\n      float process(int indices[${outputRank}]) {\n        int aindices[${aRank}];\n        int bindices[${bRank}];\n        ${aBcast}\n        ${bBcast}\n        return ${glslFunc.name}(_A(aindices), _B(bindices));\n      }`;\n\n    return {\n      name: glslFunc.name,\n      inputNames: ['A', 'B'],\n      inputTypes: [textureType, textureType],\n      output: { dims: outputShape, type: outputTensorType, textureType },\n      shaderSource,\n      hasMain: usePackedTexture,\n    };\n  }\n  const glsl = getGlsl(handler.session.backend.glContext.version);\n  const shaderSource = `\n    ${glslFunc.body}\n    void main() {\n      vec4 v1 = ${glsl.texture2D}(A, TexCoords);\n      vec4 v2 = ${glsl.texture2D}(B, TexCoords);\n      vec4 result = ${glslFunc.name}(v1, v2);\n      ${glsl.output} = result;\n    }\n    `;\n\n  return {\n    name: glslFunc.name,\n    inputNames: ['A', 'B'],\n    inputTypes: [textureType, textureType],\n    output: { dims: inputs[0].dims, type: outputTensorType, textureType },\n    shaderSource,\n    hasMain: true,\n  };\n};\n\nexport const add = (handler: WebGLInferenceHandler, inputs: Tensor[]): Tensor[] => [\n  handler.run(createBinaryProgramInfoLoader(handler, inputs, glslAdd()), inputs),\n];\n\nexport const and = (handler: WebGLInferenceHandler, inputs: Tensor[]): Tensor[] => [\n  handler.run(createBinaryProgramInfoLoader(handler, inputs, glslAnd(), 'bool'), inputs),\n];\n\nexport const div = (handler: WebGLInferenceHandler, inputs: Tensor[]): Tensor[] => [\n  handler.run(createBinaryProgramInfoLoader(handler, inputs, glslDiv()), inputs),\n];\n\nexport const equal = (handler: WebGLInferenceHandler, inputs: Tensor[]): Tensor[] => [\n  handler.run(createBinaryProgramInfoLoader(handler, inputs, glslEqual(), 'bool'), inputs),\n];\n\nexport const greater = (handler: WebGLInferenceHandler, inputs: Tensor[]): Tensor[] => [\n  handler.run(createBinaryProgramInfoLoader(handler, inputs, glslGreater(), 'bool'), inputs),\n];\n\nexport const less = (handler: WebGLInferenceHandler, inputs: Tensor[]): Tensor[] => [\n  handler.run(createBinaryProgramInfoLoader(handler, inputs, glslLess(), 'bool'), inputs),\n];\n\nexport const mul = (handler: WebGLInferenceHandler, inputs: Tensor[]): Tensor[] => [\n  handler.run(createBinaryProgramInfoLoader(handler, inputs, glslMul()), inputs),\n];\n\nexport const or = (handler: WebGLInferenceHandler, inputs: Tensor[]): Tensor[] => [\n  handler.run(createBinaryProgramInfoLoader(handler, inputs, glslOr(), 'bool'), inputs),\n];\n\nexport const pow = (handler: WebGLInferenceHandler, inputs: Tensor[]): Tensor[] => [\n  handler.run(createBinaryProgramInfoLoader(handler, inputs, glslPow()), inputs),\n];\n\nexport const pRelu = (handler: WebGLInferenceHandler, inputs: Tensor[]): Tensor[] => [\n  handler.run(createBinaryProgramInfoLoader(handler, inputs, glslPRelu()), inputs),\n];\n\nexport const sub = (handler: WebGLInferenceHandler, inputs: Tensor[]): Tensor[] => [\n  handler.run(createBinaryProgramInfoLoader(handler, inputs, glslSub()), inputs),\n];\n\nexport const xor = (handler: WebGLInferenceHandler, inputs: Tensor[]): Tensor[] => [\n  handler.run(createBinaryProgramInfoLoader(handler, inputs, glslXor(), 'bool'), inputs),\n];\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Graph } from '../../../graph';\nimport { OperatorImplementation, OperatorInitialization } from '../../../operators';\nimport { Tensor } from '../../../tensor';\nimport { ProtoUtil } from '../../../util';\nimport { WebGLInferenceHandler } from '../inference-handler';\n\nexport const cast: OperatorImplementation<Tensor.DataType> = (\n  handler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  to: Tensor.DataType,\n): Tensor[] => {\n  validateInputs(inputs);\n  return [handler.cast(inputs[0], to)];\n};\n\nexport const parseCastAttributes: OperatorInitialization<Tensor.DataType> = (node: Graph.Node): Tensor.DataType =>\n  ProtoUtil.tensorDataTypeFromProto(node.attributes.getInt('to'));\n\nconst validateInputs = (inputs: Tensor[]): void => {\n  if (!inputs || inputs.length !== 1) {\n    throw new Error('Cast requires 1 input.');\n  }\n\n  if (inputs[0].type === 'string') {\n    throw new Error('Invalid input type.');\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Tensor } from '../../../tensor';\nimport { getGlsl } from '../glsl-source';\nimport { WebGLInferenceHandler } from '../inference-handler';\nimport { ProgramInfo, ProgramInfoLoader, ProgramMetadata, TextureType } from '../types';\nimport { getCoordsDataType, getGlChannels } from '../utils';\n\nimport { ConcatAttributes } from './concat';\nimport { getChannels, unpackFromChannel } from './packing-utils';\n\nconst createPackedConcatProgramMetadata = (inputCount: number, cacheHint: string) => ({\n  name: 'Concat (packed)',\n  inputNames: Array.from({ length: inputCount }, (_v, i) => `X${i}`),\n  inputTypes: Array(inputCount).fill(TextureType.packed),\n  cacheHint,\n});\n\nconst createPackedConcatProgramInfo = (\n  handler: WebGLInferenceHandler,\n  metadata: ProgramMetadata,\n  inputs: Tensor[],\n  axis: number,\n): ProgramInfo => {\n  const inputShape = inputs[0].dims.slice();\n  if (axis >= inputShape.length || axis < -1 * inputShape.length) {\n    throw new Error(\"axis specified for concat doesn't match input dimensionality\");\n  }\n  if (axis < 0) {\n    axis = inputShape.length + axis;\n  }\n  // ensure all of the non-concatenated axes match each other\n  // calculate the shape of the output tensor while we do that\n  const outputShape = inputShape.slice(0);\n  for (let i = 1; i < inputs.length; i++) {\n    const dataNShape = inputs[i].dims.slice();\n    for (let axisIndex = 0; axisIndex < inputShape.length; axisIndex++) {\n      // add to the placeholder for computing output shape\n      if (axisIndex === axis) {\n        outputShape[axis] += dataNShape[axisIndex];\n      }\n      // ensure all non-cancatenated axes match each other\n      else if (inputShape[axisIndex] !== dataNShape[axisIndex]) {\n        throw new Error('non concat dimensions must match');\n      }\n    }\n  }\n\n  const rank = outputShape.length;\n  const coords = getChannels('coords', rank);\n  const dtype = getCoordsDataType(rank);\n  const unpackChannel = unpackFromChannel();\n\n  const shapes = inputs.map((i) => i.dims);\n  const channels = getGlChannels(rank);\n  const offsets: number[] = new Array(shapes.length - 1);\n\n  offsets[0] = shapes[0][axis];\n  for (let i = 1; i < offsets.length; i++) {\n    offsets[i] = offsets[i - 1] + shapes[i][axis];\n  }\n\n  const channel = channels[axis];\n  const lastChannels = channels.slice(-2);\n  const allChannels = channels.join();\n\n  let getValueSnippet = `if (${channel} < ${offsets[0]}) {\n        return getChannel(\n            getX0(${allChannels}), vec2(${lastChannels.join()}));\n        }`;\n  for (let i = 1; i < offsets.length; i++) {\n    const shift = offsets[i - 1];\n    getValueSnippet += `\n            if (${channel} < ${offsets[i]}  && ${channel} >= ${offsets[i - 1]}) {\n              return getChannel(\n                getX${i}(${getShiftedChannelsSnippet(channels, channel, shift)}),\n                vec2(${getShiftedChannelsSnippet(lastChannels, channel, shift)}));\n            }`;\n  }\n  const lastIndex = offsets.length;\n  const shift = offsets[offsets.length - 1];\n  getValueSnippet += `\n            return getChannel(\n              getX${lastIndex}(${getShiftedChannelsSnippet(channels, channel, shift)}),\n              vec2(${getShiftedChannelsSnippet(lastChannels, channel, shift)}));`;\n\n  const glsl = getGlsl(handler.session.backend.glContext.version);\n\n  const shaderSource = `\n          ${unpackChannel}\n          float getValue(${channels.map((x) => 'int ' + x)}) {\n            ${getValueSnippet}\n          }\n\n          void main() {\n            ${dtype} coords = getOutputCoords();\n            int lastDim = coords.${channels[rank - 1]};\n            coords.${channels[rank - 1]} = coords.${channels[rank - 2]};\n            coords.${channels[rank - 2]} = lastDim;\n\n            vec4 result = vec4(getValue(${coords}), 0., 0., 0.);\n\n            ${coords[rank - 1]} = ${coords[rank - 1]} + 1;\n            if (${coords[rank - 1]} < ${outputShape[rank - 1]}) {\n              result.g = getValue(${coords});\n            }\n\n            ${coords[rank - 2]} = ${coords[rank - 2]} + 1;\n            if (${coords[rank - 2]} < ${outputShape[rank - 2]}) {\n              result.a = getValue(${coords});\n            }\n\n            ${coords[rank - 1]} = ${coords[rank - 1]} - 1;\n            if (${coords[rank - 2]} < ${outputShape[rank - 2]} &&\n                ${coords[rank - 1]} < ${outputShape[rank - 1]}) {\n              result.b = getValue(${coords});\n            }\n            ${glsl.output} = result;\n          }\n        `;\n\n  return {\n    ...metadata,\n    output: { dims: outputShape, type: inputs[0].type, textureType: TextureType.packed },\n    shaderSource,\n    hasMain: true,\n  };\n};\n\nexport const createPackedConcatProgramInfoLoader = (\n  handler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  attributes: ConcatAttributes,\n): ProgramInfoLoader => {\n  const metadata = createPackedConcatProgramMetadata(inputs.length, attributes.cacheKey);\n  return { ...metadata, get: () => createPackedConcatProgramInfo(handler, metadata, inputs, attributes.axis) };\n};\n\nconst getShiftedChannelsSnippet = (channels: string[], channel: string, shift: number): string => {\n  const channelIdx = channels.indexOf(channel);\n  const res = channels.map((c, idx) => {\n    if (idx === channelIdx) {\n      return `${c} - ${shift}`;\n    } else {\n      return c;\n    }\n  });\n  return res.join();\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { AttributeWithCacheKey, createAttributeWithCacheKey } from '../../../attribute-with-cache-key';\nimport { Graph } from '../../../graph';\nimport { OperatorImplementation, OperatorInitialization } from '../../../operators';\nimport { Tensor } from '../../../tensor';\nimport { WebGLInferenceHandler } from '../inference-handler';\nimport { ProgramInfo, ProgramInfoLoader, ProgramMetadata, TextureType } from '../types';\n\nimport { createPackedConcatProgramInfoLoader } from './concat-packed';\n\nexport interface ConcatAttributes extends AttributeWithCacheKey {\n  readonly axis: number;\n}\n\nexport const concat: OperatorImplementation<ConcatAttributes> = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  attributes: ConcatAttributes,\n): Tensor[] => {\n  validateInputs(inputs);\n  if (inferenceHandler.session.pack && inputs[0].dims.length > 1) {\n    const output = inferenceHandler.run(\n      createPackedConcatProgramInfoLoader(inferenceHandler, inputs, attributes),\n      inputs,\n    );\n    return [output];\n  } else {\n    const output = inferenceHandler.run(\n      createUnpackedConcatProgramInfoLoader(inferenceHandler, inputs, attributes),\n      inputs,\n    );\n    return [output];\n  }\n};\n\nconst createUnpackedConcatProgramMetadata = (inputCount: number, cacheHint: string) => ({\n  name: 'Concat',\n  inputNames: Array.from({ length: inputCount }, (_v, i) => `X${i}`),\n  inputTypes: Array(inputCount).fill(TextureType.unpacked),\n  cacheHint,\n});\n\nconst createUnpackedConcatProgramInfo = (\n  _handler: WebGLInferenceHandler,\n  metadata: ProgramMetadata,\n  inputs: Tensor[],\n  axis: number,\n): ProgramInfo => {\n  const inputShape = inputs[0].dims.slice();\n  if (axis >= inputShape.length || axis < -1 * inputShape.length) {\n    throw new Error(\"axis specified for concat doesn't match input dimensionality\");\n  }\n  if (axis < 0) {\n    axis = inputShape.length + axis;\n  }\n  // ensure all of the non-concatenated axes match each other\n  // calculate the shape of the output tensor while we do that\n  const outputShape = inputShape.slice(0);\n  for (let i = 1; i < inputs.length; i++) {\n    const dataNShape = inputs[i].dims.slice();\n    for (let axisIndex = 0; axisIndex < inputShape.length; axisIndex++) {\n      // add to the placeholder for computing output shape\n      if (axisIndex === axis) {\n        outputShape[axis] += dataNShape[axisIndex];\n      }\n      // ensure all non-cancatenated axes match each other\n      else if (inputShape[axisIndex] !== dataNShape[axisIndex]) {\n        throw new Error('non concat dimensions must match');\n      }\n    }\n  }\n\n  const rank = outputShape.length;\n\n  const sizeInConcatAxis = new Array<number>(inputs.length);\n  let previousSum = 0;\n  for (let i = 0; i < sizeInConcatAxis.length; ++i) {\n    previousSum += inputs[i].dims[axis];\n    sizeInConcatAxis[i] = previousSum;\n  }\n\n  let getTextureIndexWhereDataResidesMethod = '';\n  // in most cases linear search is sufficient, as in most scenarios, only 2 tensors are concatenated\n  if (inputs.length < 5) {\n    getTextureIndexWhereDataResidesMethod = getTextureIndexWhereDataResidesLinearSearch(sizeInConcatAxis);\n  } else {\n    getTextureIndexWhereDataResidesMethod = getTextureIndexWhereDataResidesBinarySearch(sizeInConcatAxis);\n  }\n\n  const fetchDataFromCorrectTextureMethod = getFetchDataFromCorrectTextureMethod(inputs.length, rank);\n  const getSizeInConcatAxisValueFromIndexMethod = getGetSizeInConcatAxisValueFromIndexMethod(sizeInConcatAxis);\n  const shaderSource = `\n        ${fetchDataFromCorrectTextureMethod}\n        ${getSizeInConcatAxisValueFromIndexMethod}\n        ${getTextureIndexWhereDataResidesMethod}\n        float process(int indices[${rank}]) {\n          int textureIndex = getTextureWhereDataResides (indices[${axis}]);\n\n          if(textureIndex != 0) {\n            indices[${axis}] = indices[${axis}] - int(getSizeInConcatAxisValueFromIndex(textureIndex-int(1)));\n          }\n\n          return fetchDataFromCorrectTexture(textureIndex, indices);\n        }`;\n  return {\n    ...metadata,\n    output: { dims: outputShape, type: inputs[0].type, textureType: TextureType.unpacked },\n    shaderSource,\n  };\n};\n\nconst createUnpackedConcatProgramInfoLoader = (\n  handler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  attributes: ConcatAttributes,\n): ProgramInfoLoader => {\n  const metadata = createUnpackedConcatProgramMetadata(inputs.length, attributes.cacheKey);\n  return { ...metadata, get: () => createUnpackedConcatProgramInfo(handler, metadata, inputs, attributes.axis) };\n};\n\nconst getTextureIndexWhereDataResidesLinearSearch = (sizeInConcatAxis: number[]): string => {\n  const searchAxis = sizeInConcatAxis.map(\n    (size, i) => `if(index<${size}) {return ${i};}\n`,\n  );\n  return `int getTextureWhereDataResides(int index) {\n      ${searchAxis.join('')}\n    }`;\n};\n\n// TODO: Implement BinarySearch in GLSL\nconst getTextureIndexWhereDataResidesBinarySearch = (sizeInConcatAxis: number[]): string =>\n  getTextureIndexWhereDataResidesLinearSearch(sizeInConcatAxis);\n\nconst getFetchDataFromCorrectTextureMethod = (numberOfTensors: number, tensorRank: number) => {\n  const codeLines: string[] = [`float fetchDataFromCorrectTexture(int textureIndex, int indices[${tensorRank}]) {`];\n  for (let i = 0; i < numberOfTensors; ++i) {\n    if (i === 0) {\n      codeLines.push('\\t' + `if (textureIndex == ${i}) { return _X${i}(indices); }`);\n    } else if (i === numberOfTensors - 1) {\n      codeLines.push('\\t' + `else { return _X${i}(indices); }`);\n    } else {\n      codeLines.push('\\t' + `else if (textureIndex == ${i}) { return _X${i}(indices); }`);\n    }\n  }\n  codeLines.push('\\t' + '}');\n  return codeLines.join('\\n');\n};\n\nconst getGetSizeInConcatAxisValueFromIndexMethod = (sizeInConcatAxis: number[]): string => {\n  const codeLines: string[] = ['int getSizeInConcatAxisValueFromIndex(int index) {'];\n  for (let i = 0; i < sizeInConcatAxis.length; ++i) {\n    if (i === 0) {\n      codeLines.push('\\t' + `if (index == ${i}) { return ${sizeInConcatAxis[i]}; }`);\n    } else if (i === sizeInConcatAxis.length - 1) {\n      codeLines.push('\\t' + `else { return ${sizeInConcatAxis[i]}; }`);\n    } else {\n      codeLines.push('\\t' + `else if (index == ${i}) { return ${sizeInConcatAxis[i]}; }`);\n    }\n  }\n  codeLines.push('\\t' + '}');\n\n  return codeLines.join('\\n');\n};\n\nexport const parseConcatAttributes: OperatorInitialization<ConcatAttributes> = (node: Graph.Node): ConcatAttributes =>\n  createAttributeWithCacheKey({ axis: node.attributes.getInt('axis') });\n\nconst validateInputs = (inputs: Tensor[]): void => {\n  if (!inputs || inputs.length < 1) {\n    throw new Error('too few inputs');\n  }\n\n  const inputType = inputs[0].type;\n  const inputDimensionality = inputs[0].dims.length;\n\n  // TODO: Support string concat\n  if (inputType === 'string') {\n    throw new Error('string tensor is not supported yet');\n  }\n\n  for (const input of inputs) {\n    // make sure types of all inputs match\n    if (input.type !== inputType) {\n      throw new Error('input tensors should be one type');\n    }\n\n    // make sure the dimensionality of all inputs are the same\n    if (input.dims.length !== inputDimensionality) {\n      throw new Error('input tensors should have the same shape');\n    }\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { AttributeWithCacheKey, createAttributeWithCacheKey } from '../../../attribute-with-cache-key';\nimport { Graph } from '../../../graph';\nimport { Tensor } from '../../../tensor';\nimport { MAX_CLIP, MIN_CLIP } from '../../../util';\nimport { FunctionType, GlslValueFunction } from '../glsl-definitions';\nimport { getGlsl } from '../glsl-source';\nimport { WebGLInferenceHandler } from '../inference-handler';\nimport { ProgramInfo, ProgramInfoLoader, ProgramMetadata, TextureType } from '../types';\n\nexport function glslAbs(): GlslValueFunction {\n  return glslBuiltinUnary('abs');\n}\nexport function glslAcos(): GlslValueFunction {\n  return glslBuiltinUnary('acos');\n}\nexport function glslAsin(): GlslValueFunction {\n  return glslBuiltinUnary('asin');\n}\nexport function glslAtan(): GlslValueFunction {\n  return glslBuiltinUnary('atan');\n}\nexport function glslCeil(): GlslValueFunction {\n  return glslBuiltinUnary('ceil');\n}\nexport function glslCos(): GlslValueFunction {\n  return glslBuiltinUnary('cos');\n}\nexport function glslElu(alpha: number): GlslValueFunction {\n  const name = 'elu';\n  const body = `\n  const float alpha = float(${alpha});\n\n  float ${name}_(float a) {\n    return a >= 0.0 ? a: (exp(a) - 1.0) * alpha;\n  }\n  vec4 ${name}_(vec4 v) {\n    return vec4(${name}_(v.x), ${name}_(v.y), ${name}_(v.z), ${name}_(v.w));\n  }\n  `;\n  return { body, name, type: FunctionType.ValueBased };\n}\nexport function glslExp(): GlslValueFunction {\n  return glslBuiltinUnary('exp');\n}\nexport function glslFloor(): GlslValueFunction {\n  return glslBuiltinUnary('floor');\n}\nexport function glslClip(min: number, max: number): GlslValueFunction {\n  const name = 'clip';\n  const body = `\n  const float min = float(${min});\n  const float max = float(${max});\n\n  float ${name}_(float a) {\n    return clamp(a, min, max);\n  }\n  vec4 ${name}_(vec4 v) {\n    return clamp(v, min, max);\n  }\n  `;\n  return { body, name, type: FunctionType.ValueBased };\n}\nexport function glslIdentity(): GlslValueFunction {\n  const name = 'indentity';\n  const body = `\n  float ${name}_(float a) {\n    return a;\n  }\n  vec4 ${name}_(vec4 v) {\n    return v;\n  }\n  `;\n  return { body, name, type: FunctionType.ValueBased };\n}\nexport function glslLeakyRelu(alpha: number): GlslValueFunction {\n  const name = 'leakyRelu';\n  const body = `\n  const float alpha = float(${alpha});\n\n  float ${name}_(float a) {\n    return a < 0.0 ? a * alpha : a;\n  }\n  vec4 ${name}_(vec4 v) {\n    return vec4(${name}_(v.x), ${name}_(v.y), ${name}_(v.z), ${name}_(v.w));\n  }\n  `;\n  return { body, name, type: FunctionType.ValueBased };\n}\nexport function glslLog(): GlslValueFunction {\n  return glslBuiltinUnary('log');\n}\nexport function glslNeg(): GlslValueFunction {\n  const name = 'neg';\n  const body = `\n  float ${name}_(float a) {\n    return -a;\n  }\n  vec4 ${name}_(vec4 v) {\n    return -v;\n  }\n  `;\n  return { body, name, type: FunctionType.ValueBased };\n}\nexport function glslNot(): GlslValueFunction {\n  const name = 'not';\n  const body = `\n  float ${name}_(float a) {\n    return float( ! bool(a) );\n  }\n  bool ${name}_(bool a) {\n    return !a;\n  }\n  vec4 ${name}_(vec4 v) {\n    return vec4(!bool(v.x), !bool(v.y), !bool(v.z), !bool(v.w));\n  }\n  bvec4 ${name}_(bvec4 v) {\n    return bvec4(!v.x, !v.y, !v.z, !v.w);\n  }\n  `;\n  return { body, name, type: FunctionType.ValueBased };\n}\nexport function glslSin(): GlslValueFunction {\n  return glslBuiltinUnary('sin');\n}\nexport function glslRelu(): GlslValueFunction {\n  const name = 'relu';\n  const body = `\n  float ${name}_(float a) {\n    return max( a, 0.0 );\n  }\n  vec4 ${name}_(vec4 v) {\n    return max( v, 0.0 );\n  }\n  `;\n  return { body, name, type: FunctionType.ValueBased };\n}\nexport function glslSigmoid(): GlslValueFunction {\n  const name = 'sigmoid';\n  const body = `\n  float ${name}_(float a) {\n    return 1.0 / (1.0 + exp(-a));\n  }\n  vec4 ${name}_(vec4 v) {\n    return 1.0 / (1.0 + exp(-v));\n  }\n  `;\n  return { body, name, type: FunctionType.ValueBased };\n}\nexport function glslSqrt(): GlslValueFunction {\n  return glslBuiltinUnary('sqrt');\n}\nexport function glslTan(): GlslValueFunction {\n  return glslBuiltinUnary('tan');\n}\nexport function glslTanh(): GlslValueFunction {\n  const name = 'tanh';\n  const body = `\n  float ${name}_(float a) {\n    a = clamp(a, -10., 10.);\n    a = exp(2.*a);\n    return (a - 1.) / (a + 1.);\n  }\n  vec4 ${name}_(vec4 v) {\n    v = clamp(v, -10., 10.);\n    v = exp(2.*v);\n    return (v - 1.) / (v + 1.);\n  }\n  `;\n  return { body, name, type: FunctionType.ValueBased };\n}\nfunction glslBuiltinUnary(name: string): GlslValueFunction {\n  const body = `\n  float ${name}_(float a) {\n    return ${name}(a);\n  }\n  vec4 ${name}_(vec4 v) {\n    return ${name}(v);\n  }\n  `;\n  return { body, name, type: FunctionType.ValueBased };\n}\n\n/////\n/////\n/////\n\nconst createElementwiseProgramInfo = (\n  handler: WebGLInferenceHandler,\n  metadata: ProgramMetadata,\n  input: Tensor,\n  glslFunc: GlslValueFunction,\n): ProgramInfo => {\n  const textureType = handler.session.pack ? TextureType.packed : TextureType.unpacked;\n  const glsl = getGlsl(handler.session.backend.glContext.version);\n  return {\n    ...metadata,\n    output: { dims: input.dims, type: input.type, textureType },\n    shaderSource: `\n     ${glslFunc.body}\n     void main() {\n       vec4 v = ${glsl.texture2D}(A, TexCoords);\n       v = ${glslFunc.name}_(v);\n       ${glsl.output} = v;\n     }\n     `,\n    hasMain: true,\n  };\n};\n\nconst createElementwiseProgramInfoLoader = (\n  handler: WebGLInferenceHandler,\n  input: Tensor,\n  glslFunc: GlslValueFunction,\n  cacheKey?: string,\n): ProgramInfoLoader => {\n  const textureType = handler.session.pack ? TextureType.packed : TextureType.unpacked;\n  const metadata = { name: glslFunc.name, inputTypes: [textureType], inputNames: ['A'], cacheHint: cacheKey };\n  return { ...metadata, get: () => createElementwiseProgramInfo(handler, metadata, input, glslFunc) };\n};\n\nexport const abs = (handler: WebGLInferenceHandler, inputs: Tensor[]): Tensor[] => [\n  handler.run(createElementwiseProgramInfoLoader(handler, inputs[0], glslAbs()), inputs),\n];\n\nexport const acos = (handler: WebGLInferenceHandler, inputs: Tensor[]): Tensor[] => [\n  handler.run(createElementwiseProgramInfoLoader(handler, inputs[0], glslAcos()), inputs),\n];\n\nexport const asin = (handler: WebGLInferenceHandler, inputs: Tensor[]): Tensor[] => [\n  handler.run(createElementwiseProgramInfoLoader(handler, inputs[0], glslAsin()), inputs),\n];\n\nexport const atan = (handler: WebGLInferenceHandler, inputs: Tensor[]): Tensor[] => [\n  handler.run(createElementwiseProgramInfoLoader(handler, inputs[0], glslAtan()), inputs),\n];\n\nexport interface ClipAttributes extends AttributeWithCacheKey {\n  readonly min: number;\n  readonly max: number;\n}\n\nexport const clip = (handler: WebGLInferenceHandler, inputs: Tensor[], attributes: ClipAttributes): Tensor[] => [\n  handler.run(\n    createElementwiseProgramInfoLoader(\n      handler,\n      inputs[0],\n      glslClip(attributes.min, attributes.max),\n      attributes.cacheKey,\n    ),\n    inputs,\n  ),\n];\n\nexport const parseClipAttributes = (node: Graph.Node): ClipAttributes =>\n  createAttributeWithCacheKey({\n    min: node.attributes.getFloat('min', MIN_CLIP),\n    max: node.attributes.getFloat('max', MAX_CLIP),\n  });\n\nexport const clipV11 = (handler: WebGLInferenceHandler, inputs: Tensor[]): Tensor[] => {\n  const attributes = generateClipAttributesFromInputs(handler, inputs);\n  return clip(handler, [inputs[0]], attributes);\n};\n\nconst generateClipAttributesFromInputs = (handler: WebGLInferenceHandler, inputs: Tensor[]): ClipAttributes => {\n  if (\n    inputs.length >= 3 &&\n    (!handler.session.isInitializer(inputs[1].dataId) || !handler.session.isInitializer(inputs[2].dataId))\n  ) {\n    throw new Error('dynamic clip attributes are not allowed');\n  }\n\n  const min = inputs.length >= 3 ? inputs[1].numberData[0] : MIN_CLIP;\n  const max = inputs.length >= 3 ? inputs[2].numberData[0] : MAX_CLIP;\n  return createAttributeWithCacheKey({ min, max });\n};\n\nexport const ceil = (handler: WebGLInferenceHandler, inputs: Tensor[]): Tensor[] => [\n  handler.run(createElementwiseProgramInfoLoader(handler, inputs[0], glslCeil()), inputs),\n];\n\nexport const cos = (handler: WebGLInferenceHandler, inputs: Tensor[]): Tensor[] => [\n  handler.run(createElementwiseProgramInfoLoader(handler, inputs[0], glslCos()), inputs),\n];\n\nexport interface EluAttributes extends AttributeWithCacheKey {\n  readonly alpha: number;\n}\n\nexport const elu = (handler: WebGLInferenceHandler, inputs: Tensor[], attributes: EluAttributes): Tensor[] => [\n  handler.run(\n    createElementwiseProgramInfoLoader(handler, inputs[0], glslElu(attributes.alpha), attributes.cacheKey),\n    inputs,\n  ),\n];\n\nexport const parseEluAttributes = (node: Graph.Node): EluAttributes =>\n  createAttributeWithCacheKey({ alpha: node.attributes.getFloat('alpha', 1.0) });\n\nexport const exp = (handler: WebGLInferenceHandler, inputs: Tensor[]): Tensor[] => [\n  handler.run(createElementwiseProgramInfoLoader(handler, inputs[0], glslExp()), inputs),\n];\n\nexport const floor = (handler: WebGLInferenceHandler, inputs: Tensor[]): Tensor[] => [\n  handler.run(createElementwiseProgramInfoLoader(handler, inputs[0], glslFloor()), inputs),\n];\n\nexport const identity = (handler: WebGLInferenceHandler, inputs: Tensor[]): Tensor[] => [\n  handler.run(createElementwiseProgramInfoLoader(handler, inputs[0], glslIdentity()), inputs),\n];\n\nexport interface LeakyReluAttributes extends AttributeWithCacheKey {\n  readonly alpha: number;\n}\n\nexport const leakyRelu = (\n  handler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  attributes: LeakyReluAttributes,\n): Tensor[] => [\n  handler.run(\n    createElementwiseProgramInfoLoader(handler, inputs[0], glslLeakyRelu(attributes.alpha), attributes.cacheKey),\n    inputs,\n  ),\n];\n\nexport const parseLeakyReluAttributes = (node: Graph.Node): LeakyReluAttributes =>\n  createAttributeWithCacheKey({ alpha: node.attributes.getFloat('alpha', 0.01) });\n\nexport const log = (handler: WebGLInferenceHandler, inputs: Tensor[]): Tensor[] => [\n  handler.run(createElementwiseProgramInfoLoader(handler, inputs[0], glslLog()), inputs),\n];\n\nexport const neg = (handler: WebGLInferenceHandler, inputs: Tensor[]): Tensor[] => [\n  handler.run(createElementwiseProgramInfoLoader(handler, inputs[0], glslNeg()), inputs),\n];\n\nexport const not = (handler: WebGLInferenceHandler, inputs: Tensor[]): Tensor[] => [\n  handler.run(createElementwiseProgramInfoLoader(handler, inputs[0], glslNot()), inputs),\n];\n\nexport const relu = (handler: WebGLInferenceHandler, inputs: Tensor[]): Tensor[] => [\n  handler.run(createElementwiseProgramInfoLoader(handler, inputs[0], glslRelu()), inputs),\n];\n\nexport const sigmoid = (handler: WebGLInferenceHandler, inputs: Tensor[]): Tensor[] => [\n  handler.run(createElementwiseProgramInfoLoader(handler, inputs[0], glslSigmoid()), inputs),\n];\n\nexport const sin = (handler: WebGLInferenceHandler, inputs: Tensor[]): Tensor[] => [\n  handler.run(createElementwiseProgramInfoLoader(handler, inputs[0], glslSin()), inputs),\n];\n\nexport const sqrt = (handler: WebGLInferenceHandler, inputs: Tensor[]): Tensor[] => [\n  handler.run(createElementwiseProgramInfoLoader(handler, inputs[0], glslSqrt()), inputs),\n];\n\nexport const tan = (handler: WebGLInferenceHandler, inputs: Tensor[]): Tensor[] => [\n  handler.run(createElementwiseProgramInfoLoader(handler, inputs[0], glslTan()), inputs),\n];\n\nexport const tanh = (handler: WebGLInferenceHandler, inputs: Tensor[]): Tensor[] => [\n  handler.run(createElementwiseProgramInfoLoader(handler, inputs[0], glslTanh()), inputs),\n];\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Attribute } from '../../../attribute';\nimport { MAX_CLIP, MIN_CLIP } from '../../../util';\nimport { GlslValueFunction } from '../glsl-definitions';\n\nimport { glslClip, glslRelu, glslSigmoid } from './unary-op';\n\nexport interface InternalActivationAttributes {\n  readonly activation: string;\n  readonly clipMin?: number;\n  readonly clipMax?: number;\n  readonly activationCacheKey: string;\n}\n\nexport function getActivationSnippet(attributes: InternalActivationAttributes) {\n  let func: GlslValueFunction;\n  switch (attributes.activation) {\n    case 'Relu':\n      func = glslRelu();\n      break;\n    case 'Sigmoid':\n      func = glslSigmoid();\n      break;\n    case 'Clip':\n      func = glslClip(attributes.clipMin!, attributes.clipMax!);\n      break;\n    // TODO: adding other activations that can be fused.\n    default:\n      return { activationFunction: '', applyActivation: '' };\n  }\n\n  const activationName = func.name;\n  const activationFunction = func.body;\n  const applyActivation = `value = ${activationName}_(value);`;\n  return { activationFunction, applyActivation };\n}\n\nexport const parseInternalActivationAttributes = (attributes: Attribute): InternalActivationAttributes => {\n  const activation = attributes.getString('activation', '');\n\n  if (activation === 'Clip') {\n    const [clipMin, clipMax] = attributes.getFloats('activation_params', [MIN_CLIP, MAX_CLIP]);\n    return { activation, clipMax, clipMin, activationCacheKey: `${activation}:${clipMin},${clipMax}` };\n  }\n  return { activation, activationCacheKey: activation };\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Logger } from '../../../instrument';\nimport { Tensor } from '../../../tensor';\nimport { getGlsl } from '../glsl-source';\nimport { WebGLInferenceHandler } from '../inference-handler';\nimport { ProgramInfo, ProgramInfoLoader, ProgramMetadata, TextureType } from '../types';\n\nimport { calculateOutputShape, ConvAttributes } from './conv';\nimport { getActivationSnippet } from './fuse-utils';\n\nconst createUnpackedGroupedConvProgramMetadata = (hasBias: boolean, cacheHint: string): ProgramMetadata => ({\n  name: 'GroupedConv',\n  inputNames: hasBias ? ['X', 'W', 'Bias'] : ['X', 'W'],\n  inputTypes: hasBias\n    ? [TextureType.unpacked, TextureType.unpacked, TextureType.unpacked]\n    : [TextureType.unpacked, TextureType.unpacked],\n  cacheHint,\n});\n\nconst createUnpackedGroupedConvProgramInfo = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: readonly Tensor[],\n  metadata: ProgramMetadata,\n  attributes: ConvAttributes,\n): ProgramInfo => {\n  const hasBias = inputs.length > 2;\n  const processBias = hasBias ? 'value += getBias(output_channel);' : '';\n  const xShape = inputs[0].dims.slice();\n  const wShape = inputs[1].dims.slice();\n  const outputChannelsPerGroup = wShape[0] / attributes.group;\n  Logger.verbose(\n    'GroupedConv',\n    `autpPad:${attributes.autoPad}, dilations:${attributes.dilations}, group:${attributes.group}, kernelShape:${\n      attributes.kernelShape\n    }, pads:${attributes.pads}, strides:${attributes.strides}`,\n  );\n  const outputShape = calculateOutputShape(xShape, wShape, attributes.dilations, attributes.pads, attributes.strides);\n  const glsl = getGlsl(inferenceHandler.session.backend.glContext.version);\n  const { activationFunction, applyActivation } = getActivationSnippet(attributes);\n\n  const shaderSource = `\n  const ivec2 strides = ivec2(${attributes.strides[0]}, ${attributes.strides[1]});\n  const ivec2 pads = ivec2(${attributes.pads[0]}, ${attributes.pads[1]});\n  ${activationFunction}\n  void main() {\n    ivec4 coords = getOutputCoords();\n    int batch = coords.x;\n    int output_channel = coords.y;\n    ivec2 xRCCorner = coords.zw * strides - pads;\n    int group_id = output_channel / ${outputChannelsPerGroup};\n\n    float value = 0.0;\n    for (int wInChannel = 0; wInChannel < ${wShape[1]}; wInChannel++) {\n      int input_channel = group_id * ${wShape[1]} + wInChannel;\n      for (int wHeight = 0; wHeight < ${wShape[2]}; wHeight++) {\n        int xHeight = xRCCorner.x + wHeight * ${attributes.dilations[0]};\n\n        if (xHeight < 0 || xHeight >= ${xShape[2]}) {\n          continue;\n        }\n\n        for (int wWidth = 0; wWidth < ${wShape[3]}; wWidth++) {\n          int xWidth = xRCCorner.y + wWidth * ${attributes.dilations[1]};\n          if (xWidth < 0 || xWidth >= ${xShape[3]}) {\n            continue;\n          }\n\n          float xVal = getX(batch, input_channel, xWidth, xHeight);\n          float wVal = getW(output_channel, wInChannel, wWidth, wHeight);\n          value += xVal*wVal;\n        }\n      }\n    }\n    ${processBias}\n    ${applyActivation}\n    ${glsl.output} = vec4(value, .0, .0, .0);\n  }\n`;\n  return {\n    ...metadata,\n    output: { dims: outputShape, type: inputs[0].type, textureType: TextureType.unpacked },\n    shaderSource,\n    hasMain: true,\n  };\n};\n\nexport const createUnpackedGroupedConvProgramInfoLoader = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: readonly Tensor[],\n  attributes: ConvAttributes,\n): ProgramInfoLoader => {\n  const metadata = createUnpackedGroupedConvProgramMetadata(inputs.length > 2, attributes.cacheKey);\n  return {\n    ...metadata,\n    get: () => createUnpackedGroupedConvProgramInfo(inferenceHandler, inputs, metadata, attributes),\n  };\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Tensor } from '../../../tensor';\nimport { getGlsl } from '../glsl-source';\nimport { WebGLInferenceHandler } from '../inference-handler';\nimport { ProgramInfo, ProgramInfoLoader, ProgramMetadata, TextureType } from '../types';\n\nimport { ConvAttributes } from './conv';\nimport { unpackFromChannel } from './packing-utils';\n\nconst createPackedIm2ColProgramMetadata = (cacheHint: string) => ({\n  name: 'Im2Col (packed)',\n  inputNames: ['A'],\n  inputTypes: [TextureType.packed],\n  cacheHint,\n});\n\nconst createPackedIm2ColProgramInfo = (\n  inferenceHandler: WebGLInferenceHandler,\n  metadata: ProgramMetadata,\n  x: Tensor,\n  w: Tensor,\n  outputShape: readonly number[],\n  attributes: ConvAttributes,\n): ProgramInfo => {\n  const xshape = x.dims;\n  const wshape = w.dims;\n  const rowDim = 2;\n  const colDim = 3;\n  const rank = outputShape.length;\n  const im2colShape = [wshape[1] * wshape[2] * wshape[3], outputShape[2] * outputShape[3]];\n  const kernelSize = wshape[2] * wshape[3];\n  const unpackChannel = unpackFromChannel();\n  const glsl = getGlsl(inferenceHandler.session.backend.glContext.version);\n  let unrolled = '';\n\n  for (let row = 0; row <= 1; row++) {\n    for (let col = 0; col <= 1; col++) {\n      unrolled += `\n            blockIndex = rc.x + ${col};\n            pos = rc.y + ${row};\n\n            if(blockIndex < ${im2colShape[1]} && pos < ${im2colShape[0]}) {\n              offsetY = int(blockIndex / (${outputShape[rank - 1]})) * ${attributes.strides[0]} -\n                ${attributes.pads[0]};\n              d0 = offsetY + ${attributes.dilations[0]} * (imod(pos, ${kernelSize}) / ${wshape[2]});\n\n              if(d0 < ${xshape[rowDim]} && d0 >= 0) {\n                offsetX = imod(blockIndex, ${outputShape[rank - 1]}) * ${attributes.strides[1]} -\n                  ${attributes.pads[1]};\n                d1 = offsetX + ${attributes.dilations[1]} * imod(imod(pos, ${kernelSize}), ${wshape[2]});\n\n                if(d1 < ${xshape[colDim]} && d1 >= 0) {\n\n                  ch = int(float(pos)/ ${kernelSize}.);\n                    innerDims = vec2(d0, d1);\n                    result[${row * 2 + col}] = getChannel(\n                      getA(0, ch, int(innerDims.x),\n                      int(innerDims.y)), innerDims);\n                }\n              }\n            }\n\n          `;\n    }\n  }\n\n  const shaderSource = `\n      ${unpackChannel}\n\n      void main() {\n        ivec2 rc = getOutputCoords();\n          vec4 result = vec4(0.0);\n          int blockIndex, pos, offsetY, d0, offsetX, d1, ch;\n          vec2 innerDims;\n          ${unrolled}\n          ${glsl.output} = result;\n      }\n            `;\n  return {\n    ...metadata,\n    output: { dims: im2colShape, type: x.type, textureType: TextureType.packed },\n    shaderSource,\n    hasMain: true,\n  };\n};\n\nexport const createPackedIm2ColProgramInfoLoader = (\n  inferenceHandler: WebGLInferenceHandler,\n  x: Tensor,\n  w: Tensor,\n  outputShape: readonly number[],\n  attributes: ConvAttributes,\n): ProgramInfoLoader => {\n  const metadata = createPackedIm2ColProgramMetadata(attributes.cacheKey);\n  return {\n    ...metadata,\n    get: () => createPackedIm2ColProgramInfo(inferenceHandler, metadata, x, w, outputShape, attributes),\n  };\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Graph } from '../../../graph';\nimport { OperatorImplementation, OperatorInitialization } from '../../../operators';\nimport { Tensor } from '../../../tensor';\nimport { BroadcastUtil, ShapeUtil } from '../../../util';\nimport { WebGLInferenceHandler } from '../inference-handler';\nimport { ProgramInfo, ProgramInfoLoader, ProgramMetadata, TextureType } from '../types';\nimport { getCoordsDataType, getGlChannels } from '../utils';\n\nimport { getActivationSnippet, InternalActivationAttributes, parseInternalActivationAttributes } from './fuse-utils';\nimport { createPackedMatmulProgramInfoLoader } from './matmul-pack';\n\nexport const matMul: OperatorImplementation<InternalActivationAttributes> = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  attributes: InternalActivationAttributes,\n): Tensor[] => {\n  validateInputs(inputs);\n\n  if (inferenceHandler.session.pack) {\n    return [inferenceHandler.run(createPackedMatmulProgramInfoLoader(inferenceHandler, inputs, attributes), inputs)];\n  } else {\n    return [inferenceHandler.run(createMatmulProgramInfoLoader(inputs, attributes), inputs)];\n  }\n};\n\nexport const parseMatMulAttributes: OperatorInitialization<InternalActivationAttributes> = (\n  node: Graph.Node,\n): InternalActivationAttributes => parseInternalActivationAttributes(node.attributes);\n\nconst createMatmulProgramMetadata = (hasBias: boolean, cacheHint: string) => ({\n  name: 'MatMul',\n  inputNames: hasBias ? ['A', 'B', 'Bias'] : ['A', 'B'],\n  inputTypes: hasBias\n    ? [TextureType.unpacked, TextureType.unpacked, TextureType.unpacked]\n    : [TextureType.unpacked, TextureType.unpacked],\n  cacheHint,\n});\n\nfunction createMatmulProgramInfo(\n  metadata: ProgramMetadata,\n  inputs: Tensor[],\n  activationAttributes: InternalActivationAttributes,\n): ProgramInfo {\n  const aShape = inputs[0].dims;\n  const bShape = inputs[1].dims;\n  const outputShape = BroadcastUtil.calcShape(aShape, bShape, true);\n  if (!outputShape) {\n    throw new Error(\"Can't use matmul on the given tensors\");\n  }\n  const coordsDataType = getCoordsDataType(outputShape.length);\n  const allGlChannels = getGlChannels();\n  const { activationFunction, applyActivation } = getActivationSnippet(activationAttributes);\n\n  const hasBias = inputs.length > 2;\n  const processBias = hasBias ? 'value += getBiasForMatmul();' : '';\n  const getBiasForMatmulSnippet = hasBias\n    ? `${getBiasForMatmul(coordsDataType, allGlChannels, inputs[2].dims, outputShape, false)}`\n    : '';\n\n  const rank = outputShape.length;\n  const arank = aShape.length;\n  const brank = bShape.length;\n  const sharedDim = aShape[aShape.length - 1];\n  const shaderSource = `\n    ${activationFunction}\n    ${getBiasForMatmulSnippet}\n    float process(int indices[${rank}]) {\n        int a[${arank}];\n        int b[${brank}];\n        bcastMatmulIndices_A(indices, a);\n        bcastMatmulIndices_B(indices, b);\n\n        float value;\n        for (int k=0; k<${sharedDim}; ++k) {\n            a[${arank - 1}] = k;\n            b[${brank - 2}] = k;\n            value += _A(a) * _B(b);\n        }\n        ${processBias}\n        ${applyActivation}\n        return value;\n    }`;\n  return {\n    ...metadata,\n    output: { dims: outputShape, type: inputs[0].type, textureType: TextureType.unpacked },\n    shaderSource,\n  };\n}\n\nexport function createMatmulProgramInfoLoader(\n  inputs: Tensor[],\n  activationAttributes: InternalActivationAttributes,\n): ProgramInfoLoader {\n  const metadata = createMatmulProgramMetadata(inputs.length > 2, activationAttributes.activationCacheKey);\n  return { ...metadata, get: () => createMatmulProgramInfo(metadata, inputs, activationAttributes) };\n}\n\nconst validateInputs = (inputs: Tensor[]): void => {\n  if (!inputs || inputs.length !== 2) {\n    throw new Error('MatMul requires 2 inputs.');\n  }\n\n  if (inputs[0].dims[inputs[0].dims.length - 1] !== inputs[1].dims[inputs[1].dims.length - 2]) {\n    throw new Error('shared dimension does not match.');\n  }\n\n  if (\n    (inputs[0].type !== 'float32' && inputs[0].type !== 'float64') ||\n    (inputs[1].type !== 'float32' && inputs[1].type !== 'float64')\n  ) {\n    throw new Error('inputs should be float type');\n  }\n\n  if (inputs[0].type !== inputs[1].type) {\n    throw new Error('inputs types should match');\n  }\n};\n\nexport function getBiasForMatmul(\n  coordsDataType: string,\n  allGlChannels: readonly string[],\n  inShape: readonly number[],\n  outShape: readonly number[],\n  isPacked: boolean,\n): string {\n  let unpackedCoordsSnippet = '';\n  const inRank = inShape.length;\n  const outRank = outShape.length;\n  const rankDiff = outRank - inRank;\n  if (outRank < 2 && inRank > 0) {\n    unpackedCoordsSnippet = 'coords';\n  } else {\n    unpackedCoordsSnippet = inShape.map((_s, i) => `coords.${allGlChannels[i + rankDiff]}`).join(', ');\n  }\n  const broadcastDims = BroadcastUtil.getBroadcastDims(inShape, outShape);\n  const coordsSnippet = broadcastDims.map((d) => `coords.${allGlChannels[d + rankDiff]} = 0;`).join('\\n');\n  const inSize = ShapeUtil.size(inShape);\n  const isInputScalar = inSize === 1;\n  let output = 'vec4(outputValue.xx, outputValue.yy)';\n  if (isInputScalar) {\n    output = 'vec4(outputValue.x)';\n  }\n  const getBiasForMatmulSource = isPacked\n    ? `\nvec4 getBiasForMatmul() {\n  ${coordsDataType} coords = getOutputCoords();\n  ${coordsSnippet}\n  vec4 outputValue = getBias(${unpackedCoordsSnippet});\n  return ${output};\n}`\n    : `\nfloat getBiasForMatmul() {\n  ${coordsDataType} coords = getOutputCoords();\n  ${coordsSnippet}\n  return getBias(coords.x);\n}`;\n\n  return getBiasForMatmulSource;\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Tensor } from '../../../tensor';\nimport { BroadcastUtil, ShapeUtil } from '../../../util';\nimport { getGlsl } from '../glsl-source';\nimport { WebGLInferenceHandler } from '../inference-handler';\nimport { ProgramInfo, ProgramInfoLoader, ProgramMetadata, TextureType } from '../types';\nimport { getCoordsDataType, getGlChannels } from '../utils';\n\nimport { getActivationSnippet, InternalActivationAttributes } from './fuse-utils';\nimport { getBiasForMatmul } from './matmul';\n\nconst createPackedMatmulProgramMetadata = (hasBias: boolean, cacheHint: string) => ({\n  name: 'MatMul (packed)',\n  inputNames: hasBias ? ['A', 'B', 'Bias'] : ['A', 'B'],\n  inputTypes: hasBias\n    ? [TextureType.packed, TextureType.packed, TextureType.packed]\n    : [TextureType.packed, TextureType.packed],\n  cacheHint,\n});\n\nconst createPackedMatmulProgramInfo = (\n  inferenceHandler: WebGLInferenceHandler,\n  metadata: ProgramMetadata,\n  inputs: Tensor[],\n  activationAttributes: InternalActivationAttributes,\n): ProgramInfo => {\n  const hasBias = inputs.length > 2;\n  const processBias = hasBias ? 'value += getBiasForMatmul();' : '';\n  const aShape = inputs[0].dims;\n  const bShape = inputs[1].dims;\n  const outputShape = BroadcastUtil.calcShape(aShape, bShape, true);\n  const isBroadcast = !ShapeUtil.areEqual(inputs[0].dims, inputs[1].dims);\n\n  if (!outputShape) {\n    throw new Error(\"Can't use matmul on the given tensors\");\n  }\n  const sharedDim = aShape[aShape.length - 1];\n  const sharedDimIndex = Math.ceil(sharedDim / 2);\n  const aRank = aShape.length;\n  const bRank = bShape.length;\n\n  const glsl = getGlsl(inferenceHandler.session.backend.glContext.version);\n  const coordsDataType = getCoordsDataType(outputShape.length);\n  const outRank = outputShape.length;\n  const allGlChannels = getGlChannels();\n  const { activationFunction, applyActivation } = getActivationSnippet(activationAttributes);\n\n  const getBiasForMatmulSnippet = hasBias\n    ? `${getBiasForMatmul(coordsDataType, allGlChannels, inputs[2].dims, outputShape, true)}`\n    : '';\n\n  const getBcastedSamplerForMatmulSnippet = isBroadcast\n    ? `${getBcastSamplerForMatmul(coordsDataType, allGlChannels, inputs, outputShape)}`\n    : '';\n\n  const getSamplerAInLoopSnippet = isBroadcast ? 'getAAtOutCoordsMatmul(i)' : `getA(${getA(allGlChannels, aRank)})`;\n  const getSamplerBInLoopSnippet = isBroadcast ? 'getBAtOutCoordsMatmul(i)' : `getB(${getB(allGlChannels, bRank)})`;\n  const getOutputCoordsSnippet = isBroadcast\n    ? ''\n    : `${coordsDataType} rc =\n          getOutputCoords(); int lastDim = rc.${allGlChannels[outRank - 1]}; rc.${allGlChannels[outRank - 1]} =\n          rc.${allGlChannels[outRank - 2]}; rc.${allGlChannels[outRank - 2]} = lastDim;\n      `;\n  const shaderSource = `\n            ${getBcastedSamplerForMatmulSnippet}\n            ${getBiasForMatmulSnippet}\n            ${activationFunction}\n            void main() {\n              ${getOutputCoordsSnippet}\n\n              vec4 value = vec4(0);\n              for (int i = 0; i < ${sharedDimIndex}; i++) {\n                vec4 a = ${getSamplerAInLoopSnippet};\n                vec4 b = ${getSamplerBInLoopSnippet};\n\n                value += (a.rrbb * b.rgrg);\n                value += (a.ggaa * b.baba);\n              }\n              ${processBias}\n              ${applyActivation}\n              ${glsl.output} = value;\n            }`;\n  return {\n    ...metadata,\n    output: { dims: outputShape, type: inputs[0].type, textureType: TextureType.packed },\n    shaderSource,\n    hasMain: true,\n  };\n};\n\nexport const createPackedMatmulProgramInfoLoader = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  activationAttributes: InternalActivationAttributes,\n): ProgramInfoLoader => {\n  const metadata = createPackedMatmulProgramMetadata(inputs.length > 2, activationAttributes.activationCacheKey);\n  return {\n    ...metadata,\n    get: () => createPackedMatmulProgramInfo(inferenceHandler, metadata, inputs, activationAttributes),\n  };\n};\n\nfunction getBcastSamplerForMatmul(\n  coordsDataType: string,\n  allGlChannels: readonly string[],\n  inputs: Tensor[],\n  outShape: readonly number[],\n): string {\n  let unpackedACoordsSnippet = [];\n  let unpackedBCoordsSnippet = [];\n\n  const inAShape = inputs[0].dims;\n  const inBShape = inputs[1].dims;\n\n  const inARank = inAShape.length;\n  const inBRank = inBShape.length;\n\n  const outRank = outShape.length;\n  const rankADiff = outRank - inARank;\n  const rankBDiff = outRank - inBRank;\n\n  unpackedACoordsSnippet = inAShape.map((_s, i) => `coords.${allGlChannels[i + rankADiff]}`);\n  unpackedACoordsSnippet[inARank - 1] = 'i*2';\n  unpackedACoordsSnippet.join(', ');\n  unpackedBCoordsSnippet = inBShape.map((_s, i) => `coords.${allGlChannels[i + rankBDiff]}`);\n  unpackedBCoordsSnippet[inBRank - 2] = 'i*2';\n  unpackedBCoordsSnippet.join(', ');\n\n  const broadcastADims = BroadcastUtil.getBroadcastDims(inAShape, outShape);\n  const broadcastBDims = BroadcastUtil.getBroadcastDims(inBShape, outShape);\n\n  const coordsASnippet = broadcastADims.map((d) => `coords.${allGlChannels[d + rankADiff]} = 0;`).join('\\n');\n  const coordsBSnippet = broadcastBDims.map((d) => `coords.${allGlChannels[d + rankBDiff]} = 0;`).join('\\n');\n  const swapDimSnippet = `int lastDim = coords.${allGlChannels[outRank - 1]};\n  coords.${allGlChannels[outRank - 1]} = coords.${allGlChannels[outRank - 2]};\n  coords.${allGlChannels[outRank - 2]} = lastDim;`;\n\n  const getBcastSamplerMatmulSource = `\nvec4 getAAtOutCoordsMatmul(int i) {\n  ${coordsDataType} coords = getOutputCoords();\n  ${swapDimSnippet}\n  ${coordsASnippet}\n  vec4 outputValue = getA(${unpackedACoordsSnippet});\n  return outputValue;\n}\n\nvec4 getBAtOutCoordsMatmul(int i) {\n  ${coordsDataType} coords = getOutputCoords();\n  ${swapDimSnippet}\n  ${coordsBSnippet}\n  vec4 outputValue = getB(${unpackedBCoordsSnippet});\n  return outputValue;\n}`;\n\n  return getBcastSamplerMatmulSource;\n}\n\nfunction getA(allGlChannels: string[], rank: number): string {\n  let res = '';\n  for (let i = 0; i < rank - 2; i++) {\n    res += `rc.${allGlChannels[i]}, `;\n  }\n  res += `rc.${allGlChannels[rank - 2]}, ` + 'i*2';\n  return res;\n}\n\nfunction getB(allGlChannels: string[], rank: number): string {\n  let res = '';\n  for (let i = 0; i < rank - 2; i++) {\n    res += `rc.${allGlChannels[i]}, `;\n  }\n  res += 'i*2, ' + `rc.${allGlChannels[rank - 1]}`;\n  return res;\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Tensor } from '../../../tensor';\nimport { WebGLInferenceHandler } from '../inference-handler';\n\nimport { calculateOutputShape, ConvAttributes } from './conv';\nimport { createPackedIm2ColProgramInfoLoader } from './im2col-pack';\nimport { createPackedMatmulProgramInfoLoader } from './matmul-pack';\n\nexport const conv2DPackedPointwise = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: readonly Tensor[],\n  attributes: ConvAttributes,\n): Tensor => {\n  const xshape = inputs[0].dims;\n  const kshape = inputs[1].dims;\n  const outputShape = calculateOutputShape(xshape, kshape, attributes.dilations, attributes.pads, attributes.strides);\n  const reshapedX = inferenceHandler.reshapePacked(inputs[0], [xshape[1], xshape[2] * xshape[3]]);\n  const reshapedK = inferenceHandler.reshapePacked(inputs[1], [kshape[0], kshape[1]]);\n\n  const matmulInputs = inputs.length > 2 ? [reshapedK, reshapedX, inputs[2]] : [reshapedK, reshapedX];\n  const matmulOutput = inferenceHandler.run(\n    createPackedMatmulProgramInfoLoader(inferenceHandler, matmulInputs, attributes),\n    matmulInputs,\n  );\n  return inferenceHandler.reshapePacked(matmulOutput, outputShape);\n};\n\nexport const conv2DPacked = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: readonly Tensor[],\n  attributes: ConvAttributes,\n): Tensor => {\n  const xshape = inputs[0].dims;\n  const kshape = inputs[1].dims;\n  const outputShape = calculateOutputShape(xshape, kshape, attributes.dilations, attributes.pads, attributes.strides);\n\n  // run im2col\n  const im2colOutput = inferenceHandler.run(\n    createPackedIm2ColProgramInfoLoader(inferenceHandler, inputs[0], inputs[1], outputShape, attributes),\n    [inputs[0]],\n  );\n\n  // reshape kernel\n  const kernelReshaped = inferenceHandler.reshapePacked(inputs[1], [kshape[0], kshape[1] * kshape[2] * kshape[3]]);\n\n  // run matmul\n  const matmulInputs = inputs.length === 3 ? [kernelReshaped, im2colOutput, inputs[2]] : [kernelReshaped, im2colOutput];\n  const matmulOutput = inferenceHandler.run(\n    createPackedMatmulProgramInfoLoader(inferenceHandler, matmulInputs, attributes),\n    matmulInputs,\n  );\n\n  // reshape output\n  const outputReshaped = inferenceHandler.reshapePacked(matmulOutput, outputShape);\n  return outputReshaped;\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Tensor } from '../../../tensor';\nimport { WebGLInferenceHandler } from '../inference-handler';\nimport { ProgramInfo, ProgramInfoLoader, ProgramMetadata, TextureType } from '../types';\n\nimport { ConvAttributes } from './conv';\n\nconst createIm2ColProgramMetadata = (cacheHint: string) => ({\n  name: 'Im2Col',\n  inputNames: ['X'],\n  inputTypes: [TextureType.unpacked],\n  cacheHint,\n});\n\nconst createIm2ColProgramInfo = (\n  _inferenceHandler: WebGLInferenceHandler,\n  metadata: ProgramMetadata,\n  x: Tensor,\n  w: Tensor,\n  outputShape: readonly number[],\n  attributes: ConvAttributes,\n): ProgramInfo => {\n  const xshape = x.dims;\n  const wshape = w.dims;\n\n  const rank = outputShape.length;\n  const im2colDims = calculateIm2ColDims(xshape, wshape, outputShape, 4);\n\n  const shaderSource = `\n        const int XC = ${xshape[1]};\n        const int XH = ${xshape[2]};\n        const int XW = ${xshape[3]};\n        const int KH = ${attributes.kernelShape[0]};\n        const int KW = ${attributes.kernelShape[1]};\n        const int dilationH = ${attributes.dilations[0]};\n        const int dilationW = ${attributes.dilations[1]};\n        const int strideH = ${attributes.strides[0]};\n        const int strideW = ${attributes.strides[1]};\n        const int padH = ${attributes.pads[0]};\n        const int padW = ${attributes.pads[1]};\n        const int KHKW = KH*KW;\n        const int XCKHKW = XC * KHKW;\n        const int outputChannels = 4;\n        vec4 process(int indices[${rank}]) {\n          int b  = indices[0]; // batch size\n          int oh = indices[1] * strideH - padH; //output height\n          int ow = indices[2] * strideW - padW; //output width\n          int p = indices[3] * outputChannels; //patch\n          vec4 value = vec4(0.0);\n          for(int i=0; i < outputChannels; ++i) {\n            if(p < XCKHKW) {\n              int patchC = p / KHKW;\n              int patchH = (p - patchC*KHKW) / KW;\n              int patchW = (p - patchC*KHKW) - patchH * KW;\n              int xh2 = oh + patchH * dilationH;\n              int xw2 = ow + patchW * dilationW;\n              int x[${xshape.length}];\n              x[0] = b;\n              x[1] = patchC;\n              x[2] = xh2;\n              x[3] = xw2;\n              if(xh2 >= 0 &&\n                  xh2 < XH &&\n                  xw2 >= 0 &&\n                  xw2 < XW) {\n                value[i] = _X(x);\n              }\n            }\n            ++p;\n          }\n          return value;\n        }\n        `;\n  return {\n    ...metadata,\n    output: { dims: im2colDims, type: x.type, textureType: TextureType.packedLastDimension },\n    shaderSource,\n  };\n};\n\nexport const createIm2ColProgramInfoLoader = (\n  inferenceHandler: WebGLInferenceHandler,\n  x: Tensor,\n  w: Tensor,\n  outputShape: readonly number[],\n  attributes: ConvAttributes,\n): ProgramInfoLoader => {\n  const metadata = createIm2ColProgramMetadata(attributes.cacheKey);\n  return {\n    ...metadata,\n    get: () => createIm2ColProgramInfo(inferenceHandler, metadata, x, w, outputShape, attributes),\n  };\n};\n\nexport const calculateIm2ColDims = (\n  inputShape: readonly number[],\n  kernelShape: readonly number[],\n  outputShape: readonly number[],\n  channels = 4,\n): number[] => [\n  outputShape[0],\n  outputShape[2],\n  outputShape[3],\n  Math.ceil((inputShape[1] * kernelShape[2] * kernelShape[3]) / channels),\n];\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Tensor } from '../../../tensor';\nimport { ShapeUtil } from '../../../util';\nimport { getGlsl } from '../glsl-source';\nimport { WebGLInferenceHandler } from '../inference-handler';\nimport { ProgramInfo, ProgramInfoLoader, ProgramMetadata, TextureType } from '../types';\n\nimport { getActivationSnippet, InternalActivationAttributes } from './fuse-utils';\nimport { calculateIm2ColDims } from './im2col';\n\nconst createDotProductProgramMetadata = (hasBias: boolean, attributes: InternalActivationAttributes) => ({\n  name: 'ConvDotProduct',\n  inputNames: hasBias ? ['Im2Col', 'K', 'B'] : ['Im2Col', 'K'],\n  inputTypes: hasBias\n    ? [TextureType.unpacked, TextureType.packedLastDimension, TextureType.unpacked]\n    : [TextureType.unpacked, TextureType.packedLastDimension],\n  cacheKey: attributes.activationCacheKey,\n});\n\nconst createDotProductProgramInfo = (\n  inferenceHandler: WebGLInferenceHandler,\n  metadata: ProgramMetadata,\n  inputs: readonly Tensor[],\n  outputShape: number[],\n  attributes: InternalActivationAttributes,\n): ProgramInfo => {\n  const xshape = inputs[0].dims;\n  const kshape = inputs[1].dims;\n  const adjustedKernelShape = [kshape[0], Math.ceil((xshape[1] * kshape[2] * kshape[3]) / 4)];\n  const im2colShape = calculateIm2ColDims(xshape, kshape, outputShape);\n  const [kWidth, kHeight] = inferenceHandler.calculateTextureWidthAndHeight(\n    adjustedKernelShape,\n    TextureType.packedLastDimension,\n  );\n\n  const im2colStrides = ShapeUtil.computeStrides(im2colShape);\n  const [im2colWidth, im2colHeight] = inferenceHandler.calculateTextureWidthAndHeight(\n    im2colShape,\n    TextureType.packedLastDimension,\n  );\n  const rank = outputShape.length;\n\n  const initValue = inputs.length < 3 ? '0.0' : '_B(b)';\n  const sharedDim = Math.ceil((xshape[1] * kshape[2] * kshape[3]) / 4);\n  const { activationFunction, applyActivation } = getActivationSnippet(attributes);\n  const glsl = getGlsl(inferenceHandler.session.backend.glContext.version);\n  const shaderSource = `\n${activationFunction}\nfloat process(int indices[${rank}]) {\n  int b[1];\n  b[0] = indices[1];\n  int im2col[4];\n  im2col[0] = indices[0];\n  im2col[1] = indices[2];\n  im2col[2] = indices[3];\n  int im2colOffset = im2col[0] * ${im2colStrides[0]} + im2col[1] * ${im2colStrides[1]} + im2col[2] * ${\n    im2colStrides[2]\n  };\n  int kernelOffset = indices[1] * ${adjustedKernelShape[1]};\n  float value = ${initValue};\n  for (int i = 0; i < ${sharedDim}; ++i) {\n    vec2 im2colCoords = offsetToCoords(im2colOffset, ${im2colWidth}, ${im2colHeight});\n    vec2 kernelCoords = offsetToCoords(kernelOffset, ${kWidth}, ${kHeight});\n    value += dot(${glsl.texture2D}(Im2Col, im2colCoords), ${glsl.texture2D}(K, kernelCoords));\n    ++im2colOffset;\n    ++kernelOffset;\n  }\n  ${applyActivation}\n  return value;\n}`;\n  return {\n    ...metadata,\n    output: { dims: outputShape, type: inputs[0].type, textureType: TextureType.unpacked },\n    shaderSource,\n  };\n};\n\nexport const createDotProductProgramInfoLoader = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: readonly Tensor[],\n  outputShape: number[],\n  attributes: InternalActivationAttributes,\n): ProgramInfoLoader => {\n  const metadata = createDotProductProgramMetadata(inputs.length > 2, attributes);\n  return {\n    ...metadata,\n    get: () => createDotProductProgramInfo(inferenceHandler, metadata, inputs, outputShape, attributes),\n  };\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { AttributeWithCacheKey, createAttributeWithCacheKey } from '../../../attribute-with-cache-key';\nimport { InferenceHandler } from '../../../backend';\nimport { Graph } from '../../../graph';\nimport { OperatorImplementation, OperatorInitialization } from '../../../operators';\nimport { Tensor } from '../../../tensor';\nimport { PoolConvUtil } from '../../../util';\nimport { WebGLInferenceHandler } from '../inference-handler';\n\nimport { createUnpackedGroupedConvProgramInfoLoader } from './conv-grouped';\nimport { conv2DPacked } from './conv-pack';\nimport { createDotProductProgramInfoLoader } from './dot-product';\nimport { InternalActivationAttributes, parseInternalActivationAttributes } from './fuse-utils';\nimport { createIm2ColProgramInfoLoader } from './im2col';\nimport { createMatmulProgramInfoLoader } from './matmul';\n\nexport const calculateOutputShape = (\n  inputShape: readonly number[],\n  kernelShape: readonly number[],\n  dilations: readonly number[],\n  adjustPads: readonly number[],\n  strides: readonly number[],\n): number[] => {\n  const batchSize = inputShape[0];\n  const inputSpatialShape = inputShape.slice(2);\n  const spatialRank = inputSpatialShape.length;\n  const outChannels = kernelShape[0];\n  const kernelSpatialShape = kernelShape.slice(2);\n  const dilatedKernelShape = kernelSpatialShape.map((v, i) => v + (v - 1) * (dilations[i] - 1));\n  const inputSpatialShapeWithPad = inputSpatialShape.map((v, i) => v + adjustPads[i] + adjustPads[i + spatialRank]);\n  const outputSpatialShape = inputSpatialShapeWithPad.map((v, i) =>\n    Math.floor((v - dilatedKernelShape[i] + strides[i]) / strides[i]),\n  );\n  const outputShape = [batchSize, outChannels].concat(...outputSpatialShape);\n  return outputShape;\n};\n\nexport interface ConvAttributes extends InternalActivationAttributes, AttributeWithCacheKey {\n  readonly autoPad: string;\n  readonly dilations: readonly number[];\n  readonly group: number;\n  readonly kernelShape: readonly number[];\n  readonly pads: readonly number[];\n  readonly strides: readonly number[];\n}\n\nexport const conv: OperatorImplementation<ConvAttributes> = (\n  inferenceHandler: InferenceHandler,\n  inputs: Tensor[],\n  attributes: ConvAttributes,\n): Tensor[] => {\n  validateInputs(inputs, attributes); // currently will fail if not conv2D\n  return conv2d(inferenceHandler, inputs, attributes);\n};\n\nconst conv2d: OperatorImplementation<ConvAttributes> = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  attributes: ConvAttributes,\n): Tensor[] => {\n  const adjustedAttributes = getAdjustedConvAttributes(attributes, inputs);\n  const packMode = inferenceHandler.session.pack;\n  const isPointwise = adjustedAttributes.kernelShape[0] === 1 && adjustedAttributes.kernelShape[1] === 1;\n  if (adjustedAttributes.group > 1) {\n    const result = inferenceHandler.run(\n      createUnpackedGroupedConvProgramInfoLoader(inferenceHandler, inputs, adjustedAttributes),\n      inputs,\n    );\n    return [result];\n  } else if (isPointwise && packMode) {\n    return [conv2DUnpackedPointwise(inferenceHandler, inputs, adjustedAttributes)];\n  } else if (packMode && inputs[0].dims.length === 4 && inputs[0].dims[0] === 1 && !isPointwise) {\n    return [conv2DPacked(inferenceHandler, inputs, adjustedAttributes)];\n  } else {\n    return [conv2DUnpacked(inferenceHandler, inputs, adjustedAttributes)];\n  }\n};\n\nconst conv2DUnpackedPointwise = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: readonly Tensor[],\n  attributes: ConvAttributes,\n): Tensor => {\n  const xshape = inputs[0].dims;\n  const kshape = inputs[1].dims;\n  const outputShape = calculateOutputShape(xshape, kshape, attributes.dilations, attributes.pads, attributes.strides);\n  const reshapedX = inferenceHandler.reshapeUnpacked(inputs[0], [xshape[1], xshape[2] * xshape[3]]);\n  const reshapedK = inferenceHandler.reshapeUnpacked(inputs[1], [kshape[0], kshape[1]]);\n\n  const matmulInputs = inputs.length > 2 ? [reshapedK, reshapedX, inputs[2]] : [reshapedK, reshapedX];\n  const matmulOutput = inferenceHandler.run(createMatmulProgramInfoLoader(matmulInputs, attributes), matmulInputs);\n  return inferenceHandler.reshapeUnpacked(matmulOutput, outputShape);\n};\n\nconst conv2DUnpacked = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: readonly Tensor[],\n  attributes: ConvAttributes,\n): Tensor => {\n  const xshape = inputs[0].dims;\n  const kshape = inputs[1].dims;\n  const outputShape = calculateOutputShape(xshape, kshape, attributes.dilations, attributes.pads, attributes.strides);\n  const xIm2Col = inferenceHandler.run(\n    createIm2ColProgramInfoLoader(inferenceHandler, inputs[0], inputs[1], outputShape, attributes),\n    [inputs[0]],\n  );\n\n  const dotProductInputs = inputs.length === 3 ? [xIm2Col, inputs[1], inputs[2]] : [xIm2Col, inputs[1]];\n  const output = inferenceHandler.run(\n    createDotProductProgramInfoLoader(inferenceHandler, inputs, outputShape, attributes),\n    dotProductInputs,\n  );\n  return output;\n};\n\nconst getAdjustedConvAttributes = <T extends ConvAttributes>(attributes: T, inputs: Tensor[]): T => {\n  const kernelShape = attributes.kernelShape.slice();\n  // if kernelShape is not specified in the attributes of this op, infer it from the weight tensor dims\n  if (attributes.kernelShape.length === 0) {\n    for (let i = 2; i < inputs[1].dims.length; ++i) {\n      kernelShape.push(inputs[1].dims[i]);\n    }\n  }\n  const pads = attributes.pads.slice();\n  PoolConvUtil.adjustPadsBasedOnAutoPad(\n    inputs[0].dims,\n    attributes.strides,\n    attributes.dilations,\n    kernelShape,\n    pads,\n    attributes.autoPad,\n  );\n\n  // always return a new object so does not modify the original attributes\n  const newAttributes: T = Object.assign({}, attributes);\n  Object.assign(newAttributes, { kernelShape, pads, cacheKey: attributes.cacheKey });\n  return newAttributes;\n};\n\nexport const parseConvAttributes: OperatorInitialization<ConvAttributes> = (node: Graph.Node): ConvAttributes => {\n  const attributes = node.attributes;\n  const activationAttributes = parseInternalActivationAttributes(attributes);\n  // TODO : Make this generic enough to compute default attributes for multi-dimensional conv\n  const autoPad = attributes.getString('auto_pad', 'NOTSET');\n  const dilations = attributes.getInts('dilations', [1, 1]);\n  const group = attributes.getInt('group', 1);\n  const kernelShape = attributes.getInts('kernel_shape', []);\n  const pads = attributes.getInts('pads', [0, 0, 0, 0]);\n  const strides = attributes.getInts('strides', [1, 1]);\n\n  return createAttributeWithCacheKey({\n    autoPad,\n    dilations,\n    group,\n    kernelShape,\n    pads,\n    strides,\n    ...activationAttributes,\n  });\n};\n\nconst validateInputs = (inputs: Tensor[], attributes: ConvAttributes): void => {\n  // Refer to the below link for all input checks\n  // https://github.com/onnx/onnx/blob/main/docs/Operators.md#Conv\n  if (!inputs || (inputs.length !== 2 && inputs.length !== 3)) {\n    throw new Error('Conv requires 2 or 3 inputs');\n  }\n\n  // TODO : Need to add support for multi-dimensional conv\n  if (inputs[0].dims.length !== 4 || inputs[1].dims.length !== 4) {\n    throw new Error('currently only support 2-dimensional conv');\n  }\n\n  // FILTER_IN_CHANNEL should be equal to DATA_CHANNEL\n  const dataChannel = inputs[0].dims[1];\n  const filterInChannel = inputs[1].dims[1] * attributes.group;\n  if (dataChannel !== filterInChannel) {\n    throw new Error('FILTER_IN_CHANNEL should be equal to DATA_CHANNEL');\n  }\n\n  // if bias is provided it should be 1D and the number of elements should be equal to the number of feature maps\n  if (inputs.length === 3 && (inputs[2].dims.length !== 1 || inputs[1].dims[0] !== inputs[2].dims[0])) {\n    throw new Error('invalid bias');\n  }\n\n  const spatialRank = inputs[0].dims.length - 2;\n  // wrong dilations dimension\n  if (attributes.dilations.length !== spatialRank) {\n    throw new Error(`dilations should be ${spatialRank}D`);\n  }\n\n  // Wrong strides dimension\n  if (attributes.strides.length !== spatialRank) {\n    throw new Error(`strides should be ${spatialRank}D`);\n  }\n\n  // Wrong pads dimension\n  if (attributes.pads.length !== spatialRank * 2) {\n    throw new Error(`pads should be ${spatialRank * 2}D`);\n  }\n\n  // if kernelShape is specified, it's data length must be 2 less than dims length of the weights tensor\n  // (the first 2 dims are batch_size and channels)\n  if (attributes.kernelShape.length !== 0 && attributes.kernelShape.length !== inputs[1].dims.length - 2) {\n    throw new Error('invalid kernel shape');\n  }\n\n  // TODO : Need to add support for float64\n  if (inputs[0].type !== 'float32' || inputs[1].type !== 'float32') {\n    throw new Error('Conv input(X,W) should be float tensor');\n  }\n\n  if (inputs.length === 3 && inputs[2].type !== 'float32') {\n    throw new Error('Conv input(bias) should be float tensor');\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { createAttributeWithCacheKey } from '../../../attribute-with-cache-key';\nimport { InferenceHandler } from '../../../backend';\nimport { Graph } from '../../../graph';\nimport { OperatorImplementation, OperatorInitialization } from '../../../operators';\nimport { Tensor } from '../../../tensor';\nimport { getGlsl } from '../glsl-source';\nimport { WebGLInferenceHandler } from '../inference-handler';\nimport { ProgramInfo, ProgramInfoLoader, ProgramMetadata, TextureType } from '../types';\n\nimport { ConvAttributes } from './conv';\nimport { getActivationSnippet, parseInternalActivationAttributes } from './fuse-utils';\n\nconst computeTotalPad = (\n  inDim: number,\n  stride: number,\n  adj: number,\n  kernel: number,\n  dilation: number,\n  outSize: number,\n) => (inDim - 1) * stride + adj + (kernel - 1) * dilation + 1 - outSize;\n\nconst distributePadding = (totalPad: number, autoPad: string, pads: number[], head: number, tail: number) => {\n  const smallPad = Math.floor(totalPad / 2);\n  if (autoPad === 'SAME_UPPER') {\n    pads[head] = smallPad;\n    pads[tail] = totalPad - smallPad;\n  } else if (autoPad === 'SAME_LOWER') {\n    pads[head] = totalPad - smallPad;\n    pads[tail] = smallPad;\n  }\n};\n\nconst calculateOutputShapeAndPads = (\n  inputShape: readonly number[],\n  kernelShape: readonly number[],\n  dilations: readonly number[],\n  autoPad: string,\n  pads: number[],\n  strides: readonly number[],\n  outputPadding: readonly number[],\n  outputShape: number[],\n) => {\n  const spatialRank = inputShape.length - 2;\n  const updateShape = outputShape.length === 0;\n  for (let i = 0; i < spatialRank; ++i) {\n    const outSize = updateShape ? inputShape[i + 2] * strides[i] : outputShape[i];\n    const totalPad = computeTotalPad(inputShape[i + 2], strides[i], pads[i], kernelShape[i], dilations[i], outSize);\n    distributePadding(totalPad, autoPad, pads, i, i + spatialRank);\n    if (updateShape) {\n      outputShape.push(\n        strides[i] * (inputShape[i + 2] - 1) +\n          outputPadding[i] +\n          (kernelShape[i] - 1) * dilations[i] +\n          1 -\n          pads[i] -\n          pads[i + spatialRank],\n      );\n    }\n  }\n};\n\nexport interface ConvTransposeAttributes extends ConvAttributes {\n  readonly outputPadding: readonly number[];\n  readonly outputShape: readonly number[];\n}\n\nexport const convTranspose: OperatorImplementation<ConvTransposeAttributes> = (\n  inferenceHandler: InferenceHandler,\n  inputs: Tensor[],\n  attributes: ConvTransposeAttributes,\n): Tensor[] => {\n  validateInputs(inputs, attributes); // currently will fail if not convTranspose2D\n  return convTranspose2d(inferenceHandler, inputs, attributes);\n};\n\nconst convTranspose2d: OperatorImplementation<ConvTransposeAttributes> = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  attributes: ConvTransposeAttributes,\n): Tensor[] => {\n  const adjustedAttributes = getAdjustedConvTransposeAttributes(attributes, inputs);\n  return [convTranspose2DUnpacked(inferenceHandler, inputs, adjustedAttributes)];\n};\n\nconst createConvTransposeProgramMetadata = (hasBias: boolean, cacheHint: string) => ({\n  name: 'ConvTranspose',\n  inputNames: hasBias ? ['X', 'W', 'B'] : ['X', 'W'],\n  inputTypes: hasBias\n    ? [TextureType.unpacked, TextureType.unpacked, TextureType.unpacked]\n    : [TextureType.unpacked, TextureType.unpacked],\n  cacheHint,\n});\n\nconst createUnpackedConvTransposeProgramInfo = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: readonly Tensor[],\n  metadata: ProgramMetadata,\n  attributes: ConvTransposeAttributes,\n): ProgramInfo => {\n  const hasBias = inputs.length > 2;\n  const valueInit = hasBias ? 'getB(output_channel)' : '0.0';\n  const xShape = inputs[0].dims;\n  const wShape = inputs[1].dims;\n  const outputChannelsPerGroup = wShape[1];\n  const inputChannelsPerGroup = wShape[0] / attributes.group;\n  const outputShape = [inputs[0].dims[0], inputs[1].dims[1] * attributes.group, ...attributes.outputShape];\n  const glsl = getGlsl(inferenceHandler.session.backend.glContext.version);\n  const { activationFunction, applyActivation } = getActivationSnippet(attributes);\n\n  const shaderSource = `\n  const ivec2 strides = ivec2(${attributes.strides[0]}, ${attributes.strides[1]});\n  const ivec2 pads = ivec2(${attributes.pads[0]}, ${attributes.pads[1]});\n  ${activationFunction}\n  void main() {\n    ivec4 coords = getOutputCoords();\n    int batch = coords.x;\n    int output_channel = coords.y;\n\n    ivec2 loc = coords.zw + pads;\n\n    int group_id = output_channel / ${outputChannelsPerGroup};\n    int wOutChannel = output_channel - group_id * ${outputChannelsPerGroup};\n\n    float value = ${valueInit};\n    for (int inChannelOffset = 0; inChannelOffset < ${inputChannelsPerGroup}; inChannelOffset++) {\n      int input_channel = group_id * ${inputChannelsPerGroup} + inChannelOffset;\n      for (int wWOff = 0; wWOff < ${wShape[2]}; wWOff++) {\n        for (int wHOff = 0; wHOff < ${wShape[3]}; wHOff++) {\n          ivec2 wOff = ivec2(wWOff * ${attributes.dilations[0]}, wHOff * ${attributes.dilations[1]});\n          ivec2 wLoc = loc - wOff;\n          ivec2 wLocIn = wLoc / strides;\n          if (\n            wLocIn * strides == wLoc &&\n            wLocIn.x >= 0 && wLocIn.x < ${xShape[2]} &&\n            wLocIn.y >= 0 && wLocIn.y < ${xShape[3]}\n          ) {\n            float xVal = getX(batch, input_channel, wLocIn.y, wLocIn.x);\n            float wVal = getW(input_channel, wOutChannel, wHOff, wWOff);\n            value += xVal * wVal;\n          }\n        }\n      }\n    }\n    ${applyActivation}\n    ${glsl.output} = vec4(value, .0, .0, .0);\n  }\n`;\n  return {\n    ...metadata,\n    output: { dims: outputShape, type: inputs[0].type, textureType: TextureType.unpacked },\n    shaderSource,\n    hasMain: true,\n  };\n};\n\nconst createUnpackedConvTransposeProgramInfoLoader = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: readonly Tensor[],\n  attributes: ConvTransposeAttributes,\n): ProgramInfoLoader => {\n  const metadata = createConvTransposeProgramMetadata(inputs.length > 2, attributes.cacheKey);\n  return {\n    ...metadata,\n    get: () => createUnpackedConvTransposeProgramInfo(inferenceHandler, inputs, metadata, attributes),\n  };\n};\n\nconst convTranspose2DUnpacked = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: readonly Tensor[],\n  attributes: ConvTransposeAttributes,\n): Tensor => {\n  const result = inferenceHandler.run(\n    createUnpackedConvTransposeProgramInfoLoader(inferenceHandler, inputs, attributes),\n    inputs,\n  );\n  return result;\n};\n\nconst getAdjustedConvTransposeAttributes = <T extends ConvTransposeAttributes>(attributes: T, inputs: Tensor[]): T => {\n  const kernelShape = attributes.kernelShape.slice();\n  // if kernelShape is not specified in the attributes of this op, infer it from the weight tensor dims\n  if (attributes.kernelShape.length === 0) {\n    for (let i = 2; i < inputs[1].dims.length; ++i) {\n      kernelShape.push(inputs[1].dims[i]);\n    }\n  }\n\n  const pads = attributes.pads.slice();\n  const outputShape = attributes.outputShape.slice();\n  const inputShape = inputs[0].dims;\n  // If outputShape is not specified in the attributes of this op, infer it from the parameters\n  // Similarly, automatically infer pads if not specified\n  calculateOutputShapeAndPads(\n    inputShape,\n    kernelShape,\n    attributes.dilations,\n    attributes.autoPad,\n    pads,\n    attributes.strides,\n    attributes.outputPadding,\n    outputShape,\n  );\n\n  // always return a new object so does not modify the original attributes\n  const newAttributes: T = Object.assign({}, attributes);\n  Object.assign(newAttributes, { kernelShape, pads, outputShape, cacheKey: attributes.cacheKey });\n  return newAttributes;\n};\n\nexport const parseConvTransposeAttributes: OperatorInitialization<ConvTransposeAttributes> = (\n  node: Graph.Node,\n): ConvTransposeAttributes => {\n  const attributes = node.attributes;\n  const activationAttributes = parseInternalActivationAttributes(attributes);\n  // TODO : Make this generic enough to compute default attributes for multi-dimensional conv\n  const autoPad = attributes.getString('auto_pad', 'NOTSET');\n  const dilations = attributes.getInts('dilations', [1, 1]);\n  const group = attributes.getInt('group', 1);\n  const kernelShape = attributes.getInts('kernel_shape', []);\n  const outputPadding = attributes.getInts('output_padding', [0, 0]);\n  const outputShape = attributes.getInts('output_shape', []);\n  const pads = attributes.getInts('pads', [0, 0, 0, 0]);\n  const strides = attributes.getInts('strides', [1, 1]);\n\n  return createAttributeWithCacheKey({\n    autoPad,\n    dilations,\n    group,\n    kernelShape,\n    outputPadding,\n    outputShape,\n    pads,\n    strides,\n    ...activationAttributes,\n  });\n};\n\nconst validateInputs = (inputs: Tensor[], attributes: ConvTransposeAttributes): void => {\n  // Refer to the below link for all input checks\n  // https://github.com/onnx/onnx/blob/main/docs/Operators.md#Conv\n  if (!inputs || (inputs.length !== 2 && inputs.length !== 3)) {\n    throw new Error('Conv requires 2 or 3 inputs');\n  }\n\n  // TODO : Need to add support for multi-dimensional conv\n  if (inputs[0].dims.length !== 4 || inputs[1].dims.length !== 4) {\n    throw new Error('currently only support 2-dimensional conv');\n  }\n\n  // FILTER_IN_CHANNEL should be equal to DATA_CHANNEL\n  const dataChannel = inputs[0].dims[1];\n  const filterInChannel = inputs[1].dims[0];\n  if (dataChannel !== filterInChannel) {\n    throw new Error('FILTER_IN_CHANNEL should be equal to DATA_CHANNEL');\n  }\n\n  const featureMaps = inputs[1].dims[1] * attributes.group;\n\n  // if bias is provided it should be 1D and the number of elements should be equal to the number of feature maps\n  if (inputs.length === 3 && (inputs[2].dims.length !== 1 || inputs[2].dims[0] !== featureMaps)) {\n    throw new Error('invalid bias');\n  }\n\n  const spatialRank = inputs[0].dims.length - 2;\n  // wrong dilations dimension\n  if (attributes.dilations.length !== spatialRank) {\n    throw new Error(`dilations should be ${spatialRank}D`);\n  }\n\n  // Wrong strides dimension\n  if (attributes.strides.length !== spatialRank) {\n    throw new Error(`strides should be ${spatialRank}D`);\n  }\n\n  // Wrong pads dimension\n  if (attributes.pads.length !== spatialRank * 2) {\n    throw new Error(`pads should be ${spatialRank * 2}D`);\n  }\n\n  // Wrong output padding dimension\n  if (attributes.outputPadding.length !== spatialRank) {\n    throw new Error(`output_padding should be ${spatialRank}D`);\n  }\n\n  // if kernelShape is specified, it's data length must be 2 less than dims length of the weights tensor\n  // (the first 2 dims are batch_size and channels)\n  if (attributes.kernelShape.length !== 0 && attributes.kernelShape.length !== inputs[1].dims.length - 2) {\n    throw new Error('invalid kernel shape');\n  }\n\n  // as with kernelShape, must have same number of spatial dims as input\n  if (attributes.outputShape.length !== 0 && attributes.outputShape.length !== inputs[0].dims.length - 2) {\n    throw new Error('invalid output shape');\n  }\n\n  // TODO : Need to add support for float64\n  if (inputs[0].type !== 'float32' || inputs[1].type !== 'float32') {\n    throw new Error('ConvTranspose input(X,W) should be float tensor');\n  }\n\n  if (inputs.length === 3 && inputs[2].type !== 'float32') {\n    throw new Error('ConvTranspose input(bias) should be float tensor');\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { AttributeWithCacheKey, createAttributeWithCacheKey } from '../../../attribute-with-cache-key';\nimport { Graph } from '../../../graph';\nimport { OperatorImplementation, OperatorInitialization } from '../../../operators';\nimport { Tensor } from '../../../tensor';\nimport { ShapeUtil } from '../../../util';\nimport { WebGLInferenceHandler } from '../inference-handler';\nimport { ProgramInfo, TextureType } from '../types';\n\nexport interface TransposeAttributes extends AttributeWithCacheKey {\n  readonly perm: number[];\n}\n\nconst transposeProgramMetadata = {\n  name: 'Transpose',\n  inputNames: ['A'],\n  inputTypes: [TextureType.unpacked],\n};\n\nexport const transpose: OperatorImplementation<TransposeAttributes> = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  attributes: TransposeAttributes,\n): Tensor[] => {\n  validateInputs(inputs);\n  const output = inferenceHandler.run(\n    {\n      ...transposeProgramMetadata,\n      cacheHint: attributes.cacheKey,\n      get: () => createTransposeProgramInfo(inferenceHandler, inputs[0], attributes.perm),\n    },\n    inputs,\n  );\n  return [output];\n};\n\nexport const parseTransposeAttributes: OperatorInitialization<TransposeAttributes> = (\n  node: Graph.Node,\n): TransposeAttributes => createAttributeWithCacheKey({ perm: node.attributes.getInts('perm', []) });\n\nconst createTransposeProgramInfo = (\n  _inferenceHandler: WebGLInferenceHandler,\n  input: Tensor,\n  perm: number[],\n): ProgramInfo => {\n  const inputShape = input.dims;\n  perm = getAdjustedPerm(inputShape, perm);\n  const unpackedOutputShape = getOutputShape(inputShape, perm);\n  const rank = inputShape.length;\n  // A dims=[${inputs[0].dims.toString()}]\n  // out Dims=[${unpackedOutputShape.toString()}]\n  // based on perm=[${perm.toString()}]\n  const shaderSource = `\n      ${getPermFunctionBody('perm', perm, rank)}\n      float process(int indices[${rank}]) {\n        int a[${rank}];\n        perm(a, indices);\n        return _A(a);\n      }`;\n  return {\n    ...transposeProgramMetadata,\n    output: { dims: unpackedOutputShape, type: input.type, textureType: TextureType.unpacked },\n    shaderSource,\n  };\n};\n\nconst getAdjustedPerm = (inputShape: readonly number[], perm: number[]): number[] => {\n  if (perm && perm.length !== inputShape.length) {\n    perm = [...inputShape.keys()].reverse();\n  }\n  return perm;\n};\n\nconst getOutputShape = (inputShape: readonly number[], perm: number[]): readonly number[] => {\n  perm = getAdjustedPerm(inputShape, perm);\n  return ShapeUtil.sortBasedOnPerm(inputShape, perm);\n};\n\nconst getPermFunctionBody = (name: string, perm: number[], rank: number): string => {\n  const reverseFunc = [];\n  reverseFunc.push(`void ${name}(out int a[${rank}], int src[${rank}]) {`);\n  for (let i = 0; i < rank; ++i) {\n    reverseFunc.push(`\\ta[${perm[i]}]=src[${i}];`);\n  }\n  reverseFunc.push('\\t}');\n  return reverseFunc.join('\\n');\n};\n\nconst validateInputs = (inputs: Tensor[]): void => {\n  if (!inputs || inputs.length !== 1) {\n    throw new Error('Transpose requires 1 input.');\n  }\n\n  if (inputs[0].type !== 'float32' && inputs[0].type !== 'float64') {\n    throw new Error('input should be float tensor');\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Graph } from '../../../graph';\nimport { OperatorImplementation, OperatorInitialization } from '../../../operators';\nimport { Tensor } from '../../../tensor';\nimport { WebGLInferenceHandler } from '../inference-handler';\n\nimport { transpose, TransposeAttributes } from './transpose';\n\nexport interface DepthToSpaceAttributes {\n  mode: 'DCR' | 'CRD';\n  blocksize: number;\n}\n\nexport const depthToSpace: OperatorImplementation<DepthToSpaceAttributes> = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  attributes: DepthToSpaceAttributes,\n): Tensor[] => {\n  validateInputs(inputs);\n  const blocksize = attributes.blocksize;\n  const blocksizeSqr = blocksize * blocksize;\n  const transposePerm = attributes.mode === 'DCR' ? [0, 3, 4, 1, 5, 2] : [0, 1, 4, 2, 5, 3];\n  const firstReshapeShape =\n    attributes.mode === 'DCR'\n      ? [\n          inputs[0].dims[0],\n          blocksize,\n          blocksize,\n          inputs[0].dims[1] / blocksizeSqr,\n          inputs[0].dims[2],\n          inputs[0].dims[3],\n        ]\n      : [\n          inputs[0].dims[0],\n          inputs[0].dims[1] / blocksizeSqr,\n          blocksize,\n          blocksize,\n          inputs[0].dims[2],\n          inputs[0].dims[3],\n        ];\n\n  // const transpose = new WebGLTranspose();\n  // const attributes = new Attribute(undefined);\n  // attributes.set('perm', 'ints', transposePerm);\n  // transpose.initialize(attributes);\n\n  // First reshape\n  const firstReshapedTensor = inferenceHandler.reshapeUnpacked(inputs[0], firstReshapeShape);\n\n  // transpose\n  const transposeAttributes: TransposeAttributes = { perm: transposePerm, cacheKey: `${transposePerm}` };\n  const [transposeOutput] = transpose(inferenceHandler, [firstReshapedTensor], transposeAttributes);\n\n  // Second reshape\n  const secondReshapeShape = [\n    inputs[0].dims[0],\n    inputs[0].dims[1] / blocksizeSqr,\n    inputs[0].dims[2] * blocksize,\n    inputs[0].dims[3] * blocksize,\n  ];\n  const result = inferenceHandler.reshapeUnpacked(transposeOutput, secondReshapeShape);\n  return [result];\n};\n\nexport const parseDepthToSpaceAttributes: OperatorInitialization<DepthToSpaceAttributes> = (\n  node: Graph.Node,\n): DepthToSpaceAttributes => {\n  // processing node attributes\n  const blocksize = node.attributes.getInt('blocksize');\n  if (blocksize < 1) {\n    throw new Error(`blocksize must be >= 1, but got : ${blocksize} for DepthToSpace`);\n  }\n  const mode = node.attributes.getString('mode', 'DCR');\n  if (mode !== 'DCR' && mode !== 'CRD') {\n    throw new Error(`unrecognized mode: ${mode} for DepthToSpace`);\n  }\n  return { mode, blocksize };\n};\n\nconst validateInputs = (inputs: Tensor[]): void => {\n  if (inputs.length !== 1) {\n    throw new Error(`DepthToSpace expect 1 inputs, but got ${inputs.length}`);\n  }\n\n  // Input has to be a 4-D tensor\n  // TODO: Support string depth-to-space.\n  if (inputs[0].type === 'string' || inputs[0].dims.length !== 4) {\n    throw new TypeError('DepthToSpace input should be a 4-D numeric tensor');\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Graph } from '../../../graph';\nimport { OperatorImplementation, OperatorInitialization } from '../../../operators';\nimport { Tensor } from '../../../tensor';\nimport { ShapeUtil } from '../../../util';\nimport { WebGLInferenceHandler } from '../inference-handler';\n\nexport const flatten: OperatorImplementation<number> = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  axis: number,\n): Tensor[] => {\n  validateInputs(inputs, axis);\n\n  const outputDims = ShapeUtil.flattenShape(inputs[0].dims, axis);\n  return [inferenceHandler.reshapeUnpacked(inputs[0], outputDims)];\n};\n\nexport const parseFlattenAttributes: OperatorInitialization<number> = (node: Graph.Node): number =>\n  node.attributes.getInt('axis', 1); // default axis is 1\n\nconst validateInputs = (inputs: Tensor[], axis: number): void => {\n  if (!inputs || inputs.length !== 1) {\n    throw new Error('Flatten requires 1 input.');\n  }\n\n  const r = inputs[0].dims.length;\n  if (r === 0) {\n    throw new Error('scalar tensor is not supported.');\n  }\n\n  if (axis < -r || axis > r) {\n    throw new Error('Invalid axis');\n  }\n\n  // TODO: Support string type\n  if (inputs[0].type === 'string') {\n    throw new Error('string tensor is not supported.');\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { InferenceHandler } from './backend';\nimport { Graph } from './graph';\nimport { Tensor } from './tensor';\n\nexport type OperatorImplementation<T> = (inferenceHandler: InferenceHandler, inputs: Tensor[], context: T) => Tensor[];\nexport type OperatorInitialization<T> = (node: Graph.Node, graph: Graph) => T;\n\nexport interface Operator {\n  readonly impl: OperatorImplementation<unknown>;\n  readonly context: Graph.Node | unknown;\n}\n\nexport const NUMBER_TYPES: readonly Tensor.DataType[] = [\n  'float32',\n  'float64',\n  'int32',\n  'int16',\n  'int8',\n  'uint16',\n  'uint32',\n  'uint8',\n];\nexport const INT_TYPES: readonly Tensor.DataType[] = ['int32', 'int16', 'int8', 'uint16', 'uint32', 'uint8'];\nexport const FLOAT_TYPES: readonly Tensor.DataType[] = ['float32', 'float64'];\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { AttributeWithCacheKey, createAttributeWithCacheKey } from '../../../attribute-with-cache-key';\nimport { Graph } from '../../../graph';\nimport { NUMBER_TYPES, OperatorImplementation, OperatorInitialization } from '../../../operators';\nimport { Tensor } from '../../../tensor';\nimport { ShapeUtil } from '../../../util';\nimport { WebGLInferenceHandler } from '../inference-handler';\nimport { ProgramInfo, ProgramInfoLoader, ProgramMetadata, TextureType } from '../types';\n\ninterface GatherAttributes extends AttributeWithCacheKey {\n  readonly axis: number;\n}\n\nexport const gather: OperatorImplementation<GatherAttributes> = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  attributes: GatherAttributes,\n): Tensor[] => {\n  validateInputs(inputs, attributes.axis);\n  const output = inferenceHandler.run(createGatherProgramInfoLoader(inferenceHandler, inputs, attributes), inputs);\n  return [output];\n};\n\nexport const parseGatherAttributes: OperatorInitialization<GatherAttributes> = (node: Graph.Node): GatherAttributes =>\n  createAttributeWithCacheKey({ axis: node.attributes.getInt('axis', 0) });\n\nconst gatherProgramMetadata = {\n  name: 'Gather',\n  inputNames: ['A', 'B'],\n  inputTypes: [TextureType.unpacked, TextureType.unpacked],\n};\n\nconst createGatherProgramInfo = (\n  _handler: WebGLInferenceHandler,\n  metadata: ProgramMetadata,\n  inputs: Tensor[],\n  axis: number,\n): ProgramInfo => {\n  const inputShape = inputs[0].dims.slice();\n  const indexDataShape = inputs[1].dims.slice();\n  const outputShape = new Array(inputShape.length + indexDataShape.length - 1);\n\n  axis = ShapeUtil.normalizeAxis(axis, inputShape.length);\n  const indexCopyOps: string[] = [];\n  for (let i = 0; i < outputShape.length; i++) {\n    // outputShape is divided into three parts: A, B, C\n    // |0        axis|  axis + indexDataShape.length |          end|\n    // |     A       |             B                 |      C      |\n    //\n    // inputIdx: [A, inputs[1][B], C]\n    if (i < axis) {\n      // A\n      outputShape[i] = inputShape[i];\n      indexCopyOps.push(`inputIdx[${i}] = outputIdx[${i}];`);\n    } else {\n      if (i < axis + indexDataShape.length) {\n        // B\n        outputShape[i] = indexDataShape[i - axis];\n        indexCopyOps.push(`indexDataIdx[${i - axis}] = outputIdx[${i}];`);\n      } else {\n        // C\n        outputShape[i] = inputShape[i - indexDataShape.length + 1]; // skip 1 for axis\n        indexCopyOps.push(`inputIdx[${i - indexDataShape.length + 1}] = outputIdx[${i}];`);\n      }\n    }\n  }\n\n  const orank = outputShape.length || 1;\n  const irank = inputShape.length;\n  const iDrank = indexDataShape.length || 1;\n  const shaderSource = `\n      float process(int outputIdx[${orank}]) {\n        int inputIdx[${irank}];\n        int indexDataIdx[${iDrank}];\n        indexDataIdx[0] = 0;\n        ${indexCopyOps.join('\\n        ')}\n        int idx = int(_B(indexDataIdx));\n        inputIdx[${axis}] = idx < 0 ? idx + ${inputShape[axis]} : idx;\n        return _A(inputIdx);\n      }`;\n  return {\n    ...metadata,\n    output: { dims: outputShape, type: inputs[0].type, textureType: TextureType.unpacked },\n    shaderSource,\n  };\n};\n\nconst createGatherProgramInfoLoader = (\n  handler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  attributes: GatherAttributes,\n): ProgramInfoLoader => {\n  const metadata = { ...gatherProgramMetadata, cacheHint: attributes.cacheKey };\n  return { ...metadata, get: () => createGatherProgramInfo(handler, metadata, inputs, attributes.axis) };\n};\n\nconst validateInputs = (inputs: Tensor[], axis: number): void => {\n  if (!inputs || inputs.length !== 2) {\n    throw new Error('Gather requires 2 inputs.');\n  }\n  const tensorRank = inputs[0].dims.length;\n  if (tensorRank < 1) {\n    throw new Error('Invalid input shape.');\n  }\n  if (axis < -tensorRank || axis > tensorRank - 1) {\n    throw new Error('Invalid axis.');\n  }\n  if (NUMBER_TYPES.indexOf(inputs[0].type) === -1) {\n    throw new Error('Invaid input type.');\n  }\n  if (inputs[1].type !== 'int32' && inputs[1].type !== 'int16') {\n    throw new Error('Invaid input type.');\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { AttributeWithCacheKey, createAttributeWithCacheKey } from '../../../attribute-with-cache-key';\nimport { Graph } from '../../../graph';\nimport { OperatorImplementation, OperatorInitialization } from '../../../operators';\nimport { Tensor } from '../../../tensor';\nimport { GemmUtil } from '../../../util';\nimport { WebGLInferenceHandler } from '../inference-handler';\nimport { ProgramInfo, ProgramInfoLoader, ProgramMetadata, TextureType } from '../types';\n\nexport interface GemmAttributes extends AttributeWithCacheKey {\n  transA: boolean;\n  transB: boolean;\n  alpha: number;\n  beta: number;\n  isOptionalC: boolean; // in opset 11, C becomes optional\n}\n\nexport const gemm: OperatorImplementation<GemmAttributes> = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  attributes: GemmAttributes,\n): Tensor[] => {\n  validateInputs(inputs, attributes);\n  const output = inferenceHandler.run(createGemmProgramInfoLoader(inputs, attributes), inputs);\n  return [output];\n};\n\nconst parseGemmAttributes = (node: Graph.Node, isOptionalC: boolean): GemmAttributes => {\n  const transA = node.attributes.getInt('transA', 0) !== 0;\n  const transB = node.attributes.getInt('transB', 0) !== 0;\n  const alpha = node.attributes.getFloat('alpha', 1.0);\n  const beta = node.attributes.getFloat('beta', 1.0);\n  return createAttributeWithCacheKey({ transA, transB, alpha, beta, isOptionalC });\n};\n\nexport const parseGemmAttributesV7: OperatorInitialization<GemmAttributes> = (node: Graph.Node): GemmAttributes =>\n  parseGemmAttributes(node, false);\n\nexport const parseGemmAttributesV11: OperatorInitialization<GemmAttributes> = (node: Graph.Node): GemmAttributes =>\n  parseGemmAttributes(node, true);\n\nconst createGemmProgramInfoLoader = (inputs: Tensor[], attributes: GemmAttributes): ProgramInfoLoader => {\n  const metadata = {\n    name: 'Gemm',\n    inputNames: inputs.length === 3 ? ['A', 'B', 'C'] : ['A', 'B'],\n    inputTypes:\n      inputs.length === 3\n        ? [TextureType.unpacked, TextureType.unpacked, TextureType.unpacked]\n        : [TextureType.unpacked, TextureType.unpacked],\n    key: attributes.cacheKey,\n  };\n\n  return { ...metadata, get: () => createGemmProgramInfo(metadata, inputs, attributes) };\n};\n\nconst createGemmProgramInfo = (\n  metadata: ProgramMetadata,\n  inputs: Tensor[],\n  attributes: GemmAttributes,\n): ProgramInfo => {\n  const aShape = inputs[0].dims.slice();\n  const bShape = inputs[1].dims.slice();\n  const [M, N] = GemmUtil.getShapeOfGemmResult(\n    aShape,\n    attributes.transA,\n    bShape,\n    attributes.transB,\n    inputs.length === 3 ? inputs[2].dims : undefined,\n  );\n  const outputShape = [M, N];\n  if (!outputShape) {\n    throw new Error(\"Can't use gemm on the given tensors\");\n  }\n  let sharedDim = aShape[aShape.length - 1];\n  let line = '';\n  if (attributes.transA) {\n    sharedDim = aShape[0];\n  }\n  if (attributes.transA && attributes.transB) {\n    line = 'value += _A_T(a) * _B_T(b);';\n  } else if (attributes.transA && !attributes.transB) {\n    line = 'value += _A_T(a) * _B(b);';\n  } else if (!attributes.transA && attributes.transB) {\n    line = 'value += _A(a) * _B_T(b);';\n  } else if (!attributes.transA && !attributes.transB) {\n    line = 'value += _A(a) * _B(b);';\n  }\n  const rank = outputShape.length;\n  const declareC = inputs.length === 3 ? `int c[${inputs[2].dims.length}];` : '';\n  const broadcastC = inputs.length === 3 ? 'bcastIndices_C(indices, c);' : '';\n  const calculateC = inputs.length === 3 ? 'value += beta * _C(c);' : '';\n  const shaderSource = `\n      float process(int indices[${rank}]) {\n          int a[${rank}];\n          int b[${rank}];\n          ${declareC}\n\n          copyVec(indices, a);\n          copyVec(indices, b);\n          ${broadcastC}\n\n          float value = 0.0;\n          for (int k=0; k<${sharedDim}; ++k) {\n              a[${rank - 1}] = k;\n              b[${rank - 2}] = k;\n              ${line}\n          }\n\n          value = value * alpha;\n          ${calculateC}\n          return value;\n      }`;\n  return {\n    ...metadata,\n    output: { dims: outputShape, type: inputs[0].type, textureType: TextureType.unpacked },\n    variables: [\n      { name: 'alpha', type: 'float', data: attributes.alpha },\n      { name: 'beta', type: 'float', data: attributes.beta },\n    ],\n    shaderSource,\n  };\n};\n\nconst validateInputs = (inputs: Tensor[], attributes: GemmAttributes): void => {\n  if (!inputs) {\n    throw new Error('Input is missing');\n  }\n  if (attributes.isOptionalC && (inputs.length < 2 || inputs.length > 3)) {\n    throw new Error('Invaid input shape.');\n  }\n  if (!attributes.isOptionalC && inputs.length !== 3) {\n    throw new Error('Gemm requires 3 inputs');\n  }\n\n  // 'C' can be of dimensionality 1 or 2 only\n  if (inputs.length === 3 && inputs[2].dims.length !== 1 && inputs[2].dims.length !== 2) {\n    throw new Error('Invalid input shape of C');\n  }\n\n  if (\n    (inputs[0].type !== 'float32' && inputs[0].type !== 'float64') ||\n    (inputs[1].type !== 'float32' && inputs[1].type !== 'float64') ||\n    (inputs.length === 3 && inputs[2].type !== 'float32' && inputs[2].type !== 'float64')\n  ) {\n    throw new Error('Invalid input type.');\n  }\n\n  if (inputs[0].type !== inputs[1].type || (inputs.length === 3 && inputs[0].type !== inputs[2].type)) {\n    throw new Error('Input types are mismatched');\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { AttributeWithCacheKey, createAttributeWithCacheKey } from '../../../attribute-with-cache-key';\nimport { Graph } from '../../../graph';\nimport { OperatorImplementation, OperatorInitialization } from '../../../operators';\nimport { Tensor } from '../../../tensor';\nimport { WebGLInferenceHandler } from '../inference-handler';\nimport { ProgramInfo, ProgramInfoLoader, ProgramMetadata, TextureType } from '../types';\n\nexport interface ImageScalerAttributes extends AttributeWithCacheKey {\n  scale: number;\n  bias: number[];\n}\n\nexport const imageScaler: OperatorImplementation<ImageScalerAttributes> = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  attributes: ImageScalerAttributes,\n): Tensor[] => {\n  validateInputs(inputs);\n  const output = inferenceHandler.run(createImageScalerProgramInfoLoader(inferenceHandler, inputs, attributes), inputs);\n  return [output];\n};\n\nexport const parseImageScalerAttributes: OperatorInitialization<ImageScalerAttributes> = (\n  node: Graph.Node,\n): ImageScalerAttributes => {\n  const scale = node.attributes.getFloat('scale');\n  const bias = node.attributes.getFloats('bias');\n  return createAttributeWithCacheKey({ scale, bias });\n};\n\nconst imageScalerProgramMetadata = {\n  name: 'ImageScaler',\n  inputNames: ['X'],\n  inputTypes: [TextureType.unpacked],\n};\n\nconst createImageScalerProgramInfo = (\n  _handler: WebGLInferenceHandler,\n  metadata: ProgramMetadata,\n  inputs: Tensor[],\n  attributes: ImageScalerAttributes,\n): ProgramInfo => {\n  const outputShape = inputs[0].dims.slice();\n  const rank = outputShape.length;\n  const getBiasMethod = createGetBiasMethod(attributes.bias.length);\n  const shaderSource = `\n      ${getBiasMethod}\n      float process(int indices[${rank}]) {\n        return _X(indices) * scale + getBias(bias, indices[1]);\n      }`;\n  return {\n    ...metadata,\n    output: { dims: outputShape, type: inputs[0].type, textureType: TextureType.unpacked },\n    variables: [\n      { name: 'bias', type: 'float', arrayLength: attributes.bias.length, data: attributes.bias },\n      { name: 'scale', type: 'float', data: attributes.scale },\n    ],\n    shaderSource,\n  };\n};\n\nconst createImageScalerProgramInfoLoader = (\n  handler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  attributes: ImageScalerAttributes,\n): ProgramInfoLoader => {\n  const metadata = { ...imageScalerProgramMetadata, cacheHint: attributes.cacheKey };\n  return { ...metadata, get: () => createImageScalerProgramInfo(handler, metadata, inputs, attributes) };\n};\n\nconst createGetBiasMethod = (numChannels: number): string => {\n  const codeLines: string[] = [`float getBias(float bias[${numChannels}], int channel) {`];\n  for (let i = 0; i < numChannels; ++i) {\n    if (i === 0) {\n      codeLines.push('\\t' + `if (channel == ${i}) { return bias[${i}]; }`);\n    } else if (i === numChannels - 1) {\n      codeLines.push('\\t' + `else { return bias[${i}]; }`);\n    } else {\n      codeLines.push('\\t' + `else if (channel == ${i}) { return bias[${i}]; }`);\n    }\n  }\n  codeLines.push('\\t' + '}');\n  return codeLines.join('\\n');\n};\n\nconst validateInputs = (inputs: Tensor[]): void => {\n  if (!inputs || inputs.length !== 1) {\n    throw new Error('ImageScaler requires 1 input.');\n  }\n  if (inputs[0].dims.length !== 4) {\n    throw new Error('Invalid input shape.');\n  }\n  if (inputs[0].type !== 'float32' && inputs[0].type !== 'float64') {\n    throw new Error('Invalid input type.');\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Graph } from '../../../graph';\nimport { OperatorImplementation, OperatorInitialization } from '../../../operators';\nimport { Tensor } from '../../../tensor';\nimport { getGlsl } from '../glsl-source';\nimport { WebGLInferenceHandler } from '../inference-handler';\nimport { ProgramInfo, ProgramInfoLoader, ProgramMetadata, TextureType } from '../types';\n\nexport const instanceNormalization: OperatorImplementation<number> = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  epsilon: number,\n): Tensor[] => {\n  validateInputs(inputs);\n\n  const meanAndVariance = inferenceHandler.run(createMeanAndVarianceProgramInfoLoader(inputs[0]), inputs);\n  const output = inferenceHandler.run(\n    createComputeOutputProgramInfoLoader(inferenceHandler, inputs[0], epsilon, meanAndVariance.dims),\n    [inputs[0], meanAndVariance, inputs[1], inputs[2]],\n  );\n  return [output];\n};\n\nexport const parseInstanceNormalizationAttributes: OperatorInitialization<number> = (node: Graph.Node): number =>\n  node.attributes.getFloat('epsilon', 1e-5);\n\nconst meanAndVarianceProgramMetadata = {\n  name: 'InstanceNormalization_MeanAndVariance',\n  inputNames: ['X'],\n  inputTypes: [TextureType.unpacked],\n};\n\nconst createMeanAndVarianceProgramInfo = (metadata: ProgramMetadata, input: Tensor): ProgramInfo => {\n  const xDims = input.dims.slice();\n  const channel = xDims[1];\n  const channelSize = xDims[2] * xDims[3];\n  const outputShape = [xDims[0], channel];\n\n  const shaderSource = `\n      vec4 process(int[2] indices) {\n        vec4 v = vec4(0.0);\n        int a[4];\n        a[0] = indices[0];\n        a[1] = indices[1];\n        float temp = 0.0;\n        for(int a2=0; a2<${xDims[2]}; a2++) {\n          a[2] = a2;\n          for(int a3=0; a3<${xDims[3]}; a3++) {\n            a[3] = a3;\n            float x = _X(a);\n            temp += x;\n          }\n        }\n        float mean = temp / float(${channelSize});\n        temp = 0.0;\n        for(int a2=0; a2<${xDims[2]}; a2++) {\n          a[2] = a2;\n          for(int a3=0; a3<${xDims[3]}; a3++) {\n            a[3] = a3;\n            float x = _X(a);\n            temp += (x - mean) * (x - mean);\n          }\n        }\n        v.r = mean;\n        v.g = temp / float(${channelSize});\n\n        return v;\n      }`;\n  return {\n    ...metadata,\n    output: { dims: outputShape, type: input.type, textureType: TextureType.packedLastDimension },\n    shaderSource,\n  };\n};\n\nconst createMeanAndVarianceProgramInfoLoader = (input: Tensor): ProgramInfoLoader => ({\n  ...meanAndVarianceProgramMetadata,\n  get: () => createMeanAndVarianceProgramInfo(meanAndVarianceProgramMetadata, input),\n});\n\nconst computeOutputProgramMetadata = {\n  name: 'InstanceNormalization_ComputeOutput',\n  inputNames: ['X', 'MeanAndVariance', 'Scale', 'B'],\n  inputTypes: [TextureType.unpacked, TextureType.packedLastDimension, TextureType.unpacked, TextureType.unpacked],\n};\n\nconst createComputeOutputProgramInfo = (\n  inferenceHandler: WebGLInferenceHandler,\n  metadata: ProgramMetadata,\n  input: Tensor,\n  epsilon: number,\n  meanAndVarianceShape: readonly number[],\n): ProgramInfo => {\n  const glsl = getGlsl(inferenceHandler.session.backend.glContext.version);\n  const [textureWidth, textureHeight] = inferenceHandler.calculateTextureWidthAndHeight(\n    meanAndVarianceShape,\n    TextureType.packedLastDimension,\n  );\n  const [meanAndVarianceWidth, meanAndVarianceHeight] = [textureWidth / 4, textureHeight];\n  const shaderSource = `\n      vec4 get_MeanAndVariance(int[2] mv) {\n        int offset = indicesToOffset_MeanAndVariance(mv);\n        vec2 coords = offsetToCoords(offset, ${meanAndVarianceWidth}, ${meanAndVarianceHeight});\n        return ${glsl.texture2D}(MeanAndVariance, coords);\n      }\n\n      float process(int[4] indices) {\n        int mv[2];\n        mv[0] = indices[0];\n        mv[1] = indices[1];\n        vec4 mean_and_variance = get_MeanAndVariance(mv);\n        float mean = mean_and_variance.r;\n        float variance = mean_and_variance.g;\n\n        int sb[1];\n        sb[0] = indices[1];\n        float scale = _Scale(sb);\n        float b = _B(sb);\n\n        return scale * (_X(indices) - mean) / sqrt(variance + epsilon) + b;\n      }`;\n  return {\n    ...metadata,\n    output: { dims: input.dims, type: input.type, textureType: TextureType.unpacked },\n    variables: [{ name: 'epsilon', type: 'float', data: epsilon }],\n    shaderSource,\n  };\n};\n\nconst createComputeOutputProgramInfoLoader = (\n  inferenceHandler: WebGLInferenceHandler,\n  input: Tensor,\n  epsilon: number,\n  meanAndVarianceShape: readonly number[],\n): ProgramInfoLoader => {\n  const metadata = { ...computeOutputProgramMetadata, cacheHint: `${epsilon}` };\n  return {\n    ...metadata,\n    get: () => createComputeOutputProgramInfo(inferenceHandler, metadata, input, epsilon, meanAndVarianceShape),\n  };\n};\n\nconst validateInputs = (inputs: Tensor[]): void => {\n  if (!inputs || inputs.length !== 3) {\n    throw new Error('InstanceNormalization requires 3 inputs.');\n  }\n\n  const X = inputs[0];\n  const scale = inputs[1];\n  const B = inputs[2];\n\n  // input should at least have three dimensions - N,C,dim1,...,dimn\n  // other inputs can have only one dimensions\n  if (X.dims.length < 3 || scale.dims.length !== 1 || B.dims.length !== 1) {\n    throw new Error('Invalid input shape.');\n  }\n  if (scale.dims[0] !== X.dims[1] || B.dims[0] !== X.dims[1]) {\n    throw new Error('Input shapes are mismatched.');\n  }\n  if (\n    (X.type !== 'float32' && X.type !== 'float64') ||\n    (scale.type !== 'float32' && scale.type !== 'float64') ||\n    (B.type !== 'float32' && B.type !== 'float64')\n  ) {\n    throw new Error('Invalid input type.');\n  }\n  if (inputs[0].dims.length !== 4) {\n    throw new Error('Only support 4-D input shape.');\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { AttributeWithCacheKey, createAttributeWithCacheKey } from '../../../attribute-with-cache-key';\nimport { Graph } from '../../../graph';\nimport { OperatorImplementation, OperatorInitialization } from '../../../operators';\nimport { Tensor } from '../../../tensor';\nimport { WebGLInferenceHandler } from '../inference-handler';\nimport { ProgramInfo, ProgramInfoLoader, TextureType } from '../types';\n\nexport interface LrnAttributes extends AttributeWithCacheKey {\n  alpha: number;\n  beta: number;\n  bias: number;\n  size: number;\n}\n\nexport const lrn: OperatorImplementation<LrnAttributes> = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  attributes: LrnAttributes,\n): Tensor[] => {\n  validateInputs(inputs);\n\n  // if (inferenceHandler.session.pack) {\n  //   return [inferenceHandler.run(createPackedLrnProgramInfoLoader(inferenceHandler, inputs, attributes),\n  //   inputs)];\n  // } else {\n  return [inferenceHandler.run(createLrnProgramInfoLoader(inputs, attributes), inputs)];\n  //}\n};\n\nexport const parseLrnAttributes: OperatorInitialization<LrnAttributes> = (node: Graph.Node): LrnAttributes => {\n  const alpha = node.attributes.getFloat('alpha', 0.0001);\n  const beta = node.attributes.getFloat('beta', 0.75);\n  const bias = node.attributes.getFloat('bias', 1.0);\n  const size = node.attributes.getInt('size');\n\n  return createAttributeWithCacheKey({ alpha, beta, bias, size });\n};\n\nconst lrnProgramMetadata = {\n  name: 'LRN',\n  inputNames: ['X'],\n  inputTypes: [TextureType.unpacked],\n};\n\nfunction createLrnProgramInfo(inputs: Tensor[], attributes: LrnAttributes): ProgramInfo {\n  const C = inputs[0].dims[1];\n  const rank = inputs[0].dims.length;\n  const from = -Math.floor((attributes.size - 1) / 2);\n  const to = Math.ceil((attributes.size - 1) / 2);\n  const alpha = `float(${attributes.alpha}) / float(${attributes.size})`;\n  const bias = `float(${attributes.bias})`;\n  const beta = `float(${attributes.beta})`;\n\n  const shaderSource = `\n    float process(int indices[${rank}]) {\n        int c = indices[1];\n        float x = _X(indices);\n        float square_sum = 0.0;\n\n        for (int i = ${from}; i <= ${to}; i++) {\n          int idx = c + i;\n          if (c >= 0 && c < ${C}) {\n            indices[1] = idx;\n            float j = _X(indices);\n            square_sum += j * j;\n          }\n        }\n        return x / pow(${bias} + ${alpha} * square_sum, ${beta});\n    }`;\n  return {\n    ...lrnProgramMetadata,\n    cacheHint: attributes.cacheKey,\n    output: { dims: inputs[0].dims, type: inputs[0].type, textureType: TextureType.unpacked },\n    shaderSource,\n  };\n}\n\nexport function createLrnProgramInfoLoader(inputs: Tensor[], attributes: LrnAttributes): ProgramInfoLoader {\n  return { ...lrnProgramMetadata, cacheHint: attributes.cacheKey, get: () => createLrnProgramInfo(inputs, attributes) };\n}\n\nconst validateInputs = (inputs: Tensor[]): void => {\n  if (!inputs || inputs.length !== 1) {\n    throw new Error('LRN requires 1 input.');\n  }\n  if (inputs[0].dims.length !== 4) {\n    throw new Error('currently only support LRN for input with \"NCHW\" format');\n  }\n  if (inputs[0].type !== 'float32') {\n    throw new Error('input should be float type');\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { AttributeWithCacheKey, createAttributeWithCacheKey } from '../../../attribute-with-cache-key';\nimport { Graph } from '../../../graph';\nimport { OperatorImplementation, OperatorInitialization } from '../../../operators';\nimport { Tensor } from '../../../tensor';\nimport { ShapeUtil } from '../../../util';\nimport { getGlsl, Glsl } from '../glsl-source';\nimport { WebGLInferenceHandler } from '../inference-handler';\nimport { ProgramInfo, TextureType } from '../types';\n\nexport interface PadAttributes extends AttributeWithCacheKey {\n  readonly mode: string;\n  readonly pads: number[];\n  readonly value: number;\n}\n\nconst padProgramMetadata = {\n  name: 'Pad',\n  inputNames: ['A'],\n  inputTypes: [TextureType.unpacked],\n};\n\nexport const padV2: OperatorImplementation<PadAttributes> = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  attributes: PadAttributes,\n): Tensor[] => {\n  validateInputsV2(inputs);\n  const output = inferenceHandler.run(\n    {\n      ...padProgramMetadata,\n      cacheHint: attributes.cacheKey,\n      get: () => createPadProgramInfo(inferenceHandler, inputs[0], attributes),\n    },\n    inputs,\n  );\n  return [output];\n};\n\nexport const parsePadAttributesV2: OperatorInitialization<PadAttributes> = (node: Graph.Node): PadAttributes => {\n  const mode = node.attributes.getString('mode', 'constant');\n  const value = node.attributes.getFloat('value', 0.0);\n  const pads = node.attributes.getInts('pads');\n  return createAttributeWithCacheKey({ mode, value, pads });\n};\n\nexport const padV11: OperatorImplementation<string> = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  mode: string,\n): Tensor[] => {\n  validateInputsV11(inputs);\n  const attrubutes = generatePadAttributesFromInputs(inferenceHandler, inputs, mode);\n  return padV2(inferenceHandler, [inputs[0]], attrubutes);\n};\n\nexport const parsePadAttributesV11: OperatorInitialization<string> = (node: Graph.Node): string =>\n  node.attributes.getString('mode', 'constant');\n\nconst generatePadAttributesFromInputs = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  mode: string,\n): PadAttributes => {\n  if (\n    !inferenceHandler.session.isInitializer(inputs[1].dataId) ||\n    (inputs.length >= 3 && !inferenceHandler.session.isInitializer(inputs[2].dataId))\n  ) {\n    throw new Error('dynamic pad attributes are not allowed');\n  }\n\n  const pads = Array.from(inputs[1].integerData);\n  const value = inputs.length >= 3 ? inputs[2].floatData[0] : 0.0;\n\n  return createAttributeWithCacheKey({ mode, pads, value });\n};\n\nconst createPadProgramInfo = (\n  inferenceHandler: WebGLInferenceHandler,\n  input: Tensor,\n  attributes: PadAttributes,\n): ProgramInfo => {\n  const outputShape = ShapeUtil.padShape(input.dims.slice(), attributes.pads);\n  const rank = outputShape.length;\n  const padFunction = getPadFunction(inferenceHandler, input, attributes);\n  const shaderSource = `\n      ${padFunction}\n      float process(int[${rank}] indices) {\n          return padA(indices);\n      }`;\n  return {\n    name: 'Pad',\n    inputNames: ['A'],\n    inputTypes: [TextureType.unpacked],\n    output: { dims: outputShape, type: input.type, textureType: TextureType.unpacked },\n    shaderSource,\n  };\n};\n\nconst validateInputsV2 = (inputs: Tensor[]): void => {\n  if (!inputs || inputs.length !== 1) {\n    throw new Error('Pad requires 1 input');\n  }\n  if (inputs[0].type !== 'float32' && inputs[0].type !== 'float64') {\n    throw new Error('Invalid input type.');\n  }\n};\n\nconst validateInputsV11 = (inputs: Tensor[]): void => {\n  if (!inputs || (inputs.length !== 2 && inputs.length !== 3)) {\n    throw new Error('Pad requires 2 or 3 inputs');\n  }\n  if (inputs[1].type !== 'int32') {\n    throw new Error('Invalid input type.');\n  }\n  if (inputs.length >= 3 && inputs[2].type === 'string') {\n    throw new Error('Invalid input type.');\n  }\n};\n\nconst getPadFunction = (inferenceHandler: WebGLInferenceHandler, input: Tensor, attributes: PadAttributes): string => {\n  const glsl = getGlsl(inferenceHandler.session.backend.glContext.version);\n  const [width, height] = inferenceHandler.calculateTextureWidthAndHeight(input.dims, TextureType.unpacked);\n  const strides = ShapeUtil.computeStrides(input.dims);\n\n  switch (attributes.mode) {\n    case 'constant':\n      return getPadConstant(glsl, input.dims, strides, width, height, attributes.pads, attributes.value);\n    case 'reflect':\n      return getPadReflect(glsl, input.dims, strides, width, height, attributes.pads);\n    case 'edge':\n      return getPadEdge(glsl, input.dims, strides, width, height, attributes.pads);\n    default:\n      throw new Error('Invalid mode');\n  }\n};\n\nconst getPadConstant = (\n  glsl: Glsl,\n  shape: readonly number[],\n  strides: readonly number[],\n  width: number,\n  height: number,\n  pads: number[],\n  value: number,\n): string => {\n  const rank = shape.length;\n  let block = '';\n  for (let i = rank - 1; i >= 0; --i) {\n    block += `\n        k = m[${i}] - ${pads[i]};\n        if (k < 0)  return constant;\n        if (k >= ${shape[i]}) return constant;\n        offset += k * ${strides[i]};\n        `;\n  }\n  return `\n      float padA(int m[${rank}]) {\n        const float constant = float(${value});\n        int offset = 0;\n        int k = 0;\n        ${block}\n        vec2 coords = offsetToCoords(offset, ${width}, ${height});\n        float value = getColorAsFloat(${glsl.texture2D}(A, coords));\n        return value;\n      }\n      `;\n};\n\nconst getPadReflect = (\n  glsl: Glsl,\n  shape: readonly number[],\n  strides: readonly number[],\n  width: number,\n  height: number,\n  pads: number[],\n): string => {\n  const rank = shape.length;\n\n  let block = '';\n  for (let i = rank - 1; i >= 0; --i) {\n    block += `\n        k = m[${i}] - ${pads[i]};\n        if (k < 0) { k = -k; }\n        {\n          const int _2n_1 = ${2 * (shape[i] - 1)};\n          k = int( mod( float(k), float(_2n_1) ) ) ;\n          if(k >= ${shape[i]}) { k = _2n_1 - k; }\n        }\n        offset += k * ${strides[i]};\n        `;\n  }\n  return `\n      float padA(int m[${rank}]) {\n        int offset = 0;\n        int k = 0;\n        ${block}\n        vec2 coords = offsetToCoords(offset, ${width}, ${height});\n        float value = getColorAsFloat(${glsl.texture2D}(A, coords));\n        return value;\n      }\n      `;\n};\n\nconst getPadEdge = (\n  glsl: Glsl,\n  shape: readonly number[],\n  strides: readonly number[],\n  width: number,\n  height: number,\n  pads: number[],\n): string => {\n  const rank = shape.length;\n\n  let block = '';\n  for (let i = rank - 1; i >= 0; --i) {\n    block += `\n        k = m[${i}] - ${pads[i]};\n        if (k < 0)  k = 0;\n        if (k >= ${shape[i]}) k = ${shape[i] - 1};\n        offset += k * ${strides[i]};\n      `;\n  }\n  return `\n      float padA(int m[${rank}]) {\n        int offset = 0;\n        int k = 0;\n        ${block}\n        vec2 coords = offsetToCoords(offset, ${width}, ${height});\n        float value = getColorAsFloat(${glsl.texture2D}(A, coords));\n        return value;\n      }\n      `;\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { AttributeWithCacheKey, createAttributeWithCacheKey } from '../../../attribute-with-cache-key';\nimport { Graph } from '../../../graph';\nimport { OperatorImplementation, OperatorInitialization } from '../../../operators';\nimport { Tensor } from '../../../tensor';\nimport { PoolConvUtil, ShapeUtil } from '../../../util';\nimport { WebGLInferenceHandler } from '../inference-handler';\nimport { ProgramInfo, ProgramMetadata, TextureType } from '../types';\n\nexport interface AveragePoolAttributes extends AttributeWithCacheKey {\n  readonly autoPad: string;\n  readonly ceilMode: number;\n  readonly countIncludePad: boolean;\n  readonly kernelShape: readonly number[];\n  readonly strides: readonly number[];\n  readonly pads: readonly number[];\n}\n\nexport const averagePool: OperatorImplementation<AveragePoolAttributes> = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  attributes: AveragePoolAttributes,\n): Tensor[] => {\n  validateInputs(inputs);\n  const metadata = {\n    name: 'AveragePool',\n    inputNames: ['X'],\n    inputTypes: [TextureType.unpacked],\n    cacheHint: attributes.cacheKey,\n  };\n  const output = inferenceHandler.run(\n    { ...metadata, get: () => createAveragePoolProgramInfo(inputs, metadata, false, attributes) },\n    inputs,\n  );\n  return [output];\n};\n\nexport const parseAveragePoolAttributes: OperatorInitialization<AveragePoolAttributes> = (\n  node: Graph.Node,\n): AveragePoolAttributes => {\n  const autoPad = node.attributes.getString('auto_pad', 'NOTSET');\n  const ceilMode = node.attributes.getInt('ceil_mode', 0);\n  const countIncludePad = node.attributes.getInt('count_include_pad', 0) === 0 ? false : true;\n  const kernelShape = node.attributes.getInts('kernel_shape');\n  const strides = node.attributes.getInts('strides', []);\n  const pads = node.attributes.getInts('pads', []);\n\n  // TODO: support attribute 'ceil_mode'\n  if (ceilMode !== 0) {\n    throw new Error('using ceil() in shape computation is not yet supported for AveragePool');\n  }\n\n  return createAttributeWithCacheKey({ autoPad, ceilMode, countIncludePad, kernelShape, strides, pads });\n};\n\nconst createAveragePoolProgramInfo = (\n  inputs: Tensor[],\n  metadata: ProgramMetadata,\n  isGlobalOperator: boolean,\n  attributes: AveragePoolAttributes,\n): ProgramInfo => {\n  const [adjustedAttributes, outputShape] = getAdjustedPoolAttributesAndOutputShape(\n    inputs,\n    attributes,\n    isGlobalOperator,\n  );\n  const kernelSize = ShapeUtil.size(adjustedAttributes.kernelShape);\n  const op1 = 'value += _X(x);';\n  let op2 = '';\n  if (adjustedAttributes.countIncludePad) {\n    op2 += `value /= float(${kernelSize});`;\n  } else {\n    op2 += `value /= float(${kernelSize} - pad);`;\n  }\n  const poolingCode = generatePoolingCode(inputs[0].dims, adjustedAttributes, op1, op2, '0.0');\n  const shaderSource = `\n        ${poolingCode}\n      `;\n  return {\n    ...metadata,\n    output: { dims: outputShape, type: inputs[0].type, textureType: TextureType.unpacked },\n    shaderSource,\n  };\n};\n\nexport const globalAveragePool: OperatorImplementation<AveragePoolAttributes> = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  attributes: AveragePoolAttributes,\n): Tensor[] => {\n  validateInputs(inputs);\n  const metadata = {\n    name: 'GlobalAveragePool',\n    inputNames: ['X'],\n    inputTypes: [TextureType.unpacked],\n    cacheHint: `${attributes.countIncludePad}`,\n  };\n  const output = inferenceHandler.run(\n    { ...metadata, get: () => createAveragePoolProgramInfo(inputs, metadata, true, attributes) },\n    inputs,\n  );\n  return [output];\n};\n\nexport const parseGlobalAveragePoolAttributes: OperatorInitialization<AveragePoolAttributes> = (\n  node: Graph.Node,\n): AveragePoolAttributes => {\n  const countIncludePad = node.attributes.getInt('count_include_pad', 0) === 0 ? false : true;\n  return createAttributeWithCacheKey({\n    autoPad: '',\n    ceilMode: 0,\n    countIncludePad,\n    kernelShape: [],\n    strides: [],\n    pads: [],\n  });\n};\n\nexport interface MaxPoolAttributes extends AveragePoolAttributes {\n  readonly storageOrder: number;\n  readonly dilations: number[];\n}\n\nexport const maxPool: OperatorImplementation<MaxPoolAttributes> = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  attributes: MaxPoolAttributes,\n): Tensor[] => {\n  validateInputs(inputs);\n  const metadata = {\n    name: 'MaxPool',\n    inputNames: ['X'],\n    inputTypes: [TextureType.unpacked],\n    cacheHint: attributes.cacheKey,\n  };\n  const output = inferenceHandler.run(\n    { ...metadata, get: () => createMaxPoolProgramInfo(inputs, metadata, false, attributes) },\n    inputs,\n  );\n  return [output];\n};\n\nexport const parseMaxPoolAttributes: OperatorInitialization<MaxPoolAttributes> = (\n  node: Graph.Node,\n): MaxPoolAttributes => {\n  const autoPad = node.attributes.getString('auto_pad', 'NOTSET');\n  const ceilMode = node.attributes.getInt('ceil_mode', 0);\n  const kernelShape = node.attributes.getInts('kernel_shape');\n  const strides = node.attributes.getInts('strides', []);\n  const pads = node.attributes.getInts('pads', []);\n  const storageOrder = node.attributes.getInt('storage_order', 0);\n  const dilations = node.attributes.getInts('dilations', []);\n\n  // TODO: support attribute 'ceil_mode' and 'storage_order'\n  if (storageOrder !== 0) {\n    throw new Error('column major storage order is not yet supported for MaxPool');\n  }\n  if (ceilMode !== 0) {\n    throw new Error('using ceil() in shape computation is not yet supported for MaxPool');\n  }\n\n  return createAttributeWithCacheKey({\n    autoPad,\n    ceilMode,\n    countIncludePad: false,\n    kernelShape,\n    strides,\n    pads,\n    storageOrder,\n    dilations,\n  });\n};\n\nconst createMaxPoolProgramInfo = (\n  inputs: Tensor[],\n  metadata: ProgramMetadata,\n  isGlobalOperator: boolean,\n  attributes: MaxPoolAttributes,\n): ProgramInfo => {\n  const [adjustedAttributes, outputShape] = getAdjustedPoolAttributesAndOutputShape(\n    inputs,\n    attributes,\n    isGlobalOperator,\n  );\n  const op1 = `\n      value = max(_X(x), value);\n    `;\n  const op2 = '';\n  const poolingCode = generatePoolingCode(inputs[0].dims, adjustedAttributes, op1, op2, '-1e5');\n  const shaderSource = `\n      ${poolingCode}\n    `;\n  return {\n    ...metadata,\n    output: { dims: outputShape, type: inputs[0].type, textureType: TextureType.unpacked },\n    shaderSource,\n  };\n};\n\nconst getAdjustedPoolAttributesAndOutputShape = (\n  inputs: Tensor[],\n  attributes: AveragePoolAttributes | MaxPoolAttributes,\n  isGlobalOperator: boolean,\n): [AveragePoolAttributes | MaxPoolAttributes, number[]] => {\n  const inputShape = inputs[0].dims.slice();\n  const hasDilations = Object.hasOwnProperty.call(attributes, 'dilations');\n  const kernelShape = attributes.kernelShape.slice();\n  const strides = attributes.strides.slice();\n  const dilations: number[] = hasDilations ? (attributes as MaxPoolAttributes).dilations.slice() : [];\n  const pads = attributes.pads.slice();\n  PoolConvUtil.adjustPoolAttributes(isGlobalOperator, inputShape, kernelShape, strides, dilations, pads);\n\n  const outputShape = PoolConvUtil.computePoolOutputShape(\n    isGlobalOperator,\n    inputShape,\n    strides,\n    dilations,\n    kernelShape,\n    pads,\n    attributes.autoPad,\n  );\n\n  const newAttributes = Object.assign({}, attributes);\n  if (hasDilations) {\n    Object.assign(newAttributes, { kernelShape, strides, pads, dilations, cacheKey: attributes.cacheKey });\n  } else {\n    Object.assign(newAttributes, { kernelShape, strides, pads, cacheKey: attributes.cacheKey });\n  }\n  return [newAttributes, outputShape];\n};\n\nconst globalMaxPoolAttributes = {\n  autoPad: '',\n  ceilMode: 0,\n  countIncludePad: false,\n  kernelShape: [],\n  strides: [],\n  pads: [],\n  storageOrder: 0,\n  dilations: [],\n  cacheKey: '',\n};\n\nconst globalMaxPoolMetadata = {\n  name: 'GlobalMaxPool',\n  inputNames: ['X'],\n  inputTypes: [TextureType.unpacked],\n};\n\nexport const globalMaxPool = (inferenceHandler: WebGLInferenceHandler, inputs: Tensor[]): Tensor[] => {\n  validateInputs(inputs);\n  const output = inferenceHandler.run(\n    {\n      ...globalMaxPoolMetadata,\n      get: () => createMaxPoolProgramInfo(inputs, globalMaxPoolMetadata, true, globalMaxPoolAttributes),\n    },\n    inputs,\n  );\n  return [output];\n};\n\nconst validateInputs = (inputs: Tensor[]): void => {\n  if (!inputs || inputs.length !== 1) {\n    throw new Error('Pool ops requires 1 input.');\n  }\n  if (inputs[0].type !== 'float32' && inputs[0].type !== 'float64') {\n    throw new Error('Invalid input type.');\n  }\n};\n\nconst generatePoolingCode = (\n  inputDims: readonly number[],\n  attributes: AveragePoolAttributes,\n  op1: string,\n  op2: string,\n  start: string,\n): string => {\n  const rank = inputDims.length;\n  if (attributes.kernelShape.length <= 2) {\n    const kw = attributes.kernelShape[attributes.kernelShape.length - 1];\n    const sw = attributes.strides[attributes.strides.length - 1];\n    const pwStart = attributes.pads[attributes.pads.length / 2 - 1];\n    const pwEnd = attributes.pads[attributes.pads.length - 1];\n    const dimW = inputDims[rank - 1];\n    let codeW = '';\n    let codeH = '';\n    let codeHEnd = '';\n    if (pwStart + pwEnd !== 0) {\n      codeW = `\n          for (int i = 0; i < ${kw}; i++) {\n            x[${rank} - 1] = indices[${rank} - 1] * ${sw} - ${pwStart} + i;\n            if (x[${rank} - 1] < 0 || x[${rank} - 1] >= ${dimW}) {\n              pad++;\n              continue;\n            }\n            ${op1}\n          }`;\n    } else {\n      codeW = `\n          for (int i = 0; i < ${kw}; i++) {\n            x[${rank} - 1] = indices[${rank} - 1] * ${sw} - ${pwStart} + i;\n            ${op1}\n          }`;\n    }\n\n    if (attributes.kernelShape.length === 2) {\n      const kh = attributes.kernelShape[attributes.kernelShape.length - 2];\n      const sh = attributes.strides[attributes.strides.length - 2];\n      const phStart = attributes.pads[attributes.pads.length / 2 - 2];\n      const phEnd = attributes.pads[attributes.pads.length - 2];\n      const dimH = inputDims[rank - 2];\n      if (phStart + phEnd !== 0) {\n        codeH = `\n            for (int j = 0; j < ${kh}; j++) {\n              x[${rank} - 2] = indices[${rank} - 2] * ${sh} - ${phStart} + j;\n              if (x[${rank} - 2] < 0 || x[${rank} - 2] >= ${dimH}) {\n                pad+= ${kw};\n                continue;\n              }\n          `;\n      } else {\n        codeH = `\n            for (int j = 0; j < ${kh}; j++) {\n              x[${rank} - 2] = indices[${rank} - 2] * ${sh} - ${phStart} + j;\n            `;\n      }\n      codeHEnd = `\n          }\n        `;\n    }\n\n    const poolingCode = `\n        float process(int indices[${rank}]) {\n          int x[${rank}];\n          copyVec(indices, x);\n\n          float value = ${start};\n          int pad = 0;\n          ${codeH}\n          ${codeW}\n          ${codeHEnd}\n          ${op2}\n          return value;\n        }\n      `;\n    return poolingCode;\n  } else {\n    const kernelSize = ShapeUtil.size(attributes.kernelShape);\n    const kernelStrides = ShapeUtil.computeStrides(attributes.kernelShape);\n    const stridesRank = kernelStrides.length;\n    const padsRank = attributes.pads.length;\n    const offsetToIndicesFunction = offsetToIndices(stridesRank);\n    const copyInputDims = copyArray(inputDims, 'inputDims');\n    const copyPads = copyArray(attributes.pads, 'pads');\n    const copyKernelStrides = copyArray(kernelStrides, 'kernelStrides');\n    const copyStrides = copyArray(attributes.strides, 'strides');\n    const hasPads = attributes.pads.reduce((sum, cur) => sum + cur);\n    let padCode = '';\n    if (hasPads) {\n      padCode = `\n            if (x[j] >= inputDims[j] || x[j] < 0) {\n              pad++;\n              isPad = true;\n              break;\n            }\n          }\n          if (!isPad) {\n            ${op1}\n          }`;\n    } else {\n      padCode = `\n          }\n          ${op1}\n        `;\n    }\n    const poolingCode = `\n        ${offsetToIndicesFunction}\n        float process(int indices[${rank}]) {\n          int x[${rank}];\n          copyVec(indices, x);\n          int offset[${stridesRank}];\n          int pads[${padsRank}];\n          int inputDims[${rank}];\n          int kernelStrides[${stridesRank}];\n          int strides[${stridesRank}];\n          ${copyPads}\n          ${copyInputDims}\n          ${copyStrides}\n          ${copyKernelStrides}\n\n          float value = ${start};\n          int pad = 0;\n          bool isPad = false;\n          for (int i = 0; i < ${kernelSize}; i++) {\n            offsetToIndices(i, kernelStrides, offset);\n            isPad = false;\n            for (int j = ${rank} - ${stridesRank}; j < ${rank}; j++) {\n              x[j] = indices[j] * strides[j - ${rank} + ${stridesRank}]\n                + offset[j - ${rank} + ${stridesRank}] - pads[j - 2];\n              ${padCode}\n          }\n          ${op2}\n\n          return value;\n        }\n      `;\n    return poolingCode;\n  }\n};\n\nconst copyArray = (array: readonly number[], arrayName: string): string => {\n  let block = '';\n  for (let i = 0; i < array.length; i++) {\n    block += `\n      ${arrayName}[${i}] = ${array[i]};\n    `;\n  }\n  return block;\n};\n\nconst offsetToIndices = (rank: number): string => `\n  void offsetToIndices(int offset, int[${rank}] strides, out int[${rank}] indices) {\n    if (${rank} == 0) {\n      return;\n    }\n    for (int i = 0; i < ${rank} - 1; ++i) {\n      indices[i] = offset / strides[i];\n      offset -= indices[i] * strides[i];\n    }\n    indices[${rank} - 1] = offset;\n  }`;\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { AttributeWithCacheKey, createAttributeWithCacheKey } from '../../../attribute-with-cache-key';\nimport { Graph } from '../../../graph';\nimport { NUMBER_TYPES, OperatorImplementation, OperatorInitialization } from '../../../operators';\nimport { Tensor } from '../../../tensor';\nimport { ShapeUtil } from '../../../util';\nimport { WebGLInferenceHandler } from '../inference-handler';\nimport { ProgramInfo, ProgramMetadata, TextureType } from '../types';\n\nexport interface ReduceAttributes extends AttributeWithCacheKey {\n  readonly axes: number[];\n  readonly keepDims: boolean;\n}\n\n// return [init ops, reduce ops, final ops]\ntype ReduceOp = (inputs: Tensor[], axes: number[]) => string[];\n\nconst reduce = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  attributes: ReduceAttributes,\n  name: string,\n  reduceOp: ReduceOp,\n): Tensor[] => {\n  validateInputs(inputs);\n\n  const reduceProgramMetadata = {\n    name,\n    inputNames: ['A'],\n    inputTypes: [TextureType.unpacked],\n  };\n\n  const output = inferenceHandler.run(\n    {\n      ...reduceProgramMetadata,\n      cacheHint: attributes.cacheKey,\n      get: () => createReduceProgramInfo(inferenceHandler, inputs, attributes, name, reduceOp, reduceProgramMetadata),\n    },\n    inputs,\n  );\n  return [output];\n};\n\nexport const parseReduceAttributes: OperatorInitialization<ReduceAttributes> = (node: Graph.Node): ReduceAttributes => {\n  const axes = node.attributes.getInts('axes', []);\n  const keepDims = node.attributes.getInt('keepdims', 1) === 1;\n  return createAttributeWithCacheKey({ axes, keepDims });\n};\n\nconst createReduceProgramInfo = (\n  _handler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  attributes: ReduceAttributes,\n  _name: string,\n  reduceOp: ReduceOp,\n  reduceProgramMetadata: ProgramMetadata,\n): ProgramInfo => {\n  const outputShape: number[] = [];\n  const iRank = inputs[0].dims.length || 1;\n\n  const idxCopy = []; // copy output indexes to input indexes\n\n  const axes = ShapeUtil.normalizeAxes(attributes.axes, inputs[0].dims.length);\n  const ops = reduceOp(inputs, axes);\n  let reduceOps = ops[1];\n\n  for (let k = 0; k < inputs[0].dims.length; k++) {\n    // if this axis is reduced\n    if (axes.indexOf(k) >= 0 || axes.length === 0) {\n      if (attributes.keepDims) {\n        outputShape.push(1);\n      } // else { remove the axis from outputShape; }\n\n      // loop over the d-th axis\n      reduceOps = `\n          for(int j${k} = 0; j${k} < ${inputs[0].dims[k]}; j${k}++) {\n            inputIdx[${k}] = j${k};\n            ${reduceOps}\n          }`;\n    } else {\n      idxCopy.push(`inputIdx[${k}] = outputIdx[${outputShape.length}];`);\n\n      outputShape.push(inputs[0].dims[k]);\n    }\n  }\n\n  const oRank = outputShape.length || 1;\n\n  const shaderSource = `\n      float process(int outputIdx[${oRank}]) {\n        float value;                 // final result\n        int inputIdx[${iRank}];      // addressing input data\n        ${idxCopy.join('\\n')}\n        ${ops[0]}       // init ops for reduce max/min\n        ${reduceOps}\n        ${ops[2]}       // final computation for reduce mean\n        return value;\n      }`;\n\n  return {\n    ...reduceProgramMetadata,\n    output: { dims: outputShape, type: inputs[0].type, textureType: TextureType.unpacked },\n    shaderSource,\n  };\n};\n\nconst validateInputs = (inputs: Tensor[]): void => {\n  // TODO: support Reduce* operators with 2 inputs.\n  if (!inputs || inputs.length !== 1) {\n    throw new Error('Reduce op requires 1 input.');\n  }\n\n  if (NUMBER_TYPES.indexOf(inputs[0].type) === -1) {\n    throw new Error('Invalid input type.');\n  }\n};\n\nexport const reduceSum: OperatorImplementation<ReduceAttributes> = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  attributes: ReduceAttributes,\n): Tensor[] => {\n  const reduceOp: ReduceOp = (): string[] => ['value = 0.0;', 'value += _A(inputIdx);', ''];\n  return reduce(inferenceHandler, inputs, attributes, 'ReduceSum', reduceOp);\n};\n\nexport const reduceMean: OperatorImplementation<ReduceAttributes> = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  attributes: ReduceAttributes,\n): Tensor[] => {\n  const reduceOp: ReduceOp = (inputs: Tensor[], axes: number[]): string[] => {\n    let size = 1.0;\n    for (let k = 0; k < inputs[0].dims.length; k++) {\n      if (axes.indexOf(k) >= 0 || axes.length === 0) {\n        size *= inputs[0].dims[k];\n      }\n    }\n\n    return ['value = 0.0;', 'value += _A(inputIdx);', `value /= ${size}.;`]; // ensure real number with `.`\n  };\n  return reduce(inferenceHandler, inputs, attributes, 'ReduceMean', reduceOp);\n};\n\nexport const reduceMax: OperatorImplementation<ReduceAttributes> = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  attributes: ReduceAttributes,\n): Tensor[] => {\n  const reduceOp: ReduceOp = (inputs: Tensor[], axes: number[]): string[] => {\n    const idxZero = [];\n    for (let k = 0; k < inputs[0].dims.length; k++) {\n      if (axes.indexOf(k) >= 0 || axes.length === 0) {\n        idxZero.push(`inputIdx[${k}] = 0;`); // first element\n      }\n    }\n\n    return [`${idxZero.join('\\n')}\\nvalue = _A(inputIdx);`, 'value = max(value, _A(inputIdx));', ''];\n  };\n  return reduce(inferenceHandler, inputs, attributes, 'ReduceMax', reduceOp);\n};\n\nexport const reduceMin: OperatorImplementation<ReduceAttributes> = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  attributes: ReduceAttributes,\n): Tensor[] => {\n  const reduceOp: ReduceOp = (inputs: Tensor[], axes: number[]): string[] => {\n    const idxZero = [];\n    for (let k = 0; k < inputs[0].dims.length; k++) {\n      if (axes.indexOf(k) >= 0 || axes.length === 0) {\n        idxZero.push(`inputIdx[${k}] = 0;`); // first element\n      }\n    }\n\n    return [`${idxZero.join('\\n')}\\nvalue = _A(inputIdx);`, 'value = min(value, _A(inputIdx));', ''];\n  };\n  return reduce(inferenceHandler, inputs, attributes, 'ReduceMin', reduceOp);\n};\n\nexport const reduceProd: OperatorImplementation<ReduceAttributes> = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  attributes: ReduceAttributes,\n): Tensor[] => {\n  const reduceOp: ReduceOp = (): string[] => ['value = 1.0;', 'value *= _A(inputIdx);', ''];\n  return reduce(inferenceHandler, inputs, attributes, 'ReduceProd', reduceOp);\n};\n\nexport const reduceLogSum: OperatorImplementation<ReduceAttributes> = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  attributes: ReduceAttributes,\n): Tensor[] => {\n  const reduceOp: ReduceOp = (): string[] => ['value = 0.0;', 'value += _A(inputIdx);', 'value = log(value);'];\n  return reduce(inferenceHandler, inputs, attributes, 'ReduceLogSum', reduceOp);\n};\n\nexport const reduceLogSumSquare: OperatorImplementation<ReduceAttributes> = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  attributes: ReduceAttributes,\n): Tensor[] => {\n  const reduceOp: ReduceOp = (): string[] => ['float t; value = 0.0;', 't = _A(inputIdx); value += t * t;', ''];\n  return reduce(inferenceHandler, inputs, attributes, 'ReduceLogSumSquare', reduceOp);\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Tensor } from '../../../tensor';\nimport { ShapeUtil } from '../../../util';\nimport { WebGLInferenceHandler } from '../inference-handler';\n\nexport const reshape = (handler: WebGLInferenceHandler, inputs: Tensor[]): Tensor[] => {\n  const reshapedDims = ShapeUtil.calculateReshapedDims(inputs[0].dims, inputs[1].integerData);\n  if (handler.session.pack) {\n    return [handler.reshapePacked(inputs[0], reshapedDims)];\n  } else {\n    return [handler.reshapeUnpacked(inputs[0], reshapedDims)];\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { AttributeWithCacheKey, createAttributeWithCacheKey } from '../../../attribute-with-cache-key';\nimport { Graph } from '../../../graph';\nimport { OperatorImplementation, OperatorInitialization } from '../../../operators';\nimport { Tensor } from '../../../tensor';\nimport { getGlsl } from '../glsl-source';\nimport { WebGLInferenceHandler } from '../inference-handler';\nimport { ProgramInfo, TextureType } from '../types';\n\nexport interface UpsampleAttributes extends AttributeWithCacheKey {\n  readonly opset: number;\n  readonly isResize: boolean;\n  readonly mode: string;\n  readonly scales: number[];\n  readonly extrapolationValue: number;\n  readonly coordinateTransformMode: string;\n  readonly useExtrapolation: boolean;\n  readonly needRoiInput: boolean;\n  readonly nearestMode: string;\n  readonly cubicCoefficientA: number;\n  readonly excludeOutside: boolean;\n  readonly useNearest2xOptimization: boolean;\n  readonly roiInputIdx: number;\n  readonly scalesInputIdx: number;\n  readonly sizesInputIdx: number;\n}\n\nconst upsampleProgramMetadata = {\n  name: 'Upsample',\n  inputNames: ['X'],\n  inputTypes: [TextureType.unpacked],\n};\n\nexport const upsample: OperatorImplementation<UpsampleAttributes> = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  attributes: UpsampleAttributes,\n): Tensor[] => {\n  validateInputs(inputs, attributes);\n  const output = inferenceHandler.run(\n    {\n      ...upsampleProgramMetadata,\n      cacheHint: attributes.cacheKey,\n      get: () => createUpsampleProgramInfo(inferenceHandler, inputs, attributes),\n    },\n    inputs,\n  );\n  return [output];\n};\n\nexport const parseUpsampleAttributesV7: OperatorInitialization<UpsampleAttributes> = (\n  node: Graph.Node,\n): UpsampleAttributes => parseUpsampleAttributes(node, 7);\n\nexport const parseUpsampleAttributesV9: OperatorInitialization<UpsampleAttributes> = (\n  node: Graph.Node,\n): UpsampleAttributes => parseUpsampleAttributes(node, 9);\n\nexport const parseUpsampleAttributes = (node: Graph.Node, opset: number): UpsampleAttributes => {\n  const isResize = opset >= 10;\n\n  // processing node attributes\n  const mode = node.attributes.getString('mode', 'nearest');\n  if (mode !== 'nearest' && mode !== 'linear' && (opset < 11 || mode !== 'cubic')) {\n    throw new Error(`unrecognized mode: ${mode}`);\n  }\n\n  let scales: number[] = [];\n  if (opset < 9) {\n    scales = node.attributes.getFloats('scales');\n    scalesValidation(scales, mode, isResize);\n  }\n\n  const extrapolationValue = node.attributes.getFloat('extrapolation_value', 0.0);\n\n  const coordinateTransformMode =\n    opset > 10 ? node.attributes.getString('coordinate_transformation_mode', 'half_pixel') : 'asymmetric';\n  if (\n    [\n      'asymmetric',\n      'pytorch_half_pixel',\n      'tf_half_pixel_for_nn',\n      'align_corners',\n      'tf_crop_and_resize',\n      'half_pixel',\n    ].indexOf(coordinateTransformMode) === -1\n  ) {\n    throw new Error(`coordinate_transform_mode '${coordinateTransformMode}' is not supported`);\n  }\n  const needRoiInput = coordinateTransformMode === 'tf_crop_and_resize';\n  const useExtrapolation = needRoiInput;\n\n  const nearestMode =\n    mode === 'nearest' && opset >= 11 ? node.attributes.getString('nearest_mode', 'round_prefer_floor') : '';\n  if (['round_prefer_floor', 'round_prefer_ceil', 'floor', 'ceil', ''].indexOf(nearestMode) === -1) {\n    throw new Error(`nearest_mode '${nearestMode}' is not supported`);\n  }\n\n  const cubicCoefficientA = node.attributes.getFloat('cubic_coeff_a', -0.75);\n  const excludeOutside = node.attributes.getInt('exclude_outside', 0) !== 0;\n  if (excludeOutside && mode !== 'cubic') {\n    throw new Error('exclude_outside can be set to 1 only when mode is CUBIC.');\n  }\n\n  const useNearest2xOptimization =\n    opset < 11 ? true : mode === 'nearest' && coordinateTransformMode === 'asymmetric' && nearestMode === 'floor';\n\n  let roiInputIdx = 0;\n  let scalesInputIdx = 0;\n  let sizesInputIdx = 0;\n\n  if (opset > 10) {\n    // handle when roiInput is not given\n    if (node.inputs.length > 2) {\n      roiInputIdx = 1;\n      scalesInputIdx = 2;\n      sizesInputIdx = 3;\n    } else {\n      scalesInputIdx = 1;\n      sizesInputIdx = 2;\n    }\n  } else if (opset === 9) {\n    scalesInputIdx = 1;\n  }\n\n  return createAttributeWithCacheKey({\n    opset,\n    isResize,\n    mode,\n    scales,\n    extrapolationValue,\n    coordinateTransformMode,\n    useExtrapolation,\n    needRoiInput,\n    nearestMode,\n    cubicCoefficientA,\n    excludeOutside,\n    useNearest2xOptimization,\n    roiInputIdx,\n    scalesInputIdx,\n    sizesInputIdx,\n  });\n};\n\nconst createUpsampleProgramInfo = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  attributes: UpsampleAttributes,\n): ProgramInfo => {\n  const glsl = getGlsl(inferenceHandler.session.backend.glContext.version);\n  const [inputWidth, inputHeight] = inferenceHandler.calculateTextureWidthAndHeight(\n    inputs[0].dims,\n    TextureType.unpacked,\n  );\n\n  const outputShape = inputs[0].dims.map((dim, i) => Math.floor(dim * attributes.scales[i]));\n  const [outputWidth, outputHeight] = inferenceHandler.calculateTextureWidthAndHeight(\n    outputShape,\n    TextureType.unpacked,\n  );\n  const dim = outputShape.length;\n\n  const outputPitches = new Array<number>(dim);\n  const inputPitches = new Array<number>(dim);\n  let precalculatedPitches = `\n      int output_pitches[${dim}];\n      int input_pitches[${dim}];\n      `;\n  for (let d = dim - 1; d >= 0; d--) {\n    outputPitches[d] = d === dim - 1 ? 1 : outputPitches[d + 1] * outputShape[d + 1];\n    inputPitches[d] = d === dim - 1 ? 1 : inputPitches[d + 1] * inputs[0].dims[d + 1];\n\n    precalculatedPitches += `\n        output_pitches[${d}] = ${outputPitches[d]};\n        input_pitches[${d}] = ${inputPitches[d]};\n        `;\n  }\n  const getInputFloatFunction = `\n      float getInputFloat(int index) {\n        vec2 coords = offsetToCoords(index, ${inputWidth}, ${inputHeight});\n        float value = getColorAsFloat(${glsl.texture2D}(X, coords));\n        return value;\n      }\n      `;\n\n  const shaderSource =\n    attributes.mode === 'nearest'\n      ? // nearest\n        `\n    ${getInputFloatFunction}\n    float process(int indices[${dim}]) {\n      int input_index = 0;\n      int output_index = coordsToOffset(TexCoords, ${outputWidth}, ${outputHeight});\n\n      ${precalculatedPitches}\n\n      int d, m;\n      for (int dim = 0; dim < ${dim}; ++dim) {\n        d = output_index / output_pitches[dim];\n        m = output_index - d * output_pitches[dim];\n        output_index = m;\n\n        if (scales[dim] != 1 && d > 0) {\n          int d2 = d / scales[dim];\n          m = d - d2 * scales[dim];\n          d = d2;\n        }\n        input_index += input_pitches[dim] * d;\n      }\n\n      return getInputFloat(input_index);\n    }`\n      : dim === 4\n        ? // bilinear 4D\n          `\n    ${getInputFloatFunction}\n    float process(int indices[4]) {\n      int input_index = 0;\n      int output_index = coordsToOffset(TexCoords, ${outputWidth}, ${outputHeight});\n\n      ${precalculatedPitches}\n\n      int m;\n      int index_of_dim0, index_of_dim1, index_of_dim2, index_of_dim3;\n      index_of_dim0 = output_index / output_pitches[0];\n      m = output_index - index_of_dim0 * output_pitches[0];\n      index_of_dim1 = m / output_pitches[1];\n      m = m - index_of_dim1 * output_pitches[1];\n      index_of_dim2 = m / output_pitches[2];\n      m = m - index_of_dim2 * output_pitches[2];\n      index_of_dim3 = m;\n\n      int index_of_input_dim2, index_of_input_dim3, x_offset, y_offset;\n      index_of_input_dim2 = index_of_dim2 / scales[2];\n      y_offset = index_of_dim2 - index_of_input_dim2 * scales[2];\n      index_of_input_dim3 = index_of_dim3 / scales[3];\n      x_offset = index_of_dim3 - index_of_input_dim3 * scales[3];\n\n      input_index = index_of_dim0 * input_pitches[0] +\n            index_of_dim1 * input_pitches[1] +\n            index_of_input_dim2 * input_pitches[2] +\n            index_of_input_dim3;\n\n      float x00 = getInputFloat(input_index);\n      float x10, x01, x11;\n\n      bool end_of_dim2 = false;\n      if (index_of_input_dim2 == (${inputs[0].dims[2]} - 1)) {\n        // It's the end in dimension 2\n        x01 = x00;\n        end_of_dim2 = true;\n      } else {\n        x01 = getInputFloat(input_index + input_pitches[2]);\n      }\n\n      if (index_of_input_dim3 == (input_pitches[2] - 1)) {\n        // It's the end in dimension 3\n        x10 = x00;\n        x11 = x01;\n      }\n      else {\n        x10 = getInputFloat(input_index + 1);\n        x11 = end_of_dim2 ? x10 : getInputFloat(input_index + input_pitches[2] + 1);\n      }\n\n      float y0 = x00 + float(y_offset) * (x01 - x00) / float(scales[2]);\n      float y1 = x10 + float(y_offset) * (x11 - x10) / float(scales[2]);\n      return y0 + float(x_offset) * (y1 - y0) / float(scales[3]);\n    }`\n        : // bilinear 2D\n          `\n    ${getInputFloatFunction}\n    float process(int indices[2]) {\n      int input_index = 0;\n      int output_index = coordsToOffset(TexCoords, ${outputWidth}, ${outputHeight});\n\n      ${precalculatedPitches}\n\n      int m;\n      int index_of_dim0, index_of_dim1;\n      index_of_dim0 = output_index / output_pitches[0];\n      m = output_index - index_of_dim0 * output_pitches[0];\n      index_of_dim1 = m;\n\n      int index_of_input_dim0, index_of_input_dim1, x_offset, y_offset;\n      index_of_input_dim0 = index_of_dim0 / scales[0];\n      y_offset = index_of_dim0 - index_of_input_dim0 * scales[0];\n      index_of_input_dim1 = index_of_dim1 / scales[1];\n      x_offset = index_of_dim1 - index_of_input_dim1 * scales[1];\n\n      input_index = index_of_input_dim0 * input_pitches[0] + index_of_input_dim1;\n\n      float x00 = getInputFloat(input_index);\n      float x10, x01, x11;\n\n      bool end_of_dim0 = false;\n      if (index_of_input_dim0 == (${inputs[0].dims[0]} - 1)) {\n        // It's the end in dimension 0\n        x01 = x00;\n        end_of_dim0 = true;\n      } else {\n        x01 = getInputFloat(input_index + input_pitches[0]);\n      }\n\n      if (index_of_input_dim1 == (input_pitches[0] - 1)) {\n        // It's the end in dimension 1\n        x10 = x00;\n        x11 = x01;\n      }\n      else {\n        x10 = getInputFloat(input_index + 1);\n        x11 = end_of_dim0 ? x10 : getInputFloat(input_index + input_pitches[0] + 1);\n      }\n\n      float y0 = x00 + float(y_offset) * (x01 - x00) / float(scales[0]);\n      float y1 = x10 + float(y_offset) * (x11 - x10) / float(scales[0]);\n      return y0 + float(x_offset) * (y1 - y0) / float(scales[1]);\n    }`;\n  return {\n    ...upsampleProgramMetadata,\n    output: { dims: outputShape, type: inputs[0].type, textureType: TextureType.unpacked },\n    shaderSource,\n    variables: [\n      {\n        name: 'scales',\n        type: 'int',\n        arrayLength: attributes.scales.length,\n        data: attributes.scales.map((x) => Math.ceil(x)),\n      },\n    ],\n  };\n};\n\nexport const validateInputs = (inputs: Tensor[], attribute: UpsampleAttributes): void => {\n  if (\n    !inputs ||\n    (attribute.opset < 9 && inputs.length !== 1) ||\n    (attribute.opset >= 9 && attribute.opset < 11 && inputs.length !== 2) ||\n    (attribute.opset >= 11 && inputs.length < 2)\n  ) {\n    throw new Error('invalid inputs.');\n  }\n\n  if (attribute.scales.length > 0 && inputs[0].dims.length !== attribute.scales.length) {\n    throw new Error('Invalid input shape.');\n  }\n\n  if (inputs[0].type === 'string') {\n    throw new Error('Invalid input tensor types.');\n  }\n};\n\nexport const scalesValidation = (scales: number[], mode: string, isResize: boolean): void => {\n  if (!isResize) {\n    for (const scale of scales) {\n      if (scale < 1) {\n        throw new Error('Scale value should be greater than or equal to 1.');\n      }\n    }\n  } else {\n    for (const scale of scales) {\n      if (scale <= 0) {\n        throw new Error('Scale value should be greater than 0.');\n      }\n    }\n  }\n  if (mode === 'linear' || mode === 'cubic') {\n    if (scales.length !== 2 && (scales.length !== 4 || scales[0] !== 1 || scales[1] !== 1)) {\n      throw new Error(`'Linear' mode and 'Cubic' mode only support 2-D inputs ('Bilinear', 'Bicubic') \\\n        or 4-D inputs with the corresponding outermost 2 scale values being 1 \\\n        in the ${isResize ? 'Resize' : 'Upsample'} opeartor.`);\n    }\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Graph } from '../../../graph';\nimport { OperatorImplementation, OperatorInitialization } from '../../../operators';\nimport { Tensor } from '../../../tensor';\nimport { getGlsl } from '../glsl-source';\nimport { WebGLInferenceHandler } from '../inference-handler';\nimport { ProgramInfo, TextureType } from '../types';\nimport { getCoordsDataType } from '../utils';\n\nimport { unpackFromChannel } from './packing-utils';\nimport { parseUpsampleAttributes, scalesValidation, UpsampleAttributes, validateInputs } from './upsample';\n\nconst resizeProgramMetadata = {\n  name: 'Resize',\n  inputNames: ['A'],\n  inputTypes: [TextureType.packed],\n};\n\nexport const resize: OperatorImplementation<UpsampleAttributes> = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  attributes: UpsampleAttributes,\n): Tensor[] => {\n  validateInputs(inputs, attributes);\n  const output = inferenceHandler.run(\n    {\n      ...resizeProgramMetadata,\n      cacheHint: attributes.cacheKey,\n      get: () => createPackedResizeProgramInfo(inferenceHandler, inputs, attributes),\n    },\n    inputs,\n  );\n  return [output];\n};\n\nexport const parseResizeAttributesV10: OperatorInitialization<UpsampleAttributes> = (\n  node: Graph.Node,\n): UpsampleAttributes => parseUpsampleAttributes(node, 10);\n\nexport const parseResizeAttributesV11: OperatorInitialization<UpsampleAttributes> = (\n  node: Graph.Node,\n): UpsampleAttributes => parseUpsampleAttributes(node, 11);\n\nconst createPackedResizeProgramInfo = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  attributes: UpsampleAttributes,\n): ProgramInfo => {\n  const glsl = getGlsl(inferenceHandler.session.backend.glContext.version);\n  const [scales, outputShape] = prepareInputs(inputs, attributes);\n\n  const isSame = scales.every((s: number) => s === 1) && attributes.coordinateTransformMode !== 'tf_crop_and_resize';\n  if (isSame) {\n    return {\n      ...resizeProgramMetadata,\n      output: { dims: outputShape, type: inputs[0].type, textureType: TextureType.packed },\n      hasMain: true,\n      shaderSource: `void main() {\n                    vec4 v = ${glsl.texture2D}(X, TexCoords);\n                    ${glsl.output} = v;\n                }`,\n    };\n  }\n\n  const dim = outputShape.length;\n  if (dim < 2) {\n    throw new Error(`output dimension should be at least 2, but got ${dim}`);\n  }\n\n  const outputHeight = outputShape[dim - 2];\n  const outputWidth = outputShape[dim - 1];\n\n  const inputShape = inputs[0].dims;\n  if (dim !== inputShape.length) {\n    throw new Error(`output dimension should match input ${inputShape.length}, but got ${dim}`);\n  }\n  const inputHeight = inputShape[dim - 2];\n  const inputWidth = inputShape[dim - 1];\n\n  const scalesHeight = scales[dim - 2];\n  const scalesWidth = scales[dim - 1];\n\n  let getSourceFracIndex = '';\n\n  if (attributes.mode !== 'linear') {\n    // TODO: support other modes\n    throw new Error(`resize (packed) does not support mode: '${attributes.mode}'`);\n  }\n  switch (attributes.coordinateTransformMode) {\n    case 'asymmetric':\n      getSourceFracIndex = `\n                    vec4 getSourceFracIndex(ivec4 coords) {\n                        return vec4(coords) / scaleWHWH;\n                    }\n                `;\n      break;\n    case 'half_pixel':\n      getSourceFracIndex = `\n                    vec4 getSourceFracIndex(ivec4 coords) {\n                        return (vec4(coords) + 0.5) / scaleWHWH - 0.5;\n                    }\n                `;\n      break;\n    case 'pytorch_half_pixel':\n      getSourceFracIndex = `\n                    vec4 getSourceFracIndex(ivec4 coords) {\n                        vec4 fcoords = vec4(coords);\n                        return vec4(\n                            ${outputWidth}.0 > 1.0 ? (fcoords.x + 0.5) / scaleWHWH.x - 0.5 : 0.0,\n                            ${outputHeight}.0 > 1.0 ? (fcoords.y + 0.5) / scaleWHWH.y - 0.5 : 0.0,\n                            ${outputWidth}.0 > 1.0 ? (fcoords.z + 0.5) / scaleWHWH.z - 0.5 : 0.0,\n                            ${outputHeight}.0 > 1.0 ? (fcoords.w + 0.5) / scaleWHWH.w - 0.5 : 0.0\n                          );\n                    }\n                `;\n      break;\n    case 'align_corners':\n      getSourceFracIndex = `\n                    vec4 getSourceFracIndex(ivec4 coords) {\n                        vec4 resized = vec4(${outputWidth}.0 - 1.0, ${outputHeight}.0 - 1.0, ${outputWidth}.0 - 1.0,\n                            ${outputHeight}.0 - 1.0);\n                        vec4 original = vec4(${inputWidth}.0 - 1.0, ${inputHeight}.0 - 1.0, ${inputWidth}.0 - 1.0,\n                            ${inputHeight}.0 - 1.0);\n                        vec4 new_scale = original / resized;\n                        return vec4(coords) * new_scale;\n                    }\n                `;\n      break;\n    default:\n      // TODO:supporting other coordinateTransformModes\n      throw new Error(`resize (packed) does not support coordinateTransformMode: \\\n                                '${attributes.coordinateTransformMode}'`);\n  }\n\n  const coordsDataType = getCoordsDataType(dim);\n  const unpackChannel = unpackFromChannel();\n  const shaderSource = `\n            const vec2 inputWH = vec2(${inputHeight}.0, ${inputWidth}.0);\n            const vec4 scaleWHWH = vec4(float(${scalesHeight}), float(${scalesWidth}), float(${scalesHeight}), float(${\n              scalesWidth\n            }));\n            ${unpackChannel}\n            ${getSourceFracIndex}\n            float getAValue(int x10, int r, int c, int d) {\n                return getChannel(getA(x10, r, c, d), vec2(c, d));\n            }\n            void main() {\n                ${coordsDataType} rc = getOutputCoords();\n\n                int batch = rc[0];\n                int depth = rc[1];\n\n                // retrieve the 4 coordinates that is used in the 4 packed output values.\n                ivec4 coords = ivec4(rc.wz, rc.w + 1, rc.z + 1);\n\n                // calculate the source index in fraction\n                vec4 sourceFrac = getSourceFracIndex(coords);\n\n                // get the lower and upper bound of the 4 values that will be packed into one texel.\n                ivec4 x00 = ivec4(max(sourceFrac.xy, vec2(0.0)), min(inputWH - 1.0, ceil(sourceFrac.xy)));\n                ivec4 x01 = ivec4(max(sourceFrac.xw, vec2(0.0)), min(inputWH - 1.0, ceil(sourceFrac.xw)));\n                ivec4 x10 = ivec4(max(sourceFrac.zy, vec2(0.0)), min(inputWH - 1.0, ceil(sourceFrac.zy)));\n                ivec4 x11 = ivec4(max(sourceFrac.zw, vec2(0.0)), min(inputWH - 1.0, ceil(sourceFrac.zw)));\n\n                bool hasNextRow = rc.w < ${outputHeight - 1};\n                bool hasNextCol = rc.z < ${outputWidth - 1};\n\n                // pack x00, x01, x10, x11's top-left corner into one vec4 structure\n                vec4 topLeft = vec4(\n                    getAValue(batch, depth, x00.x, x00.y),\n                    hasNextCol ? getAValue(batch, depth, x01.x, x01.y) : 0.0,\n                    hasNextRow ? getAValue(batch, depth, x10.x, x10.y) : 0.0,\n                    (hasNextRow && hasNextCol) ? getAValue(batch, depth, x11.x, x11.y) : 0.0);\n\n                // pack x00, x01, x10, x11's top-right corner into one vec4 structure\n                vec4 topRight = vec4(\n                    getAValue(batch, depth, x00.x, x00.w),\n                    hasNextCol ? getAValue(batch, depth, x01.x, x01.w) : 0.0,\n                    hasNextRow ? getAValue(batch, depth, x10.x, x10.w) : 0.0,\n                    (hasNextRow && hasNextCol) ? getAValue(batch, depth, x11.x, x11.w) : 0.0);\n\n                // pack x00, x01, x10, x11's bottom-left corner into one vec4 structure\n                vec4 bottomLeft = vec4(\n                    getAValue(batch, depth, x00.z, x00.y),\n                    hasNextCol ? getAValue(batch, depth, x01.z, x01.y) : 0.0,\n                    hasNextRow ? getAValue(batch, depth, x10.z, x10.y) : 0.0,\n                    (hasNextRow && hasNextCol) ? getAValue(batch, depth, x11.z, x11.y) : 0.0);\n\n                // pack x00, x01, x10, x11's bottom-right corner into one vec4 structure\n                vec4 bottomRight = vec4(\n                    getAValue(batch, depth, x00.z, x00.w),\n                    hasNextCol ? getAValue(batch, depth, x01.z, x01.w) : 0.0,\n                    hasNextRow ? getAValue(batch, depth, x10.z, x10.w) : 0.0,\n                    (hasNextRow && hasNextCol) ? getAValue(batch, depth, x11.z, x11.w) : 0.0);\n\n                // calculate the interpolation fraction on u and v direction\n                vec4 frac = vec4(sourceFrac) - floor(sourceFrac);\n                vec4 clampFrac = clamp(frac, vec4(0.0), vec4(1.0));\n\n                vec4 top = mix(topLeft, topRight, clampFrac.ywyw);\n                vec4 bottom = mix(bottomLeft, bottomRight, clampFrac.ywyw);\n                vec4 newValue = mix(top, bottom, clampFrac.xxzz);\n\n                ${glsl.output} = vec4(newValue);\n            }\n        `;\n  return {\n    ...resizeProgramMetadata,\n    output: { dims: outputShape, type: inputs[0].type, textureType: TextureType.packed },\n    hasMain: true,\n    shaderSource,\n  };\n};\n\nconst prepareInputs = (inputs: Tensor[], attributes: UpsampleAttributes): [readonly number[], readonly number[]] => {\n  const x = inputs[0];\n  const xDims = x.dims;\n\n  let scales = attributes.scales;\n  let outputSizes: number[] | undefined;\n  if (scales.length === 0) {\n    const scalesTensor = inputs[attributes.scalesInputIdx];\n    if (scalesTensor && scalesTensor.size !== 0) {\n      if (inputs[attributes.sizesInputIdx]) {\n        throw new Error('Only one of scales or sizes must be provided as input.');\n      }\n      scales = parseScalesData(scalesTensor, attributes.mode, attributes.isResize);\n    } else {\n      const sizesTensor = inputs[attributes.sizesInputIdx];\n      if (!sizesTensor || sizesTensor.size === 0) {\n        throw new Error('Either scales or sizes MUST be provided as input.');\n      }\n\n      outputSizes = Array.from(sizesTensor.integerData);\n      scales = parseScalesDataFromOutputSize(outputSizes, xDims, attributes.mode, attributes.isResize);\n    }\n  } else {\n    if (inputs[attributes.sizesInputIdx]) {\n      throw new Error('Only one of scales or sizes must be provided as input.');\n    }\n  }\n\n  const yDims = outputSizes || xDims.map((dim, i) => Math.floor(dim * scales[i]));\n\n  return [scales, yDims];\n};\n\nconst parseScalesData = (scale: Tensor, mode: string, isResize: boolean): number[] => {\n  const scales = Array.from(scale.floatData);\n  scalesValidation(scales, mode, isResize);\n  return scales;\n};\n\nconst parseScalesDataFromOutputSize = (\n  yDims: readonly number[],\n  xDims: readonly number[],\n  mode: string,\n  isResize: boolean,\n): number[] => {\n  const length = xDims.length;\n  const scales = new Array<number>(length);\n\n  for (let i = 0, end = length; i < end; i++) {\n    if (xDims[i] === 0) {\n      if (yDims[i] !== 0) {\n        throw new Error('Input dim is zero but required output dim is non-zero.');\n      }\n      scales[i] = 1;\n    } else {\n      scales[i] = yDims[i] / xDims[i];\n    }\n  }\n  scalesValidation(scales, mode, isResize);\n  return scales;\n};\n\n// roi data is not used yet. but leave here for future usage.\n// const getRoi = (inputs: Tensor[], attributes: UpsampleAttributes) : number[] => {\n//     let roi: number[] = [];\n//     if (attributes.needRoiInput) {\n//         if (attributes.roiInputIdx <= 0) {\n//             throw new Error('Invalid roi input index.');\n//         }\n//         const roiTensor = inputs[attributes.roiInputIdx];\n//         roi = roiTensor.size > 0 ? Array.from(roiTensor.floatData) : [];\n//     } else {\n//         roi = new Array(inputs[0].dims.length * 2).fill(0);\n//     }\n//     return roi;\n// };\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Tensor } from '../../../tensor';\nimport { WebGLInferenceHandler } from '../inference-handler';\n\nexport const shape = (_inferenceHandler: WebGLInferenceHandler, inputs: Tensor[]): Tensor[] => {\n  validateInputs(inputs);\n  return [new Tensor([inputs[0].dims.length], 'int32', undefined, undefined, new Int32Array(inputs[0].dims))];\n};\n\nconst validateInputs = (inputs: Tensor[]): void => {\n  if (!inputs || inputs.length !== 1) {\n    throw new Error('Shape requires 1 input.');\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { AttributeWithCacheKey, createAttributeWithCacheKey } from '../../../attribute-with-cache-key';\nimport { Graph } from '../../../graph';\nimport { NUMBER_TYPES, OperatorImplementation, OperatorInitialization } from '../../../operators';\nimport { Tensor } from '../../../tensor';\nimport { ShapeUtil } from '../../../util';\nimport { WebGLInferenceHandler } from '../inference-handler';\nimport { ProgramInfo, TextureType } from '../types';\n\nexport interface SliceAttributes extends AttributeWithCacheKey {\n  readonly axes: number[];\n  readonly ends: number[];\n  readonly starts: number[];\n}\n\nconst sliceProgramMetadata = {\n  name: 'Slice',\n  inputNames: ['A'],\n  inputTypes: [TextureType.unpacked],\n};\n\nexport const slice: OperatorImplementation<SliceAttributes> = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  attributes: SliceAttributes,\n): Tensor[] => {\n  validateInputs(inputs);\n  const output = inferenceHandler.run(\n    {\n      ...sliceProgramMetadata,\n      cacheHint: attributes.cacheKey,\n      get: () => createSliceProgramInfo(inferenceHandler, inputs[0], attributes),\n    },\n    inputs,\n  );\n  return [output];\n};\n\nexport const parseSliceAttributes: OperatorInitialization<SliceAttributes> = (node: Graph.Node): SliceAttributes => {\n  const starts = node.attributes.getInts('starts');\n  const ends = node.attributes.getInts('ends');\n  const axes = node.attributes.getInts('axes', []);\n  return createAttributeWithCacheKey({ starts, ends, axes });\n};\n\nconst createSliceProgramInfo = (\n  _inferenceHandler: WebGLInferenceHandler,\n  input: Tensor,\n  attributes: SliceAttributes,\n): ProgramInfo => {\n  const axes = attributes.axes.length === 0 ? input.dims.slice(0).map((_val, i) => i) : attributes.axes;\n  const normalizedAxes = ShapeUtil.normalizeAxes(axes, input.dims.length);\n  const starts = attributes.starts.map((start, i) => {\n    if (start > input.dims[normalizedAxes[i]] - 1) {\n      return input.dims[normalizedAxes[i]];\n    }\n    return ShapeUtil.normalizeAxis(start, input.dims[normalizedAxes[i]]);\n  });\n  const ends = attributes.ends.map((end, i) => {\n    if (end > input.dims[normalizedAxes[i]] - 1) {\n      return input.dims[normalizedAxes[i]];\n    }\n    return ShapeUtil.normalizeAxis(end, input.dims[normalizedAxes[i]]);\n  });\n\n  const outputShape = input.dims.slice();\n\n  const sliceOps: string[] = [];\n  for (let i = 0; i < normalizedAxes.length; i++) {\n    outputShape[normalizedAxes[i]] = ends[i] - starts[i];\n    if (starts[i] > 0) {\n      sliceOps.push(`outputIdx[${normalizedAxes[i]}] += ${starts[i]};`);\n    } // else { sliceOps.push(`outputIdx[${normalizedAxes[i]}] += 0;`); }\n  }\n\n  const rank = outputShape.length;\n  const shaderSource = `\n      float process(int outputIdx[${rank}]) {\n        ${sliceOps.join('\\n      ')}\n        return _A(outputIdx);\n      }`;\n  return {\n    ...sliceProgramMetadata,\n    output: { dims: outputShape, type: input.type, textureType: TextureType.unpacked },\n    shaderSource,\n  };\n};\n\nconst validateInputs = (inputs: Tensor[]): void => {\n  if (!inputs || inputs.length !== 1) {\n    throw new Error('Slice requires 1 input.');\n  }\n  if (NUMBER_TYPES.indexOf(inputs[0].type) === -1) {\n    throw new Error('Invalid input type.');\n  }\n};\n\nexport const sliceV10 = (inferenceHandler: WebGLInferenceHandler, inputs: Tensor[]): Tensor[] => {\n  validateInputsV10(inputs);\n  const attributes = generateSliceAttributesFromInputs(inferenceHandler, inputs);\n  const output = inferenceHandler.run(\n    {\n      ...sliceProgramMetadata,\n      cacheHint: attributes.cacheKey,\n      get: () => createSliceProgramInfo(inferenceHandler, inputs[0], attributes),\n    },\n    [inputs[0]],\n  );\n  return [output];\n};\n\nconst generateSliceAttributesFromInputs = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n): SliceAttributes => {\n  if (\n    !inferenceHandler.session.isInitializer(inputs[1].dataId) ||\n    !inferenceHandler.session.isInitializer(inputs[2].dataId) ||\n    (inputs.length >= 4 && !inferenceHandler.session.isInitializer(inputs[3].dataId)) ||\n    (inputs.length >= 5 && !inferenceHandler.session.isInitializer(inputs[4].dataId))\n  ) {\n    throw new Error('dynamic slice attributes are not allowed');\n  }\n\n  if (inputs.length >= 5 && inputs[4].integerData.some((i: number) => i !== 1)) {\n    throw new Error('currently non-1 steps is not supported for Slice');\n  }\n\n  const starts = Array.from(inputs[1].integerData);\n  const ends = Array.from(inputs[2].integerData);\n  const axes = inputs.length >= 4 ? Array.from(inputs[3].integerData) : [];\n  const cacheKey = `${axes};${starts};${ends}`;\n  return { starts, ends, axes, cacheKey };\n};\n\nconst validateInputsV10 = (inputs: Tensor[]): void => {\n  if (!inputs || inputs.length < 3 || inputs.length > 5) {\n    throw new Error('Invalid input number.');\n  }\n  if (inputs[1].type !== 'int32' || inputs[1].dims.length !== 1) {\n    throw new Error('Invalid input type.');\n  }\n  if (inputs[2].type !== 'int32' || inputs[2].dims.length !== 1) {\n    throw new Error('Invalid input type.');\n  }\n  if (inputs.length >= 4 && (inputs[3].type !== 'int32' || inputs[3].dims.length !== 1)) {\n    throw new Error('Invalid input type.');\n  }\n  if (inputs.length >= 5 && (inputs[4].type !== 'int32' || inputs[4].dims.length !== 1)) {\n    throw new Error('Invalid input type.');\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { AttributeWithCacheKey, createAttributeWithCacheKey } from '../../../attribute-with-cache-key';\nimport { Graph } from '../../../graph';\nimport { OperatorImplementation, OperatorInitialization } from '../../../operators';\nimport { Tensor } from '../../../tensor';\nimport { ShapeUtil } from '../../../util';\nimport { getGlsl } from '../glsl-source';\nimport { WebGLInferenceHandler } from '../inference-handler';\nimport { ProgramInfo, TextureType } from '../types';\n\nimport { transpose, TransposeAttributes } from './transpose';\n\nexport interface SoftmaxAttributes extends AttributeWithCacheKey {\n  readonly axis: number;\n}\n\nconst softmaxComputeMaxProgramMetadata = {\n  name: 'SoftmaxComputeMax',\n  inputNames: ['A'],\n  inputTypes: [TextureType.unpacked],\n};\n\nconst softmaxComputeScaleProgramMetadata = {\n  name: 'SoftmaxComputeScale',\n  inputNames: ['A', 'Max'],\n  inputTypes: [TextureType.unpacked, TextureType.unpacked],\n};\n\nconst softmaxProgramMetadata = {\n  name: 'SoftMax',\n  inputNames: ['A', 'Max', 'Norm'],\n  inputTypes: [TextureType.unpacked, TextureType.unpacked, TextureType.unpacked],\n};\n\nexport const softmax: OperatorImplementation<SoftmaxAttributes> = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  attributes: SoftmaxAttributes,\n): Tensor[] => {\n  validateInputs(inputs);\n\n  const inputShape = inputs[0].dims.slice();\n  const axis = ShapeUtil.normalizeAxis(attributes.axis, inputShape.length);\n  const logicalRowCount = ShapeUtil.sizeToDimension(inputShape, axis);\n  const featureCount = ShapeUtil.sizeFromDimension(inputShape, axis);\n\n  const output = computeSoftmax(inferenceHandler, inputs, attributes, logicalRowCount, featureCount);\n  return output;\n};\n\nexport const parseSoftmaxAttributes: OperatorInitialization<SoftmaxAttributes> = (\n  node: Graph.Node,\n): SoftmaxAttributes => createAttributeWithCacheKey({ axis: node.attributes.getInt('axis', 1) });\n\nexport const parseSoftmaxAttributesV13: OperatorInitialization<SoftmaxAttributes> = (\n  node: Graph.Node,\n): SoftmaxAttributes => createAttributeWithCacheKey({ axis: node.attributes.getInt('axis', -1) });\n\n// The \"semantic\" meaning of axis has changed in opset-13.\n// Please compare: https://github.com/onnx/onnx/blob/main/docs/Operators.md#Softmax\n// with https://github.com/onnx/onnx/blob/main/docs/Changelog.md#Softmax-11 for detailed explanations\n// To account for the opset-13 behavior, our plan will be to transpose the \"axis\" dim to the innermost dim\n// and perform softmax and then reverse the transpose. We can skip the transposing aspect if the axis is already\n// the innermost dim\nexport const softmaxV13: OperatorImplementation<SoftmaxAttributes> = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  attributes: SoftmaxAttributes,\n): Tensor[] => {\n  validateInputs(inputs);\n\n  const inputShape = inputs[0].dims.slice();\n  const axis = ShapeUtil.normalizeAxis(attributes.axis, inputShape.length);\n  const rank = inputShape.length;\n\n  const isTransposeRequired = axis !== rank - 1 ? true : false;\n  const transposedInputShape: number[] = [];\n  let perm: number[] = [];\n  let transposedInputs: Tensor[] = [];\n  let transposeAttribute: TransposeAttributes;\n\n  if (isTransposeRequired) {\n    perm = Array.from({ length: rank }).map((_, i) => i);\n\n    // swap the innermost dim with the dim corresponding to axis\n    perm[axis] = rank - 1;\n    perm[rank - 1] = axis;\n\n    perm.map((p) => transposedInputShape.push(inputShape[p]));\n\n    transposeAttribute = createAttributeWithCacheKey({ perm });\n    transposedInputs = transpose(inferenceHandler, inputs, transposeAttribute);\n  }\n\n  const logicalRowCount = isTransposeRequired\n    ? ShapeUtil.sizeToDimension(transposedInputShape, rank - 1)\n    : ShapeUtil.sizeToDimension(inputShape, rank - 1);\n  const featureCount = isTransposeRequired\n    ? ShapeUtil.sizeFromDimension(transposedInputShape, rank - 1)\n    : ShapeUtil.sizeFromDimension(inputShape, rank - 1);\n\n  const output = computeSoftmax(\n    inferenceHandler,\n    isTransposeRequired ? transposedInputs : inputs,\n    attributes,\n    logicalRowCount,\n    featureCount,\n  );\n\n  if (isTransposeRequired) {\n    const reversedOutput = transpose(inferenceHandler, output, transposeAttribute!);\n    return reversedOutput;\n  } else {\n    return output;\n  }\n};\n\nconst computeSoftmax = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  attributes: SoftmaxAttributes,\n  logicalRowCount: number,\n  featureCount: number,\n): Tensor[] => {\n  const computeMaxProgramInfo = createComputeMaxProgramInfo(\n    inferenceHandler,\n    inputs[0],\n    logicalRowCount,\n    featureCount,\n    [logicalRowCount],\n  );\n  const max = inferenceHandler.run(\n    { ...softmaxComputeMaxProgramMetadata, cacheHint: attributes.cacheKey, get: () => computeMaxProgramInfo },\n    inputs,\n  );\n\n  const computeScaleProgramInfo = createComputScaleProgramInfo(\n    inferenceHandler,\n    inputs[0],\n    logicalRowCount,\n    featureCount,\n    computeMaxProgramInfo.output.dims,\n    [logicalRowCount],\n  );\n  const scale = inferenceHandler.run(\n    { ...softmaxComputeScaleProgramMetadata, cacheHint: attributes.cacheKey, get: () => computeScaleProgramInfo },\n    [inputs[0], max],\n  );\n\n  const softMaxProgramInfo = createSoftMaxProgramInfo(\n    inferenceHandler,\n    inputs[0],\n    logicalRowCount,\n    featureCount,\n    computeMaxProgramInfo.output.dims,\n    computeScaleProgramInfo.output.dims,\n  );\n  const output = inferenceHandler.run(\n    { ...softmaxProgramMetadata, cacheHint: attributes.cacheKey, get: () => softMaxProgramInfo },\n    [inputs[0], max, scale],\n  );\n  return [output];\n};\n\n/**\n * Create a texture that contains the maximum value of each of the 'N' rows\n */\nconst createComputeMaxProgramInfo = (\n  inferenceHandler: WebGLInferenceHandler,\n  input: Tensor,\n  logicalRowCount: number,\n  featureCount: number,\n  outputShape: number[],\n): ProgramInfo => {\n  const [textureWidth, textureHeight] = inferenceHandler.calculateTextureWidthAndHeight(\n    input.dims,\n    TextureType.unpacked,\n  );\n  const rank = outputShape.length;\n\n  if (logicalRowCount < 1 || featureCount < 1) {\n    throw new Error('Logical row count N and feature count D must be greater than or equal to 1');\n  }\n\n  if (outputShape.length !== 1) {\n    throw new Error('Dimensionality of the output should be 1');\n  }\n\n  if (outputShape[0] !== logicalRowCount) {\n    throw new Error('Shape of the output should be equal to logical row count');\n  }\n\n  const glsl = getGlsl(inferenceHandler.session.backend.glContext.version);\n  const shaderSource = `\n      float process(int[${rank}] indices) {\n        int logical_row_start_offset = indices[0] * ${featureCount};\n\n        float max = getColorAsFloat(${glsl.texture2D}(A, offsetToCoords(logical_row_start_offset, ${textureWidth},\n        ${textureHeight} )));\n        for(int i=1; i<${featureCount}; ++i)\n        {\n          float current = getColorAsFloat(${glsl.texture2D}(A, offsetToCoords(logical_row_start_offset + i,\n            ${textureWidth}, ${textureHeight})));\n          if(current > max)\n          max = current;\n        }\n\n        return max;\n      }`;\n  return {\n    ...softmaxComputeMaxProgramMetadata,\n    output: { dims: outputShape, type: input.type, textureType: TextureType.unpacked },\n    shaderSource,\n  };\n};\n\n/**\n * Create a texture that contains the normalization factor for each of the 'N' rows\n */\nconst createComputScaleProgramInfo = (\n  inferenceHandler: WebGLInferenceHandler,\n  input: Tensor,\n  logicalRowCount: number,\n  featureCount: number,\n  maxElementPerLogicalRow: readonly number[],\n  outputShape: number[],\n): ProgramInfo => {\n  const [textureWidth, textureHeight] = inferenceHandler.calculateTextureWidthAndHeight(\n    input.dims,\n    TextureType.unpacked,\n  );\n  const rank = outputShape.length;\n\n  if (logicalRowCount < 1 || featureCount < 1) {\n    throw new Error('Logical row count N and feature count D must be greater than or equal to 1');\n  }\n\n  if (outputShape.length !== 1) {\n    throw new Error('Dimensionality of the output should be 1');\n  }\n\n  if (outputShape[0] !== logicalRowCount) {\n    throw new Error('Shape of the output should be equal to logical row count');\n  }\n\n  if (maxElementPerLogicalRow.length !== 1) {\n    throw new Error('Dimensionality of the intermediate results should be 1');\n  }\n\n  if (maxElementPerLogicalRow[0] !== logicalRowCount) {\n    throw new Error('Shape of the intermediate results should be equal to logical row count');\n  }\n\n  const glsl = getGlsl(inferenceHandler.session.backend.glContext.version);\n  const shaderSource = `\n      float process(int[${rank}] indices) {\n        int logical_row_start_offset = indices[0] * ${featureCount};\n\n        float norm_factor = 0.0;\n        float max = _Max(indices);\n        for(int i=0; i<${featureCount}; ++i)\n        {\n          norm_factor += exp(getColorAsFloat(${glsl.texture2D}(A, offsetToCoords(logical_row_start_offset + i,\n            ${textureWidth}, ${textureHeight}))) - max);\n        }\n\n        return norm_factor;\n      }`;\n  return {\n    ...softmaxComputeScaleProgramMetadata,\n    output: { dims: outputShape, type: input.type, textureType: TextureType.unpacked },\n    shaderSource,\n  };\n};\n\nconst createSoftMaxProgramInfo = (\n  inferenceHandler: WebGLInferenceHandler,\n  input: Tensor,\n  logicalRowCount: number,\n  featureCount: number,\n  maxElementPerLogicalRow: readonly number[],\n  normalizationPerLogicalRow: readonly number[],\n): ProgramInfo => {\n  const [textureWidth, textureHeight] = inferenceHandler.calculateTextureWidthAndHeight(\n    input.dims,\n    TextureType.unpacked,\n  );\n  const rank = input.dims.length;\n\n  if (logicalRowCount < 1 || featureCount < 1) {\n    throw new Error('Logical row count N and feature count D must be greater than or equal to 1');\n  }\n\n  if (maxElementPerLogicalRow.length !== 1 || normalizationPerLogicalRow.length !== 1) {\n    throw new Error('Dimensionality of the intermediate results should be 1');\n  }\n\n  if (maxElementPerLogicalRow[0] !== logicalRowCount || normalizationPerLogicalRow[0] !== logicalRowCount) {\n    throw new Error('Shape of the intermediate results should be equal to logical row count');\n  }\n\n  const shaderSource = `\n      float process(int[${rank}] indices) {\n\n      // get offset of current logical tensor index from the 2-D texture coordinates (TexCoords)\n      int offset = coordsToOffset(TexCoords, ${textureWidth}, ${textureHeight});\n\n      //determine the logical row for this index\n      int logical_row_index[1];\n      logical_row_index[0] = offset / ${featureCount};\n\n      float norm_factor = _Norm(logical_row_index);\n\n      // avoid possible division by 0\n      // if norm_facor is 0, all elements are zero\n      // if so, return 0\n      if(norm_factor == 0.0)\n        return 0.0;\n\n      return exp(_A(indices) - _Max(logical_row_index)) / norm_factor;\n    }`;\n  return {\n    ...softmaxProgramMetadata,\n    output: { dims: input.dims, type: input.type, textureType: TextureType.unpacked },\n    shaderSource,\n  };\n};\n\nconst validateInputs = (inputs: Tensor[]): void => {\n  if (!inputs || inputs.length !== 1) {\n    throw new Error('Softmax requires 1 input.');\n  }\n\n  if (inputs[0].type !== 'float32' && inputs[0].type !== 'float64') {\n    throw new Error('Invalid input type');\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { AttributeWithCacheKey, createAttributeWithCacheKey } from '../../../attribute-with-cache-key';\nimport { Graph } from '../../../graph';\nimport { OperatorImplementation, OperatorInitialization } from '../../../operators';\nimport { Tensor } from '../../../tensor';\nimport { ShapeUtil, SplitUtil } from '../../../util';\nimport { WebGLInferenceHandler } from '../inference-handler';\nimport { ProgramInfo, TextureType } from '../types';\n\nexport interface SplitAttributes extends AttributeWithCacheKey {\n  readonly axis: number;\n  readonly split: number[];\n  readonly numOutputs: number;\n}\n\nconst splitProgramMetadata = {\n  name: 'Split',\n  inputNames: ['A'],\n  inputTypes: [TextureType.unpacked],\n};\n\nexport const split: OperatorImplementation<SplitAttributes> = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  attributes: SplitAttributes,\n): Tensor[] => {\n  validateInputs(inputs);\n\n  const axis = ShapeUtil.normalizeAxis(attributes.axis, inputs[0].dims.length);\n  const count = getProgramCount(inferenceHandler, inputs, axis, attributes);\n  const output: Tensor[] = [];\n  for (let i = 0; i < count; ++i) {\n    output.push(\n      inferenceHandler.run(\n        {\n          ...splitProgramMetadata,\n          cacheHint: `${attributes.cacheKey};${i}`,\n          get: () => createSplitProgramInfo(inferenceHandler, inputs[0], attributes, axis, i),\n        },\n        inputs,\n      ),\n    );\n  }\n\n  return output;\n};\n\nexport const parseSplitAttributes: OperatorInitialization<SplitAttributes> = (node: Graph.Node): SplitAttributes => {\n  const axis = node.attributes.getInt('axis', 0);\n  const split = node.attributes.getInts('split', []);\n  const numOutputs = node.outputs.length;\n  return createAttributeWithCacheKey({ axis, split, numOutputs });\n};\n\nconst getProgramCount = (\n  _inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  axis: number,\n  attributes: SplitAttributes,\n): number => {\n  const [, offsets] = SplitUtil.splitShape(inputs[0].dims, axis, attributes.split, attributes.numOutputs);\n  return offsets.length;\n};\n\nconst createSplitProgramInfo = (\n  _inferenceHandler: WebGLInferenceHandler,\n  input: Tensor,\n  attributes: SplitAttributes,\n  axis: number,\n  index: number,\n): ProgramInfo => {\n  const [shapes, offsets] = SplitUtil.splitShape(input.dims, axis, attributes.split, attributes.numOutputs);\n  const offset = offsets[index];\n  const outputShape = shapes[index];\n  const rank = outputShape.length;\n  const shaderSource = `\n      float process(int indices[${rank}]) {\n        indices[${axis}] += ${offset};\n        return _A(indices);\n      }\n    `;\n  return {\n    ...splitProgramMetadata,\n    cacheHint: `${attributes.cacheKey}:${index}`,\n    output: { dims: outputShape, type: input.type, textureType: TextureType.unpacked },\n    shaderSource,\n  };\n};\n\nconst validateInputs = (inputs: Tensor[]): void => {\n  if (!inputs || inputs.length !== 1) {\n    throw new Error('Split requires one input.');\n  }\n\n  if (\n    inputs[0].type !== 'int8' &&\n    inputs[0].type !== 'uint8' &&\n    inputs[0].type !== 'int16' &&\n    inputs[0].type !== 'uint16' &&\n    inputs[0].type !== 'int32' &&\n    inputs[0].type !== 'uint32' &&\n    inputs[0].type !== 'float32' &&\n    inputs[0].type !== 'float64' &&\n    inputs[0].type !== 'bool'\n  ) {\n    throw new Error('Invalid input type.');\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Graph } from '../../../graph';\nimport { OperatorImplementation, OperatorInitialization } from '../../../operators';\nimport { Tensor } from '../../../tensor';\nimport { ShapeUtil } from '../../../util';\nimport { WebGLInferenceHandler } from '../inference-handler';\n\nexport const squeeze: OperatorImplementation<number[]> = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  axes: number[],\n): Tensor[] => {\n  validateInputs(inputs);\n  const outputShape = ShapeUtil.squeezeShape(inputs[0].dims, axes);\n  const output = inferenceHandler.reshapeUnpacked(inputs[0], outputShape);\n  return [output];\n};\n\nexport const squeezeV13 = (inferenceHandler: WebGLInferenceHandler, inputs: Tensor[]): Tensor[] => {\n  validateInputsV13(inputs);\n  return squeeze(inferenceHandler, [inputs[0]], Array.from(inputs[1].integerData));\n};\n\nexport const parseSqueezeAttributes: OperatorInitialization<number[]> = (node: Graph.Node): number[] =>\n  node.attributes.getInts('axes');\n\nconst validateInputs = (inputs: Tensor[]): void => {\n  if (!inputs || inputs.length !== 1) {\n    throw new Error('Squeeze requires 1 input.');\n  }\n\n  if (inputs[0].type === 'string') {\n    throw new Error('invalid input tensor types.');\n  }\n};\n\nconst validateInputsV13 = (inputs: Tensor[]): void => {\n  if (!inputs || inputs.length !== 2) {\n    throw new Error('Squeeze requires 2 inputs.');\n  }\n\n  if (inputs[1].type !== 'int32') {\n    throw new Error('Invalid input type.');\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Tensor } from '../../../tensor';\nimport { getGlsl } from '../glsl-source';\nimport { WebGLInferenceHandler } from '../inference-handler';\nimport { ProgramInfo, ProgramMetadata, TextureType } from '../types';\n\nexport const sum = (inferenceHandler: WebGLInferenceHandler, inputs: Tensor[]): Tensor[] => {\n  validateInputs(inputs);\n\n  const sumProgramMetadata = {\n    name: 'Sum',\n    inputNames: inputs.map((_v, i) => `X${i}`),\n    inputTypes: new Array(inputs.length).fill(TextureType.unpacked),\n  };\n\n  const output = inferenceHandler.run(\n    { ...sumProgramMetadata, get: () => createSumProgramInfo(inferenceHandler, inputs, sumProgramMetadata) },\n    inputs,\n  );\n  return [output];\n};\n\nconst createSumProgramInfo = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  sumProgramMetadata: ProgramMetadata,\n): ProgramInfo => {\n  const glsl = getGlsl(inferenceHandler.session.backend.glContext.version);\n  const outputShape = inputs[0].dims.slice();\n  const sumLine = inputs.map((_v, i) => `${glsl.texture2D}(X${i},TexCoords)`).join(' + ');\n  const shaderSource = `\n      void main() {\n        vec4 result = ${sumLine};\n        ${glsl.output} = result;\n      }\n    `;\n  return {\n    ...sumProgramMetadata,\n    output: { dims: outputShape, type: inputs[0].type, textureType: TextureType.unpacked },\n    hasMain: true,\n    shaderSource,\n  };\n};\n\nconst validateInputs = (inputs: Tensor[]): void => {\n  if (!inputs || inputs.length === 0) {\n    throw new Error('Sum requires inputs.');\n  }\n\n  const length = inputs[0].dims.length;\n  for (let i = 1; i < inputs.length; i++) {\n    if (length !== inputs[i].dims.length) {\n      throw new Error('Input shapes are mismatched.');\n    }\n\n    for (let j = 0; j < length; j++) {\n      if (inputs[0].dims[j] !== inputs[i].dims[j]) {\n        throw new Error('Input shapes are not matched.');\n      }\n    }\n  }\n\n  if (inputs[0].type !== 'float32' && inputs[0].type !== 'float64') {\n    throw new Error('Invalid input type.');\n  }\n  for (let i = 1; i < inputs.length; i++) {\n    if (inputs[0].type !== inputs[i].type) {\n      throw new Error('Input types are not matched.');\n    }\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { NUMBER_TYPES } from '../../../operators';\nimport { Tensor } from '../../../tensor';\nimport { WebGLInferenceHandler } from '../inference-handler';\nimport { ProgramInfo, ProgramMetadata, TextureType } from '../types';\n\nexport const tile = (inferenceHandler: WebGLInferenceHandler, inputs: Tensor[]): Tensor[] => {\n  validateInputs(inputs);\n\n  const tileProgramMetadata = {\n    name: 'Tile',\n    inputNames: ['A'],\n    inputTypes: [TextureType.unpacked],\n  };\n\n  const output = inferenceHandler.run(\n    { ...tileProgramMetadata, get: () => createTileProgramInfo(inferenceHandler, inputs, tileProgramMetadata) },\n    inputs,\n  );\n  return [output];\n};\n\nconst createTileProgramInfo = (\n  _handler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  tileProgramMetadata: ProgramMetadata,\n): ProgramInfo => {\n  const inputShape = inputs[0].dims.slice();\n  const outputShape = new Array(inputShape.length);\n\n  const tileOps: string[] = [];\n  for (let i = 0; i < inputShape.length; i++) {\n    outputShape[i] = inputShape[i] * inputs[1].numberData[i];\n    tileOps.push(`inputIdx[${i}] = int(mod(float(outputIdx[${i}]), ${inputShape[i]}.));`);\n  }\n\n  const rank = outputShape.length;\n  const shaderSource = `\n      float process(int outputIdx[${rank}]) {\n        int inputIdx[${rank}];\n        ${tileOps.join('\\n')}\n        return _A(inputIdx);\n      }\n    `;\n  return {\n    ...tileProgramMetadata,\n    output: { dims: outputShape, type: inputs[0].type, textureType: TextureType.unpacked },\n    shaderSource,\n  };\n};\n\nconst validateInputs = (inputs: Tensor[]): void => {\n  if (!inputs || inputs.length !== 2) {\n    throw new Error('Tile requires 2 input.');\n  }\n  if (inputs[1].dims.length !== 1) {\n    throw new Error('The second input shape must 1 dimension.');\n  }\n  if (inputs[1].dims[0] !== inputs[0].dims.length) {\n    throw new Error('Invalid input shape.');\n  }\n  if (NUMBER_TYPES.indexOf(inputs[0].type) === -1) {\n    throw new Error('Invalid input type.');\n  }\n  if (inputs[1].type !== 'int32' && inputs[1].type !== 'int16') {\n    throw new Error('Invalid repeat type.');\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Graph } from '../../../graph';\nimport { OperatorImplementation, OperatorInitialization } from '../../../operators';\nimport { Tensor } from '../../../tensor';\nimport { ShapeUtil } from '../../../util';\nimport { WebGLInferenceHandler } from '../inference-handler';\n\nexport const unsqueeze: OperatorImplementation<number[]> = (\n  inferenceHandler: WebGLInferenceHandler,\n  inputs: Tensor[],\n  axes: number[],\n): Tensor[] => {\n  validateInputs(inputs);\n  const outputShape = ShapeUtil.unsqueezeShape(inputs[0].dims, axes);\n  const output = inferenceHandler.reshapeUnpacked(inputs[0], outputShape);\n  return [output];\n};\n\nexport const unsqueezeV13 = (inferenceHandler: WebGLInferenceHandler, inputs: Tensor[]): Tensor[] => {\n  validateInputsV13(inputs);\n  return unsqueeze(inferenceHandler, [inputs[0]], Array.from(inputs[1].integerData));\n};\n\nexport const parseUnsqueezeAttributes: OperatorInitialization<number[]> = (node: Graph.Node): number[] =>\n  node.attributes.getInts('axes');\n\nconst validateInputs = (inputs: Tensor[]): void => {\n  if (!inputs || inputs.length !== 1) {\n    throw new Error('Unsqueeze requires 1 input.');\n  }\n\n  if (inputs[0].type === 'string') {\n    throw new Error('invalid input tensor types.');\n  }\n};\n\nconst validateInputsV13 = (inputs: Tensor[]): void => {\n  if (!inputs || inputs.length !== 2) {\n    throw new Error('Unsqueeze requires 2 inputs.');\n  }\n\n  if (inputs[1].type !== 'int32') {\n    throw new Error('Invalid input type.');\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { OpSet } from '../../opset';\n\nimport { batchNormalization, parseBatchNormalizationAttributes } from './ops/batch-normalization';\nimport * as binaryOps from './ops/binary-op';\nimport { cast, parseCastAttributes } from './ops/cast';\nimport { concat, parseConcatAttributes } from './ops/concat';\nimport { conv, parseConvAttributes } from './ops/conv';\nimport { convTranspose, parseConvTransposeAttributes } from './ops/conv-transpose';\nimport { depthToSpace, parseDepthToSpaceAttributes } from './ops/depth-to-space';\nimport { flatten, parseFlattenAttributes } from './ops/flatten';\nimport { gather, parseGatherAttributes } from './ops/gather';\nimport { gemm, parseGemmAttributesV11, parseGemmAttributesV7 } from './ops/gemm';\nimport { imageScaler, parseImageScalerAttributes } from './ops/image-scaler';\nimport { instanceNormalization, parseInstanceNormalizationAttributes } from './ops/instance-normalization';\nimport { lrn, parseLrnAttributes } from './ops/lrn';\nimport { matMul, parseMatMulAttributes } from './ops/matmul';\nimport { padV11, padV2, parsePadAttributesV11, parsePadAttributesV2 } from './ops/pad';\nimport {\n  averagePool,\n  globalAveragePool,\n  globalMaxPool,\n  maxPool,\n  parseAveragePoolAttributes,\n  parseGlobalAveragePoolAttributes,\n  parseMaxPoolAttributes,\n} from './ops/pool';\nimport {\n  parseReduceAttributes,\n  reduceLogSum,\n  reduceLogSumSquare,\n  reduceMax,\n  reduceMean,\n  reduceMin,\n  reduceProd,\n  reduceSum,\n} from './ops/reduce';\nimport { reshape } from './ops/reshape';\nimport { parseResizeAttributesV10, parseResizeAttributesV11, resize } from './ops/resize-packed';\nimport { shape } from './ops/shape';\nimport { parseSliceAttributes, slice, sliceV10 } from './ops/slice';\nimport { parseSoftmaxAttributes, parseSoftmaxAttributesV13, softmax, softmaxV13 } from './ops/softmax';\nimport { parseSplitAttributes, split } from './ops/split';\nimport { parseSqueezeAttributes, squeeze, squeezeV13 } from './ops/squeeze';\nimport { sum } from './ops/sum';\nimport { tile } from './ops/tile';\nimport { parseTransposeAttributes, transpose } from './ops/transpose';\nimport * as unaryOps from './ops/unary-op';\nimport { parseUnsqueezeAttributes, unsqueeze, unsqueezeV13 } from './ops/unsqueeze';\nimport { parseUpsampleAttributesV7, parseUpsampleAttributesV9, upsample } from './ops/upsample';\n\nexport const WEBGL_OP_RESOLVE_RULES: readonly OpSet.ResolveRule[] = [\n  ['Abs', '', '6+', unaryOps.abs],\n  ['Acos', '', '7+', unaryOps.acos],\n  ['Add', '', '7+', binaryOps.add],\n  ['And', '', '7+', binaryOps.and],\n  ['Asin', '', '7+', unaryOps.asin],\n  ['Atan', '', '7+', unaryOps.atan],\n  // TODO: support new attributes for AveragePool-10\n  ['AveragePool', '', '7+', averagePool, parseAveragePoolAttributes],\n  ['BatchNormalization', '', '7+', batchNormalization, parseBatchNormalizationAttributes],\n  ['Cast', '', '6+', cast, parseCastAttributes],\n  ['Ceil', '', '6+', unaryOps.ceil],\n  ['Clip', '', '6-10', unaryOps.clip, unaryOps.parseClipAttributes],\n  ['Clip', '', '11+', unaryOps.clipV11],\n  ['Concat', '', '4+', concat, parseConcatAttributes],\n  ['Conv', '', '1+', conv, parseConvAttributes],\n  ['ConvTranspose', '', '1+', convTranspose, parseConvTransposeAttributes],\n  ['Cos', '', '7+', unaryOps.cos],\n  ['Div', '', '7+', binaryOps.div],\n  ['Dropout', '', '7+', unaryOps.identity],\n  ['DepthToSpace', '', '1+', depthToSpace, parseDepthToSpaceAttributes],\n  ['Equal', '', '7+', binaryOps.equal],\n  ['Elu', '', '6+', unaryOps.elu, unaryOps.parseEluAttributes],\n  ['Exp', '', '6+', unaryOps.exp],\n  ['Flatten', '', '1+', flatten, parseFlattenAttributes],\n  ['Floor', '', '6+', unaryOps.floor],\n  ['FusedConv', 'com.microsoft', '1+', conv, parseConvAttributes],\n  ['Gather', '', '1+', gather, parseGatherAttributes],\n  ['Gemm', '', '7-10', gemm, parseGemmAttributesV7],\n  ['Gemm', '', '11+', gemm, parseGemmAttributesV11],\n  ['GlobalAveragePool', '', '1+', globalAveragePool, parseGlobalAveragePoolAttributes],\n  ['GlobalMaxPool', '', '1+', globalMaxPool],\n  ['Greater', '', '7+', binaryOps.greater],\n  ['Identity', '', '1+', unaryOps.identity],\n  ['ImageScaler', '', '1+', imageScaler, parseImageScalerAttributes],\n  ['InstanceNormalization', '', '6+', instanceNormalization, parseInstanceNormalizationAttributes],\n  ['LeakyRelu', '', '6+', unaryOps.leakyRelu, unaryOps.parseLeakyReluAttributes],\n  ['Less', '', '7+', binaryOps.less],\n  ['LRN', '', '1+', lrn, parseLrnAttributes],\n  ['Log', '', '6+', unaryOps.log],\n  ['MatMul', '', '1+', matMul, parseMatMulAttributes],\n  // TODO: support new attributes for MaxPool-8 and MaxPool-10\n  ['MaxPool', '', '1+', maxPool, parseMaxPoolAttributes],\n  ['Mul', '', '7+', binaryOps.mul],\n  ['Neg', '', '6+', unaryOps.neg],\n  ['Not', '', '1+', unaryOps.not],\n  ['Or', '', '7+', binaryOps.or],\n  ['Pad', '', '2-10', padV2, parsePadAttributesV2],\n  ['Pad', '', '11+', padV11, parsePadAttributesV11],\n  ['Pow', '', '7+', binaryOps.pow],\n  ['PRelu', '', '7+', binaryOps.pRelu],\n  ['ReduceLogSum', '', '1+', reduceLogSum, parseReduceAttributes],\n  ['ReduceMax', '', '1+', reduceMax, parseReduceAttributes],\n  ['ReduceMean', '', '1+', reduceMean, parseReduceAttributes],\n  ['ReduceMin', '', '1+', reduceMin, parseReduceAttributes],\n  ['ReduceProd', '', '1+', reduceProd, parseReduceAttributes],\n  ['ReduceSum', '', '1-12', reduceSum, parseReduceAttributes],\n  ['ReduceSumSquare', '', '1+', reduceLogSumSquare, parseReduceAttributes],\n  ['Relu', '', '6+', unaryOps.relu],\n  ['Reshape', '', '5+', reshape],\n  ['Resize', '', '10', resize, parseResizeAttributesV10],\n  ['Resize', '', '11+', resize, parseResizeAttributesV11],\n  ['Shape', '', '1+', shape],\n  ['Sigmoid', '', '6+', unaryOps.sigmoid],\n  ['Sin', '', '7+', unaryOps.sin],\n  ['Slice', '', '10+', sliceV10], // TODO: support 'steps' for Slice-10\n  ['Slice', '', '1-9', slice, parseSliceAttributes],\n  // The \"semantic\" meaning of axis has changed in opset-13.\n  ['Softmax', '', '1-12', softmax, parseSoftmaxAttributes],\n  ['Softmax', '', '13+', softmaxV13, parseSoftmaxAttributesV13],\n  // 'Split' operator has an optional attribute 'split'\n  // this attribute determines how the specified axis of input data is split.\n  // When the attribute is missing, we need the count of number of outputs\n  // so that we can determine the 'split' attribute from the runtime input to the Operator\n  ['Split', '', '2-12', split, parseSplitAttributes],\n  ['Sqrt', '', '6+', unaryOps.sqrt],\n  ['Squeeze', '', '1-12', squeeze, parseSqueezeAttributes],\n  ['Squeeze', '', '13+', squeezeV13],\n  ['Sub', '', '7+', binaryOps.sub],\n  ['Sum', '', '6+', sum],\n  ['Tan', '', '7+', unaryOps.tan],\n  ['Tanh', '', '6+', unaryOps.tanh],\n  ['Tile', '', '6+', tile],\n  ['Transpose', '', '1+', transpose, parseTransposeAttributes],\n  ['Upsample', '', '7-8', upsample, parseUpsampleAttributesV7],\n  ['Upsample', '', '9', upsample, parseUpsampleAttributesV9],\n  ['Unsqueeze', '', '1-12', unsqueeze, parseUnsqueezeAttributes],\n  ['Unsqueeze', '', '13+', unsqueezeV13],\n  ['Xor', '', '7+', binaryOps.xor],\n];\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nconst INLINE_FUNC_DEF_REGEX = /@inline[\\s\\n\\r]+(\\w+)[\\s\\n\\r]+([0-9a-zA-Z_]+)\\s*\\(([^)]*)\\)\\s*{(([^}]|[\\n\\r])*)}/gm;\nconst FUNC_CALL_REGEX = '(\\\\w+)?\\\\s+([_0-9a-zA-Z]+)\\\\s+=\\\\s+__FUNC__\\\\((.*)\\\\)\\\\s*;';\n/**\n * GLSL preprocessor responsible for resolving @inline directives\n */\nexport function replaceInlines(script: string): string {\n  const inlineDefs: { [name: string]: { params: Array<{ type: string; name: string } | null>; body: string } } = {};\n  let match;\n  while ((match = INLINE_FUNC_DEF_REGEX.exec(script)) !== null) {\n    const params = match[3]\n      .split(',')\n      .map((s) => {\n        const tokens = s.trim().split(' ');\n        if (tokens && tokens.length === 2) {\n          return { type: tokens[0], name: tokens[1] };\n        }\n        return null;\n      })\n      .filter((v) => v !== null);\n    inlineDefs[match[2]] = { params, body: match[4] };\n  }\n  for (const name in inlineDefs) {\n    const regexString = FUNC_CALL_REGEX.replace('__FUNC__', name);\n    const regex = new RegExp(regexString, 'gm');\n    while ((match = regex.exec(script)) !== null) {\n      const type = match[1];\n      const variable = match[2];\n      const params = match[3].split(',');\n      const declLine = type ? `${type} ${variable};` : '';\n      let newBody: string = inlineDefs[name].body;\n      let paramRedecLine = '';\n      inlineDefs[name].params.forEach((v, i) => {\n        if (v) {\n          paramRedecLine += `${v.type} ${v.name} = ${params[i]};\\n`;\n        }\n      });\n      newBody = `${paramRedecLine}\\n ${newBody}`;\n      newBody = newBody.replace('return', `${variable} = `);\n      const replacement = `\n      ${declLine}\n      {\n        ${newBody}\n      }\n      `;\n      script = script.replace(match[0], replacement);\n    }\n  }\n  script = script.replace(INLINE_FUNC_DEF_REGEX, '');\n  return script;\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Logger } from '../../instrument';\nimport { assert } from '../../util';\n\n/** Layout preferences */\nexport interface WidthHeightPrefs {\n  breakAxis?: number;\n  isPacked?: boolean;\n  reverseWH?: boolean;\n}\n/**\n * TextureLayoutStrategy is an abstraction for different plans\n * for mapping n-dimensional arrays to 2D textures (and back)\n */\nexport interface TextureLayoutStrategy {\n  computeTextureWH(shape: readonly number[], prefs?: WidthHeightPrefs): [number, number];\n}\n\n/**\n * This strategy try to find the minimal max(W,H) that fulfills (W * H == totalSize)\n */\nexport class AlwaysKeepOriginalSizeStrategy implements TextureLayoutStrategy {\n  constructor(public maxTextureSize: number) {}\n  computeTextureWH(shape: readonly number[], prefs?: WidthHeightPrefs): [number, number] {\n    // scalar tensor\n    if (shape.length === 0) {\n      return [1, 1];\n    }\n    const maxTextureSize = this.maxTextureSize;\n    if (prefs && prefs.breakAxis !== undefined) {\n      // check to see if dims fit\n      const wsize = prefs.breakAxis >= shape.length ? 1 : shape.slice(prefs.breakAxis).reduce((a, b) => a * b);\n      const hsize = prefs.breakAxis <= 0 ? 1 : shape.slice(0, prefs.breakAxis).reduce((a, b) => a * b);\n      if (wsize > maxTextureSize || hsize > maxTextureSize) {\n        // ignore preferences\n        // continue with default layout\n        Logger.verbose(\n          'TextureLayout',\n          `Given width/height preferences were unattainable: shape:${shape}, breakAxis:${prefs.breakAxis}`,\n        );\n      } else {\n        return [wsize, hsize];\n      }\n    }\n    const totalSize = shape.reduce((a, b) => a * b);\n\n    let width = Math.floor(Math.sqrt(totalSize));\n\n    for (; width < maxTextureSize && width < totalSize; width++) {\n      if (totalSize % width === 0) {\n        break;\n      }\n    }\n\n    if (width >= maxTextureSize || totalSize % width !== 0) {\n      throw new Error(`The given dimensions are outside this GPU's boundaries: ${shape}`);\n    }\n    return [width, totalSize / width];\n  }\n}\n\nexport class PreferLogicalStrategy implements TextureLayoutStrategy {\n  constructor(public maxTextureSize: number) {}\n  computeTextureWH(shape: readonly number[], prefs?: WidthHeightPrefs): [number, number] {\n    const wh = this.computeTexture(shape, prefs);\n    if (prefs && prefs.isPacked) {\n      wh[0] /= 2;\n      wh[1] /= 2;\n    }\n    if (prefs && prefs.reverseWH) {\n      return [wh[1], wh[0]];\n    }\n    return wh;\n  }\n\n  computeTexture(shape: readonly number[], prefs?: WidthHeightPrefs): [number, number] {\n    const isPacked = prefs && prefs.isPacked;\n    // scalar tensor\n    if (shape.length === 0) {\n      return isPacked ? [2, 2] : [1, 1];\n    }\n    let maxTextureSize = this.maxTextureSize;\n    if (prefs && prefs.breakAxis !== undefined) {\n      // check to see if dims fit\n      const wsize = prefs.breakAxis >= shape.length ? 1 : shape.slice(prefs.breakAxis).reduce((a, b) => a * b);\n      const hsize = prefs.breakAxis <= 0 ? 1 : shape.slice(0, prefs.breakAxis).reduce((a, b) => a * b);\n      if (wsize > maxTextureSize || hsize > maxTextureSize) {\n        // ignore preferences\n        // continue with default layout\n        Logger.verbose(\n          'TextureLayout',\n          `Given width/height preferences were unattainable: shape:${shape}, breakAxis:${prefs.breakAxis}`,\n        );\n      } else {\n        return [wsize, hsize];\n      }\n    }\n    let logShape = shape.slice(0);\n    if (isPacked) {\n      maxTextureSize = maxTextureSize * 2;\n\n      // This logic ensures we accurately count the number of packed texels needed\n      // to accommodate the tensor. We can only pack values in the same texel if\n      // they are from adjacent pairs of rows/cols within the same batch. So if a\n      // tensor has 3 rows, we pretend it has 4 rows in order to account for the\n      // fact that the texels containing the third row are half empty.\n      logShape = logShape.map((_d, i) =>\n        i >= logShape.length - 2 ? (logShape[i] % 2 === 0 ? logShape[i] : logShape[i] + 1) : logShape[i],\n      );\n\n      // Packed texture height is at least 2 (the channel height of a single\n      // texel).\n      if (logShape.length === 1) {\n        logShape = [2, logShape[0]];\n      }\n    }\n\n    // If logical shape is 2, we don't squeeze, since we want to match physical.\n    if (logShape.length !== 2) {\n      const squeezeResult = squeezeShape(logShape);\n      logShape = squeezeResult.newShape;\n    }\n\n    const size = sizeFromShape(logShape);\n    if (logShape.length <= 1 && size <= maxTextureSize) {\n      return [1, size];\n    } else if (logShape.length === 2 && logShape[0] <= maxTextureSize && logShape[1] <= maxTextureSize) {\n      return logShape as [number, number];\n    } else if (logShape.length === 3 && logShape[0] * logShape[1] <= maxTextureSize && logShape[2] <= maxTextureSize) {\n      return [logShape[0] * logShape[1], logShape[2]];\n    } else if (logShape.length === 3 && logShape[0] <= maxTextureSize && logShape[1] * logShape[2] <= maxTextureSize) {\n      return [logShape[0], logShape[1] * logShape[2]];\n    } else if (\n      logShape.length === 4 &&\n      logShape[0] * logShape[1] * logShape[2] <= maxTextureSize &&\n      logShape[3] <= maxTextureSize\n    ) {\n      return [logShape[0] * logShape[1] * logShape[2], logShape[3]];\n    } else if (\n      logShape.length === 4 &&\n      logShape[0] <= maxTextureSize &&\n      logShape[1] * logShape[2] * logShape[3] <= maxTextureSize\n    ) {\n      return [logShape[0], logShape[1] * logShape[2] * logShape[3]];\n    } else {\n      if (isPacked) {\n        // For packed textures size equals the number of channels required to\n        // accommodate the texture data. However in order to squarify such that\n        // inner dimensions stay even, we rewrite size to equal the number of\n        // texels. Then in the return statement we rehydrate the squarified\n        // dimensions to channel units.\n        return sizeToSquarishShape(size / 4).map((d) => d * 2) as [number, number];\n      }\n      return sizeToSquarishShape(size);\n    }\n  }\n}\n\nexport function squeezeShape(shape: number[], axis?: number[]): { newShape: number[]; keptDims: number[] } {\n  const newShape: number[] = [];\n  const keptDims: number[] = [];\n  const isEmptyArray = axis != null && Array.isArray(axis) && axis.length === 0;\n  const axes = axis == null || isEmptyArray ? null : parseAxisParam(axis, shape).sort();\n  let j = 0;\n  for (let i = 0; i < shape.length; ++i) {\n    if (axes != null) {\n      if (axes[j] === i && shape[i] !== 1) {\n        throw new Error(`Can't squeeze axis ${i} since its dim '${shape[i]}' is not 1`);\n      }\n      if ((axes[j] == null || axes[j] > i) && shape[i] === 1) {\n        newShape.push(shape[i]);\n        keptDims.push(i);\n      }\n      if (axes[j] <= i) {\n        j++;\n      }\n    }\n    if (shape[i] !== 1) {\n      newShape.push(shape[i]);\n      keptDims.push(i);\n    }\n  }\n  return { newShape, keptDims };\n}\n\nexport function parseAxisParam(axis: number | number[], shape: number[]): number[] {\n  const rank = shape.length;\n\n  // Normalize input\n  axis = axis == null ? shape.map((_s, i) => i) : ([] as number[]).concat(axis);\n\n  // Check for valid range\n  assert(\n    axis.every((ax) => ax >= -rank && ax < rank),\n    () => `All values in axis param must be in range [-${rank}, ${rank}) but ` + `got axis ${axis}`,\n  );\n\n  // Check for only integers\n  assert(axis.every(isInt), () => 'All values in axis param must be integers but ' + `got axis ${axis}`);\n\n  // Handle negative axis.\n  return axis.map((a) => (a < 0 ? rank + a : a));\n}\nexport function isInt(a: number): boolean {\n  return a % 1 === 0;\n}\nexport function sizeFromShape(shape: number[]): number {\n  if (shape.length === 0) {\n    // Scalar.\n    return 1;\n  }\n  let size = shape[0];\n  for (let i = 1; i < shape.length; i++) {\n    size *= shape[i];\n  }\n  return size;\n}\nexport function getRowsCols(shape: number[]): [number, number] {\n  if (shape.length === 0) {\n    throw Error('Cannot get rows and columns of an empty shape array.');\n  }\n\n  return [shape.length > 1 ? shape[shape.length - 2] : 1, shape[shape.length - 1]];\n}\nexport function sizeToSquarishShape(size: number): [number, number] {\n  const width = Math.ceil(Math.sqrt(size));\n  return [width, Math.ceil(size / width)];\n}\nexport function getBatchDim(shape: number[], dimsToSkip = 2): number {\n  return sizeFromShape(shape.slice(0, shape.length - dimsToSkip));\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { ArrayUtil, BroadcastUtil, ShapeUtil } from '../../util';\n\nimport { GlslContext, GlslLib, GlslLibRoutine } from './glsl-definitions';\nimport { getGlsl } from './glsl-source';\nimport { squeezeShape } from './texture-layout-strategy';\nimport { TextureLayout } from './types';\nimport {\n  generateShaderFuncNameFromInputSamplerName,\n  generateShaderFuncNameFromInputSamplerNameAtOutCoords,\n  getCoordsDataType,\n  getGlChannels,\n  getSqueezedParams,\n  squeezeInputShape,\n} from './utils';\n\n/**\n * GLSL Library responsible for data types and routines for manipulating\n * coordinates and mapping to/from tensor indices\n */\nexport class CoordsGlslLib extends GlslLib {\n  returnType: string;\n\n  constructor(context: GlslContext) {\n    super(context);\n  }\n  getFunctions(): { [name: string]: GlslLibRoutine } {\n    return {\n      ...this.offsetToCoords(),\n      ...this.coordsToOffset(),\n      ...this.toVec(),\n      ...this.valueFrom(),\n      // TODO return these only when packing is enabled.\n      ...this.getCommonUtilFuncs(),\n      ...this.getInputsSamplingSnippets(),\n      ...this.getOutputSamplingSnippet(),\n    };\n  }\n  getCustomTypes() {\n    return {};\n  }\n  /**\n   * Produces a function that can map from\n   * 2D normalzied coordinates (s,t) to a flat offset\n   */\n  protected offsetToCoords(): { [name: string]: GlslLibRoutine } {\n    const funcName = 'offsetToCoords';\n    return {\n      offsetToCoords: new GlslLibRoutine(`\n      vec2 ${funcName}(int offset, int width, int height) {\n        int t = offset / width;\n        int s = offset - t*width;\n        vec2 coords = (vec2(s,t) + vec2(0.5,0.5)) / vec2(width, height);\n        return coords;\n      }\n      `),\n    };\n  }\n\n  /**\n   * Produces a function that can map from\n   * 2D normalzied coordinates (s,t) to a flat offset\n   */\n  protected coordsToOffset(): { [name: string]: GlslLibRoutine } {\n    const funcName = 'coordsToOffset';\n    return {\n      coordsToOffset: new GlslLibRoutine(`\n      int ${funcName}(vec2 coords, int width, int height) {\n        float s = coords.s * float(width);\n        float t = coords.t * float(height);\n        int offset = int(t) * width + int(s);\n        return offset;\n      }\n      `),\n    };\n  }\n\n  /**\n   * Generates code for output sampler.\n   */\n\n  protected getOutputSamplingSnippet(): { [name: string]: GlslLibRoutine } {\n    const outputLayout = this.context.outputTextureLayout;\n    if (outputLayout.isPacked) {\n      return this.getPackedOutputSamplingSnippet(outputLayout);\n    } else {\n      return this.getUnpackedOutputSamplingSnippet(outputLayout);\n    }\n  }\n\n  /**\n   * Generates code for packed output sampler.\n   */\n  protected getPackedOutputSamplingSnippet(outputLayout: TextureLayout): { [name: string]: GlslLibRoutine } {\n    const outShape = outputLayout.unpackedShape;\n    const outTexShape = [outputLayout.width, outputLayout.height];\n    const result: { [name: string]: GlslLibRoutine } = {};\n    const funcName = 'getOutputCoords';\n    switch (outShape.length) {\n      case 0:\n        result[funcName] = this.getOutputScalarCoords();\n        break;\n      case 1:\n        result[funcName] = this.getOutputPacked1DCoords(outShape as [number], outTexShape as [number, number]);\n        break;\n      case 2:\n        result[funcName] = this.getOutputPacked2DCoords(outShape as [number, number], outTexShape as [number, number]);\n        break;\n      case 3:\n        result[funcName] = this.getOutputPacked3DCoords(\n          outShape as [number, number, number],\n          outTexShape as [number, number],\n        );\n        break;\n      default:\n        result[funcName] = this.getOutputPackedNDCoords(outShape, outTexShape as [number, number]);\n    }\n    const glsl = getGlsl(this.context.glContext.version);\n    // TODO we need this to properly return a packed vec4 from kernels.\n    // Replace all '{glsl.output} = result' with 'setOutput(result)' in all kernels.\n    const floatTextureSetRGBASource = `\n      void setOutput(vec4 val) {\n        ${glsl.output} = val;\n      }\n    `;\n    const floatTextureSetRGBAFuncName = 'floatTextureSetRGBA';\n    result[floatTextureSetRGBAFuncName] = new GlslLibRoutine(floatTextureSetRGBASource);\n    return result;\n  }\n\n  /**\n   * Generates code for unpacked output sampler.\n   */\n  protected getUnpackedOutputSamplingSnippet(outputLayout: TextureLayout): { [name: string]: GlslLibRoutine } {\n    const outShape = outputLayout.unpackedShape;\n    const outTexShape = [outputLayout.width, outputLayout.height];\n    const result: { [name: string]: GlslLibRoutine } = {};\n    const funcName = 'getOutputCoords';\n    switch (outShape.length) {\n      case 0:\n        result[funcName] = this.getOutputScalarCoords();\n        break;\n      case 1:\n        result[funcName] = this.getOutputUnpacked1DCoords(outShape as [number], outTexShape as [number, number]);\n        break;\n      case 2:\n        result[funcName] = this.getOutputUnpacked2DCoords(\n          outShape as [number, number],\n          outTexShape as [number, number],\n        );\n        break;\n      case 3:\n        result[funcName] = this.getOutputUnpacked3DCoords(\n          outShape as [number, number, number],\n          outTexShape as [number, number],\n        );\n        break;\n      case 4:\n        result[funcName] = this.getOutputUnpacked4DCoords(\n          outShape as [number, number, number, number],\n          outTexShape as [number, number],\n        );\n        break;\n      case 5:\n        result[funcName] = this.getOutputUnpacked5DCoords(\n          outShape as [number, number, number, number, number],\n          outTexShape as [number, number],\n        );\n        break;\n      case 6:\n        result[funcName] = this.getOutputUnpacked6DCoords(\n          outShape as [number, number, number, number, number, number],\n          outTexShape as [number, number],\n        );\n        break;\n      default:\n        throw new Error(`Unsupported output dimensionality: ${outShape.length}`);\n    }\n    const glsl = getGlsl(this.context.glContext.version);\n    // TODO we need this to properly return a packed vec4 from kernels.\n    // Replace all '{glsl.output} = result' with 'setOutput(result)' in all kernels.\n    const floatTextureSetRSource = `\n        void setOutput(float val) {\n          ${glsl.output} = vec4(val, 0, 0, 0);\n        }\n    `;\n    const floatTextureSetRFuncName = 'floatTextureSetR';\n    result[floatTextureSetRFuncName] = new GlslLibRoutine(floatTextureSetRSource);\n    return result;\n  }\n\n  /**\n   * Scalar output coordinates.\n   */\n  protected getOutputScalarCoords(): GlslLibRoutine {\n    return new GlslLibRoutine(`\n      int getOutputCoords() {\n        return 0;\n      }\n    `);\n  }\n\n  /**\n   * 1D packed output coordinates.\n   */\n  protected getOutputPacked1DCoords(_shape: [number], texShape: [number, number]): GlslLibRoutine {\n    const packedTexShape = texShape;\n    let source = '';\n    if (packedTexShape[0] === 1) {\n      source = `\n          int getOutputCoords() {\n            return 2 * int(TexCoords.y * ${packedTexShape[1]}.0);\n          }\n        `;\n      return new GlslLibRoutine(source);\n    }\n\n    if (packedTexShape[1] === 1) {\n      source = `\n          int getOutputCoords() {\n            return 2 * int(TexCoords.x * ${packedTexShape[0]}.0);\n          }\n        `;\n      return new GlslLibRoutine(source);\n    }\n\n    source = `\n        int getOutputCoords() {\n          ivec2 resTexRC = ivec2(TexCoords.xy *\n                                 vec2(${packedTexShape[0]}, ${packedTexShape[1]}));\n          return 2 * (resTexRC.y * ${packedTexShape[0]} + resTexRC.x);\n        }\n      `;\n    return new GlslLibRoutine(source);\n  }\n\n  /**\n   * 2D packed output coordinates.\n   */\n  protected getOutputPacked2DCoords(shape: [number, number], texShape: [number, number]): GlslLibRoutine {\n    let source = '';\n    if (ArrayUtil.arraysEqual(shape, texShape)) {\n      source = `\n        ivec2 getOutputCoords() {\n          return 2 * ivec2(TexCoords.xy * vec2(${texShape[0]}, ${texShape[1]}));\n        }\n      `;\n      return new GlslLibRoutine(source);\n    }\n\n    const packedTexShape = texShape;\n    // texels needed to accommodate a logical row\n    const texelsInLogicalRow = Math.ceil(shape[1] / 2);\n\n    /**\n     * getOutputCoords\n     *\n     * resTexRC: The rows and columns of the texels. If you move over one\n     * texel to the right in the packed texture, you are moving over one column\n     * (not two).\n     *\n     * index: The texel index\n     */\n    source = `\n        ivec2 getOutputCoords() {\n          ivec2 resTexRC = ivec2(TexCoords.xy *\n                                vec2(${packedTexShape[0]}, ${packedTexShape[1]}));\n\n          int index = resTexRC.y * ${packedTexShape[0]} + resTexRC.x;\n\n          // reverse r and c order for packed texture\n          int r = imod(index, ${texelsInLogicalRow}) * 2;\n          int c = 2 * (index / ${texelsInLogicalRow});\n\n          return ivec2(r, c);\n        }\n      `;\n    return new GlslLibRoutine(source);\n  }\n\n  /**\n   * 3D packed output coordinates.\n   */\n  protected getOutputPacked3DCoords(shape: [number, number, number], texShape: [number, number]): GlslLibRoutine {\n    const packedTexShape = [texShape[0], texShape[1]];\n    const texelsInLogicalRow = Math.ceil(shape[2] / 2);\n    const texelsInBatch = texelsInLogicalRow * Math.ceil(shape[1] / 2);\n    const source = `\n        ivec3 getOutputCoords() {\n          ivec2 resTexRC = ivec2(TexCoords.xy *\n                                vec2(${packedTexShape[0]}, ${packedTexShape[1]}));\n          int index = resTexRC.y * ${packedTexShape[0]} + resTexRC.x;\n\n          int b = index / ${texelsInBatch};\n          index -= b * ${texelsInBatch};\n\n          // reverse r and c order for packed texture\n          int r = imod(index, ${texelsInLogicalRow}) * 2;\n          int c = 2 * (index / ${texelsInLogicalRow});\n\n          return ivec3(b, r, c);\n        }\n      `;\n    return new GlslLibRoutine(source);\n  }\n\n  /**\n   * ND packed output coordinates.\n   */\n  protected getOutputPackedNDCoords(shape: readonly number[], texShape: [number, number]): GlslLibRoutine {\n    const packedTexShape = [texShape[0], texShape[1]];\n\n    const texelsInLogicalRow = Math.ceil(shape[shape.length - 1] / 2);\n    const texelsInBatch = texelsInLogicalRow * Math.ceil(shape[shape.length - 2] / 2);\n    let texelsInBatchN = texelsInBatch;\n    let batches = '';\n    let coords = 'b, r, c';\n\n    for (let b = 2; b < shape.length - 1; b++) {\n      texelsInBatchN *= shape[shape.length - b - 1];\n      batches =\n        `\n      int b${b} = index / ${texelsInBatchN};\n      index -= b${b} * ${texelsInBatchN};\n    ` + batches;\n      coords = `b${b}, ` + coords;\n    }\n    const source = `\n      ivec${shape.length} getOutputCoords() {\n        ivec2 resTexRC = ivec2(TexCoords.xy *\n                              vec2(${packedTexShape[0]}, ${packedTexShape[1]}));\n        int index = resTexRC.y * ${packedTexShape[0]} + resTexRC.x;\n\n        ${batches}\n\n        int b = index / ${texelsInBatch};\n        index -= b * ${texelsInBatch};\n\n        // reverse r and c order for packed texture\n        int r = imod(index, ${texelsInLogicalRow}) * 2;\n        int c = 2 * (index / ${texelsInLogicalRow});\n\n        return ivec${shape.length}(${coords});\n      }\n    `;\n    return new GlslLibRoutine(source);\n  }\n\n  /**\n   * Unpacked 1D output coordinates.\n   */\n  protected getOutputUnpacked1DCoords(_shape: [number], texShape: [number, number]): GlslLibRoutine {\n    const source = `\n        int getOutputCoords() {\n          ivec2 resTexRC = ivec2(TexCoords.xy *\n                                vec2(${texShape[0]}, ${texShape[1]}));\n          return resTexRC.y * ${texShape[0]} + resTexRC.x;\n        }\n      `;\n    return new GlslLibRoutine(source);\n  }\n\n  /**\n   * Unpacked 2D output coordinates.\n   */\n  protected getOutputUnpacked2DCoords(shape: [number, number], texShape: [number, number]): GlslLibRoutine {\n    const source = `\n        ivec2 getOutputCoords() {\n          ivec2 resTexRC = ivec2(TexCoords.xy *\n                                vec2(${texShape[0]}, ${texShape[1]}));\n          int index = resTexRC.y * ${texShape[0]} + resTexRC.x;\n          int r = index / ${shape[1]};\n          int c = index - r * ${shape[1]};\n          return ivec2(r, c);\n        }\n      `;\n    return new GlslLibRoutine(source);\n  }\n\n  /**\n   * Unpacked 3D output coordinates.\n   */\n  protected getOutputUnpacked3DCoords(shape: [number, number, number], texShape: [number, number]): GlslLibRoutine {\n    let source = '';\n    const rank = shape.length;\n\n    let strides = null;\n    if (rank < 2) {\n      strides = [];\n    }\n\n    strides = new Array(rank - 1);\n    strides[rank - 2] = shape[rank - 1];\n    for (let i = rank - 3; i >= 0; --i) {\n      strides[i] = strides[i + 1] * shape[i + 1];\n    }\n    const coordsToCompute = ['r', 'c', 'd'];\n    const coordsFromIndexSnippet = strides\n      .map((stride, i) => {\n        const line1 = `int ${coordsToCompute[i]} = index / ${stride}`;\n        const line2 =\n          i === strides.length - 1\n            ? `int ${coordsToCompute[i + 1]} = index - ${coordsToCompute[i]} * ${stride}`\n            : `index -= ${coordsToCompute[i]} * ${stride}`;\n        return `${line1}; ${line2};`;\n      })\n      .join('');\n\n    source = `\n        ivec3 getOutputCoords() {\n          ivec2 resTexRC = ivec2(TexCoords.xy *\n                                vec2(${texShape[0]}, ${texShape[1]}));\n          int index = resTexRC.y * ${texShape[0]} + resTexRC.x;\n          ${coordsFromIndexSnippet}\n          return ivec3(r, c, d);\n        }\n      `;\n    return new GlslLibRoutine(source);\n  }\n\n  /**\n   * Unpacked 4D output coordinates.\n   */\n  protected getOutputUnpacked4DCoords(\n    shape: [number, number, number, number],\n    texShape: [number, number],\n  ): GlslLibRoutine {\n    let source = '';\n    const rank = shape.length;\n\n    let strides = null;\n    if (rank < 2) {\n      strides = [];\n    }\n\n    strides = new Array(rank - 1);\n    strides[rank - 2] = shape[rank - 1];\n    for (let i = rank - 3; i >= 0; --i) {\n      strides[i] = strides[i + 1] * shape[i + 1];\n    }\n    const coordsToCompute = ['r', 'c', 'd', 'd2'];\n    const coordsFromIndexSnippet = strides\n      .map((stride, i) => {\n        const line1 = `int ${coordsToCompute[i]} = index / ${stride}`;\n        const line2 =\n          i === strides.length - 1\n            ? `int ${coordsToCompute[i + 1]} = index - ${coordsToCompute[i]} * ${stride}`\n            : `index -= ${coordsToCompute[i]} * ${stride}`;\n        return `${line1}; ${line2};`;\n      })\n      .join('');\n\n    source = `\n      ivec4 getOutputCoords() {\n          ivec2 resTexRC = ivec2(TexCoords.xy *\n                                vec2(${texShape[0]}, ${texShape[1]}));\n          int index = resTexRC.y * ${texShape[0]} + resTexRC.x;\n          ${coordsFromIndexSnippet}\n          return ivec4(r, c, d, d2);\n        }\n      `;\n    return new GlslLibRoutine(source);\n  }\n\n  /**\n   * Unpacked 5D output coordinates.\n   */\n  protected getOutputUnpacked5DCoords(\n    shape: [number, number, number, number, number],\n    texShape: [number, number],\n  ): GlslLibRoutine {\n    let source = '';\n    const rank = shape.length;\n\n    let strides = null;\n    if (rank < 2) {\n      strides = [];\n    }\n\n    strides = new Array(rank - 1);\n    strides[rank - 2] = shape[rank - 1];\n    for (let i = rank - 3; i >= 0; --i) {\n      strides[i] = strides[i + 1] * shape[i + 1];\n    }\n    const coordsToCompute = ['r', 'c', 'd', 'd2', 'd3'];\n    const coordsFromIndexSnippet = strides\n      .map((stride, i) => {\n        const line1 = `int ${coordsToCompute[i]} = index / ${stride}`;\n        const line2 =\n          i === strides.length - 1\n            ? `int ${coordsToCompute[i + 1]} = index - ${coordsToCompute[i]} * ${stride}`\n            : `index -= ${coordsToCompute[i]} * ${stride}`;\n        return `${line1}; ${line2};`;\n      })\n      .join('');\n\n    source = `\n      ivec5 getOutputCoords() {\n          ivec2 resTexRC = ivec2(TexCoords.xy *\n                                vec2(${texShape[0]}, ${texShape[1]}));\n          int index = resTexRC.y * ${texShape[0]} + resTexRC.x;\n          ${coordsFromIndexSnippet}\n          return ivec5(r, c, d, d2, d3);\n        }\n      `;\n    return new GlslLibRoutine(source);\n  }\n\n  /**\n   * Unpacked 6D output coordinates.\n   */\n  protected getOutputUnpacked6DCoords(\n    shape: [number, number, number, number, number, number],\n    texShape: [number, number],\n  ): GlslLibRoutine {\n    let source = '';\n    const rank = shape.length;\n\n    let strides = null;\n    if (rank < 2) {\n      strides = [];\n    }\n\n    strides = new Array(rank - 1);\n    strides[rank - 2] = shape[rank - 1];\n    for (let i = rank - 3; i >= 0; --i) {\n      strides[i] = strides[i + 1] * shape[i + 1];\n    }\n    const coordsToCompute = ['r', 'c', 'd', 'd2', 'd3', 'd4'];\n    const coordsFromIndexSnippet = strides\n      .map((stride, i) => {\n        const line1 = `int ${coordsToCompute[i]} = index / ${stride}`;\n        const line2 =\n          i === strides.length - 1\n            ? `int ${coordsToCompute[i + 1]} = index - ${coordsToCompute[i]} * ${stride}`\n            : `index -= ${coordsToCompute[i]} * ${stride}`;\n        return `${line1}; ${line2};`;\n      })\n      .join('');\n\n    source = `\n     ivec6 getOutputCoords() {\n         ivec2 resTexRC = ivec2(TexCoords.xy *\n                               vec2(${texShape[0]}, ${texShape[1]}));\n         int index = resTexRC.y * ${texShape[0]} + resTexRC.x;\n         ${coordsFromIndexSnippet}\n         return ivec6(r, c, d, d2, d3, d4);\n       }\n     `;\n    return new GlslLibRoutine(source);\n  }\n\n  /**\n   * Generates code for common UV coords computation utility functions.\n   */\n  protected getCommonUtilFuncs(): { [name: string]: GlslLibRoutine } {\n    const result: { [name: string]: GlslLibRoutine } = {};\n    let funcName = 'uvFromFlat';\n    result[funcName] = new GlslLibRoutine(`\n    vec2 uvFromFlat(int texNumR, int texNumC, int index) {\n      int texC = index / texNumR;\n      int texR = index - texC * texNumR;\n      // TODO: swap texR, texC order in following function so row is corresponding to u and column is corresponding to\n      //       v.\n      return (vec2(texR, texC) + halfCR) / vec2(texNumR, texNumC);\n    }\n    `);\n    funcName = 'packedUVfrom1D';\n    result[funcName] = new GlslLibRoutine(`\n      vec2 packedUVfrom1D(int texNumR, int texNumC, int index) {\n        int texelIndex = index / 2;\n        int texR = texelIndex / texNumC;\n        int texC = texelIndex - texR * texNumC;\n        return (vec2(texC, texR) + halfCR) / vec2(texNumC, texNumR);\n      }\n      `);\n    funcName = 'packedUVfrom2D';\n    result[funcName] = new GlslLibRoutine(`\n      vec2 packedUVfrom2D(int texNumR, int texNumC, int texelsInLogicalRow, int row, int col) {\n        int texelIndex = (row / 2) * texelsInLogicalRow + (col / 2);\n        int texR = texelIndex / texNumC;\n        int texC = texelIndex - texR * texNumC;\n        return (vec2(texC, texR) + halfCR) / vec2(texNumC, texNumR);\n      }\n      `);\n    funcName = 'packedUVfrom3D';\n    result[funcName] = new GlslLibRoutine(`\n      vec2 packedUVfrom3D(int texNumR, int texNumC,\n          int texelsInBatch, int texelsInLogicalRow, int b,\n          int row, int col) {\n        int index = b * texelsInBatch + (row / 2) * texelsInLogicalRow + (col / 2);\n        int texR = index / texNumC;\n        int texC = index - texR * texNumC;\n        return (vec2(texC, texR) + halfCR) / vec2(texNumC, texNumR);\n      }\n      `);\n    funcName = 'sampleTexture';\n    const glsl = getGlsl(this.context.glContext.version);\n    result[funcName] = new GlslLibRoutine(`\n        float sampleTexture(sampler2D textureSampler, vec2 uv) {\n            return ${glsl.texture2D}(textureSampler, uv).r;\n        }`);\n    return result;\n  }\n\n  /**\n   * Constructing snippets for inputs\n   */\n  protected getInputsSamplingSnippets(): { [name: string]: GlslLibRoutine } {\n    const result: { [name: string]: GlslLibRoutine } = {};\n    const outputLayout = this.context.outputTextureLayout;\n    this.context.programInfo.inputNames.forEach((samplerName, i) => {\n      const inputLayout = this.context.inputTextureLayouts[i];\n      const funcName = generateShaderFuncNameFromInputSamplerName(samplerName);\n      if (inputLayout.isPacked) {\n        result[funcName] = this.getPackedSamplerFromInput(funcName, samplerName, inputLayout);\n      } else {\n        result[funcName] = this.getUnpackedSamplerFromInput(funcName, samplerName, inputLayout);\n      }\n\n      const outCoordFuncName = generateShaderFuncNameFromInputSamplerNameAtOutCoords(samplerName);\n      if (inputLayout.unpackedShape.length <= outputLayout.unpackedShape.length) {\n        if (inputLayout.isPacked) {\n          result[outCoordFuncName] = this.getPackedSamplerAtOutputCoords(\n            outCoordFuncName,\n            inputLayout,\n            outputLayout,\n            samplerName,\n          );\n        } else {\n          result[outCoordFuncName] = this.getUnpackedSamplerAtOutputCoords(\n            outCoordFuncName,\n            inputLayout,\n            outputLayout,\n            samplerName,\n          );\n        }\n      }\n    });\n\n    return result;\n  }\n\n  /**\n   * Constructing snippets for output coordinates of samplers\n   */\n  protected getPackedSamplerAtOutputCoords(\n    funcName: string,\n    inputLayout: TextureLayout,\n    outputLayout: TextureLayout,\n    name: string,\n  ): GlslLibRoutine {\n    const inShape = inputLayout.unpackedShape;\n    const outShape = outputLayout.unpackedShape;\n    const texName = name;\n    const texFuncSnippet = generateShaderFuncNameFromInputSamplerName(texName);\n\n    const inRank = inShape.length;\n    const outRank = outShape.length;\n\n    const broadcastDims = BroadcastUtil.getBroadcastDims(inShape, outShape);\n\n    const type = getCoordsDataType(outRank);\n    const rankDiff = outRank - inRank;\n    let coordsSnippet: string;\n    const fields = getGlChannels();\n\n    if (inRank === 0) {\n      coordsSnippet = '';\n    } else if (outRank < 2 && broadcastDims.length >= 1) {\n      coordsSnippet = 'coords = 0;';\n    } else {\n      coordsSnippet = broadcastDims.map((d) => `coords.${fields[d + rankDiff]} = 0;`).join('\\n');\n    }\n    let unpackedCoordsSnippet = '';\n    if (outRank < 2 && inRank > 0) {\n      unpackedCoordsSnippet = 'coords';\n    } else {\n      unpackedCoordsSnippet = inShape.map((_s, i) => `coords.${fields[i + rankDiff]}`).join(', ');\n    }\n\n    let output = 'return outputValue;';\n    const inSize = ShapeUtil.size(inShape);\n    const isInputScalar = inSize === 1;\n    const outSize = ShapeUtil.size(outShape);\n    const isOutputScalar = outSize === 1;\n\n    if (inRank === 1 && !isInputScalar && !isOutputScalar) {\n      output = `\n        return vec4(outputValue.xy, outputValue.xy);\n      `;\n    } else if (isInputScalar && !isOutputScalar) {\n      if (outRank === 1) {\n        output = `\n          return vec4(outputValue.x, outputValue.x, 0., 0.);\n        `;\n      } else {\n        output = `\n          return vec4(outputValue.x);\n        `;\n      }\n    } else if (broadcastDims.length) {\n      const rows = inRank - 2;\n      const cols = inRank - 1;\n\n      if (broadcastDims.indexOf(rows) > -1 && broadcastDims.indexOf(cols) > -1) {\n        output = 'return vec4(outputValue.x);';\n      } else if (broadcastDims.indexOf(rows) > -1) {\n        output = 'return vec4(outputValue.x, outputValue.y, ' + 'outputValue.x, outputValue.y);';\n      } else if (broadcastDims.indexOf(cols) > -1) {\n        output = 'return vec4(outputValue.xx, outputValue.zz);';\n      }\n    }\n\n    const swapLastDimsSnippet = `\n        int lastDim = coords.${fields[outRank - 1]};\n        coords.${fields[outRank - 1]} = coords.${fields[outRank - 2]};\n        coords.${fields[outRank - 2]} = lastDim;\n      `;\n    const source = `\n      vec4 ${funcName}() {\n        ${type} coords = getOutputCoords();\n        ${swapLastDimsSnippet}\n        ${coordsSnippet}\n        vec4 outputValue = ${texFuncSnippet}(${unpackedCoordsSnippet});\n        ${output}\n      }\n    `;\n    return new GlslLibRoutine(source, ['coordinates.getOutputCoords']);\n  }\n\n  /**\n   * Constructing snippets for unpacked output coordinates of samplers\n   */\n  protected getUnpackedSamplerAtOutputCoords(\n    funcName: string,\n    inputLayout: TextureLayout,\n    outputLayout: TextureLayout,\n    name: string,\n  ): GlslLibRoutine {\n    const outTexShape = [outputLayout.width, outputLayout.height];\n    const inTexShape = [inputLayout.width, inputLayout.height];\n    const inRank = inputLayout.unpackedShape.length;\n    const outRank = outputLayout.unpackedShape.length;\n    const inShape = inputLayout.unpackedShape;\n    const outShape = outputLayout.unpackedShape;\n    const texFuncSnippet = generateShaderFuncNameFromInputSamplerName(name);\n\n    if (inRank === outRank && ArrayUtil.arraysEqual(inTexShape, outTexShape)) {\n      const source = `\n          float ${funcName}() {\n            return sampleTexture(${name}, TexCoords);\n          }\n        `;\n      return new GlslLibRoutine(source, ['coordinates.sampleTexture']);\n    }\n\n    const type = getCoordsDataType(outRank);\n    const broadcastDims = BroadcastUtil.getBroadcastDims(inShape, outShape);\n    const rankDiff = outRank - inRank;\n    let coordsSnippet: string;\n    const fields = getGlChannels();\n\n    if (inRank === 0) {\n      coordsSnippet = '';\n    } else if (outRank < 2 && broadcastDims.length >= 1) {\n      coordsSnippet = 'coords = 0;';\n    } else {\n      coordsSnippet = broadcastDims.map((d) => `coords.${fields[d + rankDiff]} = 0;`).join('\\n');\n    }\n    let unpackedCoordsSnippet = '';\n    if (outRank < 2 && inRank > 0) {\n      unpackedCoordsSnippet = 'coords';\n    } else {\n      unpackedCoordsSnippet = inputLayout.unpackedShape.map((_s, i) => `coords.${fields[i + rankDiff]}`).join(', ');\n    }\n    const source = `\n        float ${funcName}() {\n          ${type} coords = getOutputCoords();\n          ${coordsSnippet}\n          return ${texFuncSnippet}(${unpackedCoordsSnippet});\n        }\n      `;\n    return new GlslLibRoutine(source, ['coordinates.getOutputCoords']);\n  }\n\n  /**\n   * Constructing snippets for packed operations.\n   */\n  protected getPackedSamplerFromInput(funcName: string, name: string, inputLayout: TextureLayout): GlslLibRoutine {\n    switch (inputLayout.unpackedShape.length) {\n      case 0:\n        return this.getPackedSamplerScalar(funcName, name);\n      case 1:\n        return this.getPackedSampler1D(funcName, name, inputLayout);\n      case 2:\n        return this.getPackedSampler2D(funcName, name, inputLayout);\n      case 3:\n        return this.getPackedSampler3D(funcName, name, inputLayout);\n      default:\n        return this.getPackedSamplerND(funcName, name, inputLayout);\n    }\n  }\n\n  /**\n   * Constructing snippets for unpacked operations.\n   */\n  protected getUnpackedSamplerFromInput(funcName: string, name: string, inputLayout: TextureLayout): GlslLibRoutine {\n    const shape = inputLayout.unpackedShape;\n    switch (shape.length) {\n      case 0:\n        return this.getUnpackedSamplerScalar(funcName, name, inputLayout);\n      case 1:\n        return this.getUnpackedSampler1D(funcName, name, inputLayout);\n      case 2:\n        return this.getUnpackedSampler2D(funcName, name, inputLayout);\n      case 3:\n        return this.getUnpackedSampler3D(funcName, name, inputLayout);\n      case 4:\n        return this.getUnpackedSampler4D(funcName, name, inputLayout);\n      case 5:\n        return this.getUnpackedSampler5D(funcName, name, inputLayout);\n      case 6:\n        return this.getUnpackedSampler6D(funcName, name, inputLayout);\n      default:\n        // TODO support more dimensionalities\n        throw new Error(`Unsupported dimension ${shape.length}-D`);\n    }\n  }\n\n  /**\n   * Packed scalar snippet.\n   */\n  protected getPackedSamplerScalar(funcName: string, name: string): GlslLibRoutine {\n    const glsl = getGlsl(this.context.glContext.version);\n    const source = `\n          vec4 ${funcName}() {\n            return ${glsl.texture2D}(${name}, halfCR);\n          }\n        `;\n    return new GlslLibRoutine(source);\n  }\n\n  /**\n   * Packed 1D snippet.\n   */\n  protected getPackedSampler1D(funcName: string, name: string, inputLayout: TextureLayout): GlslLibRoutine {\n    const texShape = [inputLayout.width, inputLayout.height];\n    const packedTexShape = [texShape[1], texShape[0]];\n    const glsl = getGlsl(this.context.glContext.version);\n\n    const packedSampler = `vec4 ${funcName}(int index) {\n      vec2 uv = packedUVfrom1D(\n      ${packedTexShape[0]}, ${packedTexShape[1]}, index);\n      return ${glsl.texture2D}(${name}, uv);\n    }`;\n    const source = packedSampler;\n    return new GlslLibRoutine(source, ['coordinates.packedUVfrom1D']);\n  }\n\n  /**\n   * Packed 2D snippet.\n   */\n  protected getPackedSampler2D(funcName: string, name: string, inputLayout: TextureLayout): GlslLibRoutine {\n    const shape = inputLayout.unpackedShape;\n    const texShape = [inputLayout.width, inputLayout.height];\n    const glsl = getGlsl(this.context.glContext.version);\n    const texNumR = texShape[0];\n    const texNumC = texShape[1];\n\n    if (texShape != null && ArrayUtil.arraysEqual(shape, texShape)) {\n      const packedSampler = `vec4 ${funcName}(int row, int col) {\n        vec2 uv = (vec2(col, row) + halfCR) / vec2(${texNumC}.0, ${texNumR}.0);\n        return ${glsl.texture2D}(${name}, uv);\n      }`;\n\n      return new GlslLibRoutine(packedSampler);\n    }\n    const packedTexShape = texShape;\n    const valuesPerRow = Math.ceil(shape[1] / 2);\n    const packedSampler = `vec4 ${funcName}(int row, int col) {\n      vec2 uv = packedUVfrom2D(${packedTexShape[1]}, ${packedTexShape[0]}, ${valuesPerRow}, row, col);\n      return ${glsl.texture2D}(${name}, uv);\n    }`;\n    const source = packedSampler;\n    return new GlslLibRoutine(source, ['coordinates.packedUVfrom2D']);\n  }\n\n  /**\n   * Packed 3D snippet.\n   */\n  protected getPackedSampler3D(funcName: string, name: string, inputLayout: TextureLayout): GlslLibRoutine {\n    const shape = inputLayout.unpackedShape;\n    const texShape = [inputLayout.width, inputLayout.height];\n    const packedTexShape = [texShape[0], texShape[1]];\n    const glsl = getGlsl(this.context.glContext.version);\n\n    if (shape[0] === 1) {\n      const squeezedShape = shape.slice(1);\n      const keptDims = [1, 2];\n      const newInputShape = squeezeInputShape(shape, squeezedShape);\n      const params = ['b', 'row', 'col'];\n      // Deep copy of input texture layout.\n      const newInputLayout: TextureLayout = JSON.parse(JSON.stringify(inputLayout));\n      newInputLayout.unpackedShape = newInputShape;\n      const samplerRoutine = this.getPackedSamplerFromInput(funcName, name, newInputLayout);\n      const packedSampler = `${samplerRoutine.routineBody}\n      vec4 ${funcName}(int b, int row, int col) {\n        return ${funcName}(${getSqueezedParams(params, keptDims)});\n      } `;\n      const source = packedSampler;\n      return new GlslLibRoutine(source, samplerRoutine.dependencies);\n    }\n    const texNumR = packedTexShape[0];\n    const texNumC = packedTexShape[1];\n\n    const valuesPerRow = Math.ceil(shape[2] / 2);\n    const texelsInBatch = valuesPerRow * Math.ceil(shape[1] / 2);\n\n    const packedSampler = `vec4 ${funcName}(int b, int row, int col) {\n      vec2 uv = packedUVfrom3D(\n        ${texNumC}, ${texNumR}, ${texelsInBatch}, ${valuesPerRow}, b, row, col);\n      return ${glsl.texture2D}(${name}, uv);}`;\n    const source = packedSampler;\n    return new GlslLibRoutine(source, ['coordinates.packedUVfrom3D']);\n  }\n  /*\n   * Packed ND snippet.\n   */\n  protected getPackedSamplerND(funcName: string, name: string, inputLayout: TextureLayout): GlslLibRoutine {\n    const shape = inputLayout.unpackedShape;\n    const rank = shape.length;\n    const texShape = [inputLayout.width, inputLayout.height];\n    const glsl = getGlsl(this.context.glContext.version);\n\n    const packedTexShape = [texShape[0], texShape[1]];\n    const texNumR = packedTexShape[1];\n    const texNumC = packedTexShape[0];\n    const valuesPerRow = Math.ceil(shape[rank - 1] / 2);\n    let texelsInBatch = valuesPerRow * Math.ceil(shape[rank - 2] / 2);\n    let params = 'int b, int row, int col';\n    let index = `b * ${texelsInBatch} + (row / 2) * ${valuesPerRow} + (col / 2)`;\n    for (let b = 2; b < rank - 1; b++) {\n      params = `int b${b}, ` + params;\n      texelsInBatch *= shape[rank - b - 1];\n      index = `b${b} * ${texelsInBatch} + ` + index;\n    }\n    const packedSampler = `vec4 ${funcName}(${params}) {\n      int index = ${index};\n      int texR = index / ${texNumC};\n      int texC = index - texR * ${texNumC};\n      vec2 uv = (vec2(texC, texR) + halfCR) / vec2(${texNumC}, ${texNumR});\n      return ${glsl.texture2D}(${name}, uv);\n    }`;\n    const source = packedSampler;\n    return new GlslLibRoutine(source);\n  }\n\n  /**\n   * Unpacked scalar snippet.\n   */\n  protected getUnpackedSamplerScalar(funcName: string, name: string, inputLayout: TextureLayout): GlslLibRoutine {\n    const [texNumR, texNumC] = [inputLayout.width, inputLayout.height];\n    if (texNumR === 1 && texNumC === 1) {\n      const source = `\n          float ${funcName}() {\n            return sampleTexture(${name}, halfCR);\n          }\n        `;\n      return new GlslLibRoutine(source, ['coordinates.sampleTexture']);\n    }\n\n    const source = `\n        float ${funcName}() {\n          int offset_${name} = coordsToOffset(TexCoords, ${texNumR}, ${texNumC});\n          vec2 uv = uvFromFlat(${texNumR}, ${texNumC}, offset_${name});\n          return sampleTexture(${name}, uv);\n        }\n      `;\n    return new GlslLibRoutine(source, [\n      'coordinates.uvFromFlat',\n      'coordinates.sampleTexture',\n      'coordinates.coordsToOffset',\n    ]);\n  }\n\n  /**\n   * Unpacked 1D snippet.\n   */\n  protected getUnpackedSampler1D(funcName: string, name: string, inputLayout: TextureLayout): GlslLibRoutine {\n    const tNumR = inputLayout.width;\n    const tNumC = inputLayout.height;\n\n    if (tNumC === 1 && tNumR === 1) {\n      const source = `\n        float ${funcName}(int index) {\n          return sampleTexture(${name}, halfCR);\n        }\n      `;\n      return new GlslLibRoutine(source, ['coordinates.sampleTexture']);\n    }\n\n    if (tNumC === 1) {\n      const source = `\n          float ${funcName}(int index) {\n            vec2 uv = vec2((float(index) + 0.5) / ${tNumR}.0, 0.5);\n            return sampleTexture(${name}, uv);\n          }\n        `;\n      return new GlslLibRoutine(source, ['coordinates.sampleTexture']);\n    }\n    if (tNumR === 1) {\n      const source = `\n          float ${funcName}(int index) {\n            vec2 uv = vec2(0.5, (float(index) + 0.5) / ${tNumC}.0);\n            return sampleTexture(${name}, uv);\n          }\n        `;\n      return new GlslLibRoutine(source, ['coordinates.sampleTexture']);\n    }\n    const source = `\n        float ${funcName}(int index) {\n          vec2 uv = uvFromFlat(${tNumR}, ${tNumC}, index);\n          return sampleTexture(${name}, uv);\n        }\n      `;\n    return new GlslLibRoutine(source, ['coordinates.uvFromFlat', 'coordinates.sampleTexture']);\n  }\n\n  /**\n   * Unpacked 2D snippet.\n   */\n\n  protected getUnpackedSampler2D(funcName: string, name: string, inputLayout: TextureLayout): GlslLibRoutine {\n    const shape = inputLayout.unpackedShape;\n\n    // TODO: modify row/col order for other dimensions.\n    const texShape = [inputLayout.height, inputLayout.width];\n\n    if (texShape != null && ArrayUtil.arraysEqual(shape, texShape)) {\n      const texNumR = texShape[1];\n      const texNumC = texShape[0];\n      const source = `\n          float ${funcName}(int row, int col) {\n            vec2 uv = (vec2(row, col) + halfCR) / vec2(${texNumR}.0, ${texNumC}.0);\n            return sampleTexture(${name}, uv);\n          }\n        `;\n      return new GlslLibRoutine(source, ['coordinates.sampleTexture']);\n    }\n\n    const { newShape, keptDims } = squeezeShape(shape as number[]);\n    const squeezedShape = newShape;\n    if (squeezedShape.length < shape.length) {\n      const newInputShape = squeezeInputShape(shape, squeezedShape);\n      // Deep copy of input texture layout.\n      const newInputLayout: TextureLayout = JSON.parse(JSON.stringify(inputLayout));\n      newInputLayout.unpackedShape = newInputShape;\n\n      const params = ['col', 'row'];\n      const source = `\n          ${this.getUnpackedSamplerFromInput(funcName, name, newInputLayout).routineBody}\n          float ${funcName}(int row, int col) {\n            return ${funcName}(${getSqueezedParams(params, keptDims)});\n          }\n        `;\n      return new GlslLibRoutine(source, ['coordinates.sampleTexture']);\n    }\n\n    const texNumR = texShape[1];\n    const texNumC = texShape[0];\n    if (texNumC === 1) {\n      const source = `\n          float ${funcName}(int row, int col) {\n            int offset_${name} = coordsToOffset(TexCoords, ${texNumR}, ${texNumC});\n            float index = dot(vec3(row, col, offset_${name}), vec3(${shape[1]}, 1, 1));\n            vec2 uv = vec2(0.5, (index + 0.5) / ${texNumR}.0);\n            return sampleTexture(${name}, uv);\n          }\n        `;\n      return new GlslLibRoutine(source, ['coordinates.sampleTexture', 'coordinates.coordsToOffset']);\n    }\n\n    if (texNumR === 1) {\n      const source = `\n          float ${funcName}(int row, int col) {\n            int offset_${name} = coordsToOffset(TexCoords, ${texNumR}, ${texNumC});\n            float index = dot(vec3(row, col, offset_${name}), vec3(${shape[1]}, 1, 1));\n            vec2 uv = vec2((index + 0.5) / ${texNumC}.0, 0.5);\n            return sampleTexture(${name}, uv);\n          }\n        `;\n      return new GlslLibRoutine(source, ['coordinates.sampleTexture', 'coordinates.coordsToOffset']);\n    }\n\n    const source = `\n        float ${funcName}(int row, int col) {\n          int index = col * ${shape[1]} + row;\n          vec2 uv = uvFromFlat(${texNumR}, ${texNumC}, index);\n          return sampleTexture(${name}, uv);\n        }\n      `;\n    return new GlslLibRoutine(source, [\n      'coordinates.uvFromFlat',\n      'coordinates.sampleTexture',\n      'coordinates.coordsToOffset',\n    ]);\n  }\n\n  /**\n   * Unpacked 3D snippet.\n   */\n\n  protected getUnpackedSampler3D(funcName: string, name: string, inputLayout: TextureLayout): GlslLibRoutine {\n    const shape = inputLayout.unpackedShape;\n    const stride0 = shape[1] * shape[2];\n    const stride1 = shape[2];\n\n    const { newShape, keptDims } = squeezeShape(shape as number[]);\n    const squeezedShape = newShape;\n    if (squeezedShape.length < shape.length) {\n      const newInputShape = squeezeInputShape(shape, squeezedShape);\n      const params = ['batch', 'col', 'row'];\n      // Deep copy of input texture layout.\n      const newInputLayout: TextureLayout = JSON.parse(JSON.stringify(inputLayout));\n      newInputLayout.unpackedShape = newInputShape;\n      const routine = this.getUnpackedSamplerFromInput(funcName, name, newInputLayout);\n      // TODO: revisit the logic here to make it simpler\n      const revDims = keptDims.reverse();\n      const source = `\n          ${routine.routineBody}\n          float ${funcName}(int batch, int row, int col) {\n            return ${funcName}(${getSqueezedParams(params, revDims)});\n          }\n        `;\n      return new GlslLibRoutine(source, routine.dependencies);\n    }\n\n    const texNumR = inputLayout.width;\n    const texNumC = inputLayout.height;\n    const source = `\n          float ${funcName}(int depth, int row, int col) {\n            // Explicitly use integer operations as dot() only works on floats.\n            int index = depth * ${stride0} + col * ${stride1} + row;\n            vec2 uv = uvFromFlat(${texNumR}, ${texNumC}, index);\n            return sampleTexture(${name}, uv);\n          }\n      `;\n    return new GlslLibRoutine(source, [\n      'coordinates.uvFromFlat',\n      'coordinates.sampleTexture',\n      'coordinates.coordsToOffset',\n    ]);\n  }\n\n  /**\n   * Unpacked 4D snippet.\n   */\n\n  protected getUnpackedSampler4D(funcName: string, name: string, inputLayout: TextureLayout): GlslLibRoutine {\n    const shape = inputLayout.unpackedShape;\n    const stride2 = shape[3];\n    const stride1 = shape[2] * stride2;\n    const stride0 = shape[1] * stride1;\n\n    //\n    // TODO: re-enable this shortcut once the index calculation bug is fixed.\n    //\n    // const {newShape, keptDims} = squeezeShape(shape as number[]);\n    // if (newShape.length < shape.length) {\n    //   const newInputShape = squeezeInputShape(shape, newShape);\n    //   const params = ['row', 'col', 'depth', 'depth2'];\n    //   // Deep copy of input texture layout.\n    //   const newInputLayout: TextureLayout = JSON.parse(JSON.stringify(inputLayout));\n    //   newInputLayout.unpackedShape = newInputShape;\n    //   const source = `\n    //       ${this.getUnpackedSamplerFromInput(funcName, name, newInputLayout).routineBody}\n    //       float ${funcName}(int row, int col, int depth, int depth2) {\n    //         return ${funcName}(${getSqueezedParams(params, keptDims)});\n    //       }\n    //     `;\n    //   return new GlslLibRoutine(\n    //       source, ['coordinates.uvFromFlat', 'coordinates.sampleTexture', 'coordinates.coordsToOffset']);\n    // }\n\n    const texNumR = inputLayout.width;\n    const texNumC = inputLayout.height;\n    const source = `\n        float ${funcName}(int row, int col, int depth, int depth2) {\n          int index = row * ${stride0} + col * ${stride1} +\n              depth2 * ${stride2} + depth;\n          vec2 uv = uvFromFlat(${texNumR}, ${texNumC}, index);\n          return sampleTexture(${name}, uv);\n        }\n      `;\n    return new GlslLibRoutine(source, ['coordinates.uvFromFlat', 'coordinates.sampleTexture']);\n  }\n\n  /**\n   * Unpacked 5D snippet.\n   */\n  protected getUnpackedSampler5D(funcName: string, name: string, inputLayout: TextureLayout): GlslLibRoutine {\n    const shape = inputLayout.unpackedShape;\n    const stride3 = shape[4];\n    const stride2 = shape[3] * stride3;\n    const stride1 = shape[2] * stride2;\n    const stride0 = shape[1] * stride1;\n\n    const { newShape, keptDims } = squeezeShape(shape as number[]);\n    if (newShape.length < shape.length) {\n      const newInputShape = squeezeInputShape(shape, newShape);\n      const params = ['row', 'col', 'depth', 'depth2', 'depth3'];\n      // Deep copy of input texture layout.\n      const newInputLayout: TextureLayout = JSON.parse(JSON.stringify(inputLayout));\n      newInputLayout.unpackedShape = newInputShape;\n\n      const source = `\n          ${this.getUnpackedSamplerFromInput(funcName, name, newInputLayout).routineBody}\n          float ${funcName}(int row, int col, int depth, int depth2, int depth3) {\n            return ${funcName}(${getSqueezedParams(params, keptDims)});\n          }\n        `;\n      return new GlslLibRoutine(source, ['coordinates.sampleTexture', 'coordinates.uvFromFlat']);\n    }\n\n    const texNumR = inputLayout.width;\n    const texNumC = inputLayout.height;\n    const source = `\n        float ${funcName}(int row, int col, int depth, int depth2, int depth3) {\n          int index = row * ${stride0} + col * ${stride1} + depth * ${stride2} +\n          depth3 * ${stride3} + depth2;\n          vec2 uv = uvFromFlat(${texNumR}, ${texNumC}, index);\n          return sampleTexture(${name}, uv);\n        }\n      `;\n    return new GlslLibRoutine(source, ['coordinates.sampleTexture', 'coordinates.uvFromFlat']);\n  }\n\n  /**\n   * Unpacked 6D snippet.\n   */\n  protected getUnpackedSampler6D(funcName: string, name: string, inputLayout: TextureLayout): GlslLibRoutine {\n    const shape = inputLayout.unpackedShape;\n    const stride4 = shape[5];\n    const stride3 = shape[4] * stride4;\n    const stride2 = shape[3] * stride3;\n    const stride1 = shape[2] * stride2;\n    const stride0 = shape[1] * stride1;\n\n    const { newShape, keptDims } = squeezeShape(shape as number[]);\n    if (newShape.length < shape.length) {\n      const newInputShape = squeezeInputShape(shape, newShape);\n      const params = ['row', 'col', 'depth', 'depth2', 'depth3', 'depth4'];\n      // Deep copy of input texture layout.\n      const newInputLayout: TextureLayout = JSON.parse(JSON.stringify(inputLayout));\n      newInputLayout.unpackedShape = newInputShape;\n\n      const source = `\n            ${this.getUnpackedSamplerFromInput(funcName, name, newInputLayout).routineBody}\n            float ${funcName}(int row, int col, int depth,\n              int depth2, int depth3, int depth4) {\n              return ${funcName}(${getSqueezedParams(params, keptDims)});\n            }\n          `;\n      return new GlslLibRoutine(source, ['coordinates.sampleTexture', 'coordinates.uvFromFlat']);\n    }\n\n    const texNumR = inputLayout.width;\n    const texNumC = inputLayout.height;\n    const source = `\n          float ${funcName}(int row, int col, int depth,\n            int depth2, int depth3, int depth4) {\n            int index = row * ${stride0} + col * ${stride1} + depth * ${stride2} +\n            depth2 * ${stride3} + depth3 * ${stride4} + depth4;\n            vec2 uv = uvFromFlat(${texNumR}, ${texNumC}, index);\n            return sampleTexture(${name}, uv);\n          }\n        `;\n    return new GlslLibRoutine(source, [\n      'coordinates.uvFromFlat',\n      'coordinates.sampleTexture',\n      'coordinates.coordsToOffset',\n    ]);\n  }\n\n  /**\n   * This is the main function to map from the given texture coordinates (s,t)\n   * to logical indices for the output\n   * There will only be one single variation of this\n   * Also see coordsToOffset and offsetToIndices for input-specific versions\n   */\n  protected toVec(): { [name: string]: GlslLibRoutine } {\n    const output = this.context.outputTextureLayout;\n    const rank = output.shape.length;\n    const strides = output.strides;\n    const xScale = output.width;\n    const yScale = output.height;\n\n    const stridesBlock = [];\n    for (let i = 0; i < rank - 1; ++i) {\n      stridesBlock.push(`\n        c[${i}] = offset / ${strides[i]};`);\n      stridesBlock.push(`\n        offset -= c[${i}] * ${strides[i]};`);\n    }\n    stridesBlock.push(`\n        c[${rank - 1}] = offset;`);\n    const body = `\n      void toVec(vec2 texCoords, out int c[${rank}]) {\n        int offset = coordsToOffset(texCoords, ${xScale}, ${yScale});\n        ${stridesBlock.join('')}\n      }\n      void toVec(int offset, out int c[${rank}]) {\n        ${stridesBlock.join('')}\n      }\n    `;\n    return { toVec: new GlslLibRoutine(body, ['coordinates.coordsToOffset']) };\n  }\n  /**\n   * These are value getter functions generated for each input\n   * Each function is hardwired to the name and dimensions of the input\n   * An '_T' variation is also produced which accesses values as if the\n   * input was transposed\n   */\n  protected valueFrom(): { [name: string]: GlslLibRoutine } {\n    const result: { [name: string]: GlslLibRoutine } = {};\n    this.context.programInfo.inputNames.forEach((name, i) => {\n      const layout = this.context.inputTextureLayouts[i];\n      const shape = layout.unpackedShape.length > 0 ? layout.unpackedShape : layout.shape;\n      const rank = shape.length;\n      let funcName = `_${name}`;\n      result[funcName] = new GlslLibRoutine(this.getValueFromSingle(name, rank, layout.width, layout.height, false), [\n        `shapeUtils.indicesToOffset${funcName}`,\n        'coordinates.offsetToCoords',\n        'fragcolor.getColorAsFloat',\n      ]);\n      funcName = funcName + '_T';\n      result[funcName] = new GlslLibRoutine(this.getValueFromSingle(name, rank, layout.width, layout.height, true), [\n        `shapeUtils.indicesToOffset${funcName}`,\n        'coordinates.offsetToCoords',\n        'fragcolor.getColorAsFloat',\n      ]);\n    });\n    return result;\n  }\n  /**\n   * Produces one value getter function for the name and rank given\n   * If a transpose is set proper offsetToCoords mapping will be used\n   * @param name name of the function\n   * @param rank rank of the input\n   * @param transpose whether or not should generate a transpose variation\n   */\n  protected getValueFromSingle(\n    varName: string,\n    rank: number,\n    width: number,\n    height: number,\n    transpose: boolean,\n  ): string {\n    let name = `_${varName}`;\n    if (transpose) {\n      name = name + '_T';\n    }\n    const glsl = getGlsl(this.context.glContext.version);\n    return `\n        float ${name}(int m[${rank}]) {\n          int offset = indicesToOffset${name}(m);\n          vec2 coords = offsetToCoords(offset, ${width}, ${height});\n          float value = getColorAsFloat(${glsl.texture2D}(${varName}, coords));\n          return value;\n        }\n        `;\n  }\n\n  /**\n   * Produces a packed value getter function for the name and rank given\n   * If a transpose is set proper offsetToCoords mapping will be used\n   * @param name name of the function\n   * @param rank rank of the input\n   * @param transpose whether or not should generate a transpose variation\n   */\n  protected getPackedValueFrom(\n    varName: string,\n    rank: number,\n    width: number,\n    height: number,\n    transpose: boolean,\n  ): string {\n    let name = `_${varName}_Pack`;\n    if (transpose) {\n      name = name + '_T';\n    }\n    const glsl = getGlsl(this.context.glContext.version);\n    return `\n        vec4 ${name}(int m[${rank}]) {\n          int offset = indicesToOffset_${varName}(m);\n          vec2 coords = offsetToCoords(offset, ${width}, ${height});\n          return ${glsl.texture2D}(${varName}, coords);\n        }\n        `;\n  }\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { GlslContext, GlslLib, GlslLibRoutine } from './glsl-definitions';\n\n/**\n * This GLSL library handles routines converting\n * float32 to/from Unsigned byte or float 16\n */\nexport class EncodingGlslLib extends GlslLib {\n  constructor(context: GlslContext) {\n    super(context);\n  }\n  getFunctions(): { [name: string]: GlslLibRoutine } {\n    return { ...this.encodeFloat32(), ...this.decodeFloat32() };\n  }\n  getCustomTypes(): { [name: string]: string } {\n    return {};\n  }\n  protected encodeFloat32(): { [name: string]: GlslLibRoutine } {\n    return {\n      encode: new GlslLibRoutine(`highp vec4 encode(highp float f) {\n        return vec4(f, 0.0, 0.0, 0.0);\n      }\n        `),\n    };\n  }\n  protected decodeFloat32(): { [name: string]: GlslLibRoutine } {\n    return {\n      decode: new GlslLibRoutine(`highp float decode(highp vec4 rgba) {\n        return rgba.r;\n      }\n        `),\n    };\n  }\n  /**\n   * returns the routine to encode encode a 32bit float to a vec4 (of unsigned bytes)\n   * @credit: https://stackoverflow.com/questions/7059962/how-do-i-convert-a-vec4-rgba-value-to-a-float\n   */\n  protected encodeUint8(): { [name: string]: GlslLibRoutine } {\n    const endianness = EncodingGlslLib.isLittleEndian() ? 'rgba.rgba=rgba.abgr;' : '';\n    return {\n      encode: new GlslLibRoutine(`\n      highp vec4 encode(highp float f) {\n        highp float F = abs(f);\n        highp float Sign = step(0.0,-f);\n        highp float Exponent = floor(log2(F));\n        highp float Mantissa = (exp2(- Exponent) * F);\n        Exponent = floor(log2(F) + 127.0) + floor(log2(Mantissa));\n        highp vec4 rgba;\n        rgba[0] = 128.0 * Sign  + floor(Exponent*exp2(-1.0));\n        rgba[1] = 128.0 * mod(Exponent,2.0) + mod(floor(Mantissa*128.0),128.0);\n        rgba[2] = floor(mod(floor(Mantissa*exp2(23.0 -8.0)),exp2(8.0)));\n        rgba[3] = floor(exp2(23.0)*mod(Mantissa,exp2(-15.0)));\n        ${endianness}\n        rgba = rgba / 255.0; // values need to be normalized to [0,1]\n        return rgba;\n    }\n        `),\n    };\n  }\n  /**\n   * returns the routine to encode a vec4 of unsigned bytes to float32\n   * @credit: https://stackoverflow.com/questions/7059962/how-do-i-convert-a-vec4-rgba-value-to-a-float\n   */\n  protected decodeUint8(): { [name: string]: GlslLibRoutine } {\n    const endianness = EncodingGlslLib.isLittleEndian() ? 'rgba.rgba=rgba.abgr;' : '';\n    return {\n      decode: new GlslLibRoutine(`\n        highp float decode(highp vec4 rgba) {\n          rgba = rgba * 255.0; // values need to be de-normalized from [0,1] to [0,255]\n          ${endianness}\n          highp float Sign = 1.0 - step(128.0,rgba[0])*2.0;\n          highp float Exponent = 2.0 * mod(rgba[0],128.0) + step(128.0,rgba[1]) - 127.0;\n          highp float Mantissa = mod(rgba[1],128.0)*65536.0 + rgba[2]*256.0 +rgba[3] + float(0x800000);\n          highp float Result =  Sign * exp2(Exponent) * (Mantissa * exp2(-23.0 ));\n          return Result;\n      }\n        `),\n    };\n  }\n  /**\n   * Determines if the machine is little endian or not\n   * @credit: https://gist.github.com/TooTallNate/4750953\n   */\n  static isLittleEndian(): boolean {\n    const b = new ArrayBuffer(4);\n    const a = new Uint32Array(b);\n    const c = new Uint8Array(b);\n    a[0] = 0xdeadbeef;\n    if (c[0] === 0xef) {\n      return true;\n    }\n    if (c[0] === 0xde) {\n      return false;\n    }\n    throw new Error('unknown endianness');\n  }\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { GlslContext, GlslLib, GlslLibRoutine } from './glsl-definitions';\nimport { getGlsl } from './glsl-source';\n\n/**\n * This GLSL library handles routines around reading a texlet and writing to it\n * Reading and writing could be more than just dealing with one channel\n * It may require encoding/decoding to/from 4 channels into one\n */\nexport class FragColorGlslLib extends GlslLib {\n  constructor(context: GlslContext) {\n    super(context);\n  }\n  getFunctions(): { [name: string]: GlslLibRoutine } {\n    return { ...this.setFragColor(), ...this.getColorAsFloat() };\n  }\n  getCustomTypes(): { [name: string]: string } {\n    return {};\n  }\n  protected setFragColor(): { [name: string]: GlslLibRoutine } {\n    const glsl = getGlsl(this.context.glContext.version);\n    return {\n      setFragColor: new GlslLibRoutine(\n        `\n        void setFragColor(float value) {\n            ${glsl.output} = encode(value);\n        }\n        `,\n        ['encoding.encode'],\n      ),\n    };\n  }\n  protected getColorAsFloat(): { [name: string]: GlslLibRoutine } {\n    return {\n      getColorAsFloat: new GlslLibRoutine(\n        `\n        float getColorAsFloat(vec4 color) {\n            return decode(color);\n        }\n        `,\n        ['encoding.decode'],\n      ),\n    };\n  }\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { GlslContext, GlslLib, GlslLibRoutine } from './glsl-definitions';\n\n/**\n * GLSL Library responsible for data types and routines for manipulating\n * coordinates and mapping to/from tensor indices\n */\nexport class ShapeUtilsGlslLib extends GlslLib {\n  constructor(context: GlslContext) {\n    super(context);\n  }\n  getFunctions(): { [name: string]: GlslLibRoutine } {\n    return {\n      ...this.bcastIndex(),\n      ...this.bcastMatmulIndex(),\n      ...this.offsetToIndices(),\n      ...this.indicesToOffset(),\n      ...this.incrementIndices(),\n    };\n  }\n  getCustomTypes() {\n    return {};\n  }\n  protected bcastIndex(): { [name: string]: GlslLibRoutine } {\n    const outputRank = this.context.outputTextureLayout.shape.length;\n    const result: { [name: string]: GlslLibRoutine } = {};\n    this.context.programInfo.inputNames.forEach((name, i) => {\n      const shape = this.context.inputTextureLayouts[i].unpackedShape;\n      if (shape.length <= outputRank) {\n        const rank = shape.length;\n        const dimOffset = outputRank - rank;\n        const funcName = `bcastIndices_${name}`;\n        let block = '';\n        for (let i = 0; i < rank; ++i) {\n          block += `\n          realIndices[${i}] = int( mod(float(bcastedIndices[${dimOffset + i}]), ${shape[i]}.0) );\n          `;\n        }\n        const body = `\n        void ${funcName} (int bcastedIndices[${outputRank}], out int realIndices[${rank}]) {\n          ${block}\n        }\n        `;\n        result[funcName] = new GlslLibRoutine(body);\n      }\n    });\n    return result;\n  }\n  protected bcastMatmulIndex(): { [name: string]: GlslLibRoutine } {\n    const outputRank = this.context.outputTextureLayout.shape.length;\n    const result: { [name: string]: GlslLibRoutine } = {};\n    this.context.programInfo.inputNames.forEach((name, i) => {\n      const shape = this.context.inputTextureLayouts[i].shape;\n      if (!(shape.length < 2 || shape.length > outputRank)) {\n        const rank = shape.length;\n        const dimOffset = outputRank - rank;\n        const funcName = `bcastMatmulIndices_${name}`;\n        let block = '';\n        for (let i = 0; i < rank - 2; ++i) {\n          block += `\n          realIndices[${i}] = int( mod(float(bcastedIndices[${dimOffset + i}]), ${shape[i]}.0) );\n          `;\n        }\n        const body = `\n        void ${funcName}(int bcastedIndices[${outputRank}], out int realIndices[${rank}]) {\n          ${block}\n          realIndices[${rank - 1}] = bcastedIndices[${outputRank - 1}];\n          realIndices[${rank - 2}] = bcastedIndices[${outputRank - 2}];\n        }\n        `;\n        result[funcName] = new GlslLibRoutine(body);\n      }\n    });\n    return result;\n  }\n  protected indicesToOffset(): { [name: string]: GlslLibRoutine } {\n    const result: { [name: string]: GlslLibRoutine } = {};\n    this.context.programInfo.inputNames.forEach((name, i) => {\n      const shape = this.context.inputTextureLayouts[i].shape;\n      const strides = this.context.inputTextureLayouts[i].strides;\n      const rank = shape.length;\n      let funcName = `indicesToOffset_${name}`;\n      result[funcName] = new GlslLibRoutine(ShapeUtilsGlslLib.indexToOffsetSingle(funcName, rank, strides));\n      funcName = `indicesToOffset_${name}_T`;\n      result[funcName] = new GlslLibRoutine(\n        ShapeUtilsGlslLib.indexToOffsetSingle(funcName, rank, strides.slice().reverse()),\n      );\n    });\n    return result;\n  }\n  static indexToOffsetSingle(name: string, rank: number, strides: readonly number[]): string {\n    let block = '';\n    for (let i = rank - 1; i >= 0; --i) {\n      block += `\n        offset += indices[${i}] * ${strides[i]};\n        `;\n    }\n    return `\n      int ${name}(int indices[${rank}]) {\n        int offset = 0;\n        ${block}\n        return offset;\n      }\n      `;\n  }\n  protected offsetToIndices(): { [name: string]: GlslLibRoutine } {\n    const result: { [name: string]: GlslLibRoutine } = {};\n    this.context.programInfo.inputNames.forEach((name, i) => {\n      const shape = this.context.inputTextureLayouts[i].shape;\n      const strides = this.context.inputTextureLayouts[i].strides;\n      const rank = shape.length;\n      let funcName = `offsetToIndices_${name}`;\n      result[funcName] = new GlslLibRoutine(ShapeUtilsGlslLib.offsetToIndicesSingle(funcName, rank, strides));\n      funcName = `offsetToIndices_${name}_T`;\n      result[funcName] = new GlslLibRoutine(\n        ShapeUtilsGlslLib.offsetToIndicesSingle(funcName, rank, strides.slice().reverse()),\n      );\n    });\n    return result;\n  }\n  static offsetToIndicesSingle(name: string, rank: number, strides: readonly number[]): string {\n    const stridesBlock = [];\n    for (let i = 0; i < rank - 1; ++i) {\n      stridesBlock.push(`\n      indices[${i}] = offset / ${strides[i]};`);\n      stridesBlock.push(`\n        offset -= indices[${i}] * ${strides[i]};`);\n    }\n    stridesBlock.push(`\n      indices[${rank - 1}] = offset;`);\n    return `\n      void ${name}(int offset, out int indices[${rank}]) {\n        ${stridesBlock.join('')}\n      }\n      `;\n  }\n  protected incrementIndices(): { [name: string]: GlslLibRoutine } {\n    const result: { [name: string]: GlslLibRoutine } = {};\n    this.context.programInfo.inputNames.forEach((name, i) => {\n      const shape = this.context.inputTextureLayouts[i].shape;\n      const rank = shape.length;\n      const funcName = `incrementIndices_${name}`;\n      let shapeInit = '';\n      for (let i = 0; i < rank; ++i) {\n        shapeInit += `\n        shape[${i}] = ${shape[i]};`;\n      }\n      const body = `\n        void ${funcName}(int axis, out int indices[${rank}]) {\n          int shape[${rank}];\n          ${shapeInit};\n          for(int i = ${rank} -1 ; i >= 0; --i) {\n            if(i > axis) continue;\n            indices[i] += 1;\n            if(indices[i] < shape[i]) {\n              break;\n            }\n            indices[i] = 0;\n          }\n        }\n        `;\n      result[funcName] = new GlslLibRoutine(body);\n    });\n    return result;\n  }\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { GlslContext, GlslLib, GlslLibRoutine } from './glsl-definitions';\n\n/**\n * GLSL Library responsible for vec routines\n * Vec is an variable length int array. The length is fixed at the time of\n * generating the library functions from the dimensions of the output.\n */\nexport class VecGlslLib extends GlslLib {\n  constructor(context: GlslContext) {\n    super(context);\n  }\n  getCustomTypes(): { [name: string]: string } {\n    return {};\n  }\n  getFunctions(): { [name: string]: GlslLibRoutine } {\n    return { ...this.binaryVecFunctions(), ...this.copyVec(), ...this.setVecItem(), ...this.getVecItem() };\n  }\n  protected binaryVecFunctions(): { [name: string]: GlslLibRoutine } {\n    const outputLayout = this.context.outputTextureLayout;\n    const rank = outputLayout.shape.length;\n    const nameOp: { [name: string]: string } = { add: '+=', sub: '-=', mul: '*=', div: '/=' };\n    const result: { [name: string]: GlslLibRoutine } = {};\n    for (const name in nameOp) {\n      const fname = `${name}Vec`;\n      let assignmentBlock = '';\n      for (let i = 0; i < rank; ++i) {\n        assignmentBlock += `\n          dest[${i}] ${nameOp[name]} src[${i}];\n          `;\n      }\n      const body = `\n        void ${fname}(int src[${rank}], out int dest[${rank}]) {\n          ${assignmentBlock}\n        }\n        `;\n      result[fname] = new GlslLibRoutine(body);\n    }\n\n    return result;\n  }\n  protected copyVec(): { [name: string]: GlslLibRoutine } {\n    const outputLayout = this.context.outputTextureLayout;\n    const rank = outputLayout.shape.length;\n    let assignmentBlock = '';\n    for (let i = 0; i < rank; ++i) {\n      assignmentBlock += `\n        dest[${i}] = src[${i}];\n        `;\n    }\n    const body = `\n      void copyVec(int src[${rank}], out int dest[${rank}]) {\n        ${assignmentBlock}\n      }\n      `;\n    return { copyVec: new GlslLibRoutine(body) };\n  }\n\n  protected setVecItem(): { [name: string]: GlslLibRoutine } {\n    const outputLayout = this.context.outputTextureLayout;\n    const rank = outputLayout.shape.length;\n    let block = `\n        if(index < 0)\n            index =${rank} + index;\n        if (index == 0)\n            m[0] = value;\n        `;\n    for (let i = 1; i < rank - 1; ++i) {\n      block += `\n        else if (index == ${i})\n            m[${i}] = value;\n            `;\n    }\n    block += `\n        else\n            m[${rank - 1}] = value;\n        `;\n    const body = `\n      void setVecItem(out int m[${rank}], int index, int value) {\n        ${block}\n      }\n        `;\n    return { setVecItem: new GlslLibRoutine(body) };\n  }\n  protected getVecItem(): { [name: string]: GlslLibRoutine } {\n    const outputLayout = this.context.outputTextureLayout;\n    const rank = outputLayout.shape.length;\n    let block = `\n        if(index < 0)\n            index = ${rank} + index;\n        if (index == 0)\n            return m[0];\n      `;\n    for (let i = 1; i < rank - 1; ++i) {\n      block += `\n        else if (index == ${i})\n            return m[${i}];\n      `;\n    }\n    block += `\n        else\n            return m[${rank - 1}];\n        `;\n    const body = `\n      int getVecItem(int m[${rank}], int index) {\n        ${block}\n      }\n    `;\n    return { getVecItem: new GlslLibRoutine(body) };\n  }\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { CoordsGlslLib } from './glsl-coordinate-lib';\nimport { GlslContext, GlslLib } from './glsl-definitions';\nimport { EncodingGlslLib } from './glsl-encoding-lib';\nimport { FragColorGlslLib } from './glsl-fragcolor-lib';\nimport { ShapeUtilsGlslLib } from './glsl-shape-utils-lib';\nimport { VecGlslLib } from './glsl-vec-lib';\n\nexport const glslRegistry: { [name: string]: new (context: GlslContext) => GlslLib } = {\n  encoding: EncodingGlslLib,\n  fragcolor: FragColorGlslLib,\n  vec: VecGlslLib,\n  shapeUtils: ShapeUtilsGlslLib,\n  coordinates: CoordsGlslLib,\n  //  'arrays': ArrayGlslSLib\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { GlslContext, GlslLib, GlslLibRoutineNode, TopologicalSortGlslRoutines } from './glsl-definitions';\nimport { replaceInlines } from './glsl-function-inliner';\nimport { glslRegistry } from './glsl-registered-libs';\nimport { getDefaultFragShaderMain, getFragShaderPreamble } from './glsl-source';\nimport { ProgramInfo, TextureLayout, VariableInfo } from './types';\nimport { WebGLContext } from './webgl-context';\n\n/**\n * Preprocessor for the additions to the GLSL language\n * It deals with:\n *  @include directives\n *  @inline\n *  Loop unrolling (not implemented)\n *  Macro resolution (not implemented)\n */\nexport class GlslPreprocessor {\n  readonly context: GlslContext;\n  readonly libs: { [name: string]: GlslLib } = {};\n  readonly glslLibRoutineDependencyGraph: { [routineName: string]: GlslLibRoutineNode } = {};\n\n  constructor(\n    glContext: WebGLContext,\n    programInfo: ProgramInfo,\n    inputTextureLayouts: TextureLayout[],\n    outputTextureLayout: TextureLayout,\n  ) {\n    this.context = new GlslContext(glContext, programInfo, inputTextureLayouts, outputTextureLayout);\n\n    // construct GlslLibs\n    Object.keys(glslRegistry).forEach((name: string) => {\n      const lib = new glslRegistry[name](this.context);\n      this.libs[name] = lib;\n    });\n\n    // construct GlslRoutineDependencyGraph\n    const map = this.glslLibRoutineDependencyGraph;\n    for (const libName in this.libs) {\n      const lib = this.libs[libName];\n      const routinesInLib = lib.getFunctions();\n      for (const routine in routinesInLib) {\n        const key = libName + '.' + routine;\n        let currentNode: GlslLibRoutineNode;\n        if (map[key]) {\n          currentNode = map[key];\n          currentNode.routineBody = routinesInLib[routine].routineBody;\n        } else {\n          currentNode = new GlslLibRoutineNode(key, routinesInLib[routine].routineBody);\n          map[key] = currentNode;\n        }\n        const dependencies = routinesInLib[routine].dependencies;\n        if (dependencies) {\n          for (let i = 0; i < dependencies.length; ++i) {\n            if (!map[dependencies[i]]) {\n              const node = new GlslLibRoutineNode(dependencies[i]);\n              map[dependencies[i]] = node;\n              currentNode.addDependency(node);\n            } else {\n              currentNode.addDependency(map[dependencies[i]]);\n            }\n          }\n        }\n      }\n    }\n  }\n\n  preprocess(): string {\n    const programInfo = this.context.programInfo;\n    let source = programInfo.shaderSource;\n\n    // append main() function\n    if (!this.context.programInfo.hasMain) {\n      source = `${source}\n      ${getDefaultFragShaderMain(this.context.glContext.version, this.context.outputTextureLayout.shape.length)}`;\n    }\n    // replace inlines\n    source = replaceInlines(source);\n\n    // concat final source string\n    return `${getFragShaderPreamble(this.context.glContext.version)}\n    ${this.getUniforms(programInfo.inputNames, programInfo.variables)}\n    ${this.getImports(source)}\n    ${source}`;\n  }\n\n  protected getImports(script: string): string {\n    const routinesIncluded = this.selectGlslLibRoutinesToBeIncluded(script);\n\n    if (routinesIncluded.length === 0) {\n      return '';\n    }\n\n    let routines = '';\n    for (let i = 0; i < routinesIncluded.length; ++i) {\n      if (routinesIncluded[i].routineBody) {\n        routines += routinesIncluded[i].routineBody + '\\n';\n      } else {\n        throw new Error(`Missing body for the Glsl Library routine: ${routinesIncluded[i].name}`);\n      }\n    }\n\n    return routines;\n  }\n  private selectGlslLibRoutinesToBeIncluded(script: string): GlslLibRoutineNode[] {\n    const nodes: GlslLibRoutineNode[] = [];\n\n    Object.keys(this.glslLibRoutineDependencyGraph).forEach((classAndRoutine) => {\n      const routine = classAndRoutine.split('.')[1];\n      if (script.indexOf(routine) !== -1) {\n        nodes.push(this.glslLibRoutineDependencyGraph[classAndRoutine]);\n      }\n    });\n\n    return TopologicalSortGlslRoutines.returnOrderedNodes(nodes);\n  }\n\n  protected getUniforms(samplers?: string[], variables?: VariableInfo[]): string {\n    const uniformLines: string[] = [];\n    if (samplers) {\n      for (const sampler of samplers) {\n        uniformLines.push(`uniform sampler2D ${sampler};`);\n      }\n    }\n    if (variables) {\n      for (const variable of variables) {\n        uniformLines.push(\n          `uniform ${variable.type} ${variable.name}${variable.arrayLength ? `[${variable.arrayLength}]` : ''};`,\n        );\n      }\n    }\n    return uniformLines.join('\\n');\n  }\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { env } from 'onnxruntime-common';\n\nimport { Logger, Profiler } from '../../instrument';\n\nimport { GlslPreprocessor } from './glsl-preprocessor';\nimport { getVertexShaderSource } from './glsl-source';\nimport { TextureLayoutStrategy } from './texture-layout-strategy';\nimport { Artifact, ProgramInfo, ProgramVariable, TextureData, TextureLayout, VariableInfo } from './types';\nimport { WebGLContext } from './webgl-context';\n\n/**\n * ProgramManager is the main class behind running computations\n * It builds ProgramInfo's into Artifacts\n * It compiles given ProgramInfo's into WebGL Prorams (cached as Artifacts)\n * Uses the artifact to run the computation by calling Draw on\n * the WebGL drawing buffer\n * ProgramManager automatically maps (binds) input variables to their\n * corresponding Location's in the binary program\n */\nexport class ProgramManager {\n  repo: Map<unknown, Artifact>; // this should be per-session object\n  vertexShader: WebGLShader;\n  attributesBound: boolean;\n\n  constructor(\n    public profiler: Readonly<Profiler>,\n    public glContext: WebGLContext,\n    public textureLayoutStrategy: TextureLayoutStrategy,\n  ) {\n    this.repo = new Map();\n    this.attributesBound = false;\n  }\n  getArtifact(key: unknown): Artifact | undefined {\n    return this.repo.get(key);\n  }\n  setArtifact(key: unknown, artifact: Artifact): void {\n    this.repo.set(key, artifact);\n  }\n  run(buildArtifact: Artifact, inputs: TextureData[], output: TextureData): void {\n    this.profiler.event(\n      'op',\n      `ProgramManager.run ${buildArtifact.programInfo.name ?? 'unknown kernel'}`,\n      () => {\n        const gl = this.glContext.gl;\n        const program = buildArtifact.program;\n        gl.useProgram(program);\n        try {\n          this.bindOutput(output);\n          if (!this.attributesBound) {\n            this.bindAttributes(buildArtifact.attribLocations);\n          }\n          this.bindUniforms(buildArtifact.uniformLocations, buildArtifact.programInfo.variables ?? [], inputs);\n        } catch (err) {\n          Logger.error('ProgramManager', buildArtifact.programInfo.shaderSource);\n          throw err;\n        }\n        this.profiler.event('backend', 'GlContext.draw()', () => {\n          this.glContext.draw();\n        });\n      },\n      this.glContext,\n    );\n  }\n  dispose(): void {\n    if (this.vertexShader) {\n      this.glContext.deleteShader(this.vertexShader);\n    }\n    this.repo.forEach((a) => this.glContext.deleteProgram(a.program));\n  }\n  build(programInfo: ProgramInfo, inputTextureLayouts: TextureLayout[], outputTextureLayout: TextureLayout): Artifact {\n    return this.profiler.event('backend', 'ProgramManager.build', () => {\n      const preprocessor = new GlslPreprocessor(this.glContext, programInfo, inputTextureLayouts, outputTextureLayout);\n      const fragScript = preprocessor.preprocess();\n      const program = this.compile(fragScript);\n      const artifact = {\n        programInfo,\n        program,\n        uniformLocations: this.getUniformLocations(\n          program,\n          preprocessor.context.programInfo.inputNames,\n          preprocessor.context.programInfo.variables,\n        ),\n        attribLocations: this.getAttribLocations(program),\n      };\n      return artifact;\n    });\n  }\n  protected compile(fragShaderScript: string): WebGLProgram {\n    if (!this.vertexShader) {\n      Logger.verbose('ProrgramManager', 'Compiling and caching Vertex shader for the first time');\n      const vertexShaderScript = getVertexShaderSource(this.glContext.version);\n      this.vertexShader = this.glContext.compileShader(vertexShaderScript, this.glContext.gl.VERTEX_SHADER);\n    }\n    if (env.debug) {\n      Logger.verbose(\n        'ProrgramManager',\n        `FragShader:\n${fragShaderScript}\n`,\n      );\n    }\n    const fragShader = this.glContext.compileShader(fragShaderScript, this.glContext.gl.FRAGMENT_SHADER);\n    const program = this.glContext.createProgram(this.vertexShader, fragShader);\n    this.glContext.deleteShader(fragShader);\n    return program;\n  }\n  bindOutput(td: TextureData): void {\n    const width = td.width;\n    const height = td.height;\n    Logger.verbose(\n      'ProrgramManager',\n      `Binding output texture to Framebuffer: w/h=${width}/${height}, shape=${td.shape}, type=${td.tensor.type}`,\n    );\n    this.glContext.attachFramebuffer(td.texture, width, height);\n  }\n  bindAttributes(attribLocations: Artifact.AttribLocations): void {\n    const positionHandle = attribLocations.position;\n    const textureCoordHandle = attribLocations.textureCoord;\n    this.glContext.setVertexAttributes(positionHandle, textureCoordHandle);\n    this.attributesBound = true;\n  }\n  bindUniforms(\n    uniformLocations: Artifact.UniformLocations,\n    variables: ProgramVariable[],\n    textures: TextureData[],\n  ): void {\n    const gl = this.glContext.gl;\n    let texturePosition = 0;\n    for (const { name, type, location, arrayLength } of uniformLocations) {\n      const value = variables.find((v) => v.name === name)?.data;\n      if (type !== 'sampler2D' && !value) {\n        throw new Error(`variable '${name}' does not have data defined in program info`);\n      }\n      switch (type) {\n        case 'sampler2D':\n          this.bindTexture(textures[texturePosition], location, texturePosition);\n          texturePosition++;\n          break;\n        case 'float':\n          if (arrayLength) {\n            gl.uniform1fv(location, value as number[]);\n          } else {\n            gl.uniform1f(location, value as number);\n          }\n          break;\n        case 'int':\n          if (arrayLength) {\n            gl.uniform1iv(location, value as number[]);\n          } else {\n            gl.uniform1i(location, value as number);\n          }\n          break;\n        default:\n          throw new Error(`Uniform not implemented: ${type}`);\n      }\n    }\n  }\n  bindTexture(td: TextureData, uniformHandle: WebGLUniformLocation, position: number): void {\n    this.glContext.bindTextureToUniform(td.texture, position, uniformHandle);\n  }\n  getAttribLocations(program: WebGLProgram): Artifact.AttribLocations {\n    return {\n      position: this.getAttribLocation(program, 'position'),\n      textureCoord: this.getAttribLocation(program, 'textureCoord'),\n    };\n  }\n  getUniformLocations(\n    program: WebGLProgram,\n    samplers?: string[],\n    variables?: VariableInfo[],\n  ): Artifact.UniformLocations {\n    const uniformLocations: Artifact.UniformLocations = [];\n    if (samplers) {\n      for (const sampler of samplers) {\n        uniformLocations.push({\n          name: sampler,\n          type: 'sampler2D',\n          location: this.getUniformLocation(program, sampler),\n        });\n      }\n    }\n    if (variables) {\n      for (const variable of variables) {\n        uniformLocations.push({ ...variable, location: this.getUniformLocation(program, variable.name) });\n      }\n    }\n    return uniformLocations;\n  }\n  getUniformLocation(program: WebGLProgram, name: string): WebGLUniformLocation {\n    const gl = this.glContext.gl;\n    const reference = gl.getUniformLocation(program, name);\n    if (reference === null) {\n      throw new Error(`Uniform ${name} not found.`);\n    }\n    return reference;\n  }\n  getAttribLocation(program: WebGLProgram, name: string): number {\n    const gl = this.glContext.gl;\n    const attributeLocation: number = gl.getAttribLocation(program, name);\n    return attributeLocation;\n  }\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Logger, Profiler } from '../../instrument';\nimport { Tensor } from '../../tensor';\n\nimport { Encoder, EncoderUsage } from './texture-data-encoder';\nimport { TextureLayoutStrategy } from './texture-layout-strategy';\nimport { TextureData, TextureLayout } from './types';\nimport { WebGLContext } from './webgl-context';\n\nexport interface TextureManagerConfig {\n  reuseTextures?: boolean;\n}\n\n/**\n * TextureManager is the mainly responsible for caching Textures\n * Textures are cached in 2 levels:\n *   1. the textures which are associated with a dataId (from Tensor)\n *    Caching these is crucial to performance. These are In-use Textures\n *   2. textures which are not in use by any current ProgramInfo/Tensor\n *     These are called Free Textures\n * TextureManager is also used to help creating textures. For this it\n * uses WebGLContext and TextureLayoutStrategy\n */\nexport class TextureManager {\n  private readonly inUseTextures: Map<string, WebGLTexture[]>;\n  private readonly idleTextures: Map<string, WebGLTexture[]>;\n  private readonly textureLookup: Map<WebGLTexture, string>;\n  private readonly pendingRead: Map<Tensor.Id, Array<(arr: Tensor.NumberType) => void>> = new Map();\n\n  constructor(\n    public glContext: WebGLContext,\n    public layoutStrategy: TextureLayoutStrategy,\n    public profiler: Readonly<Profiler>,\n    private config: TextureManagerConfig,\n  ) {\n    if (config.reuseTextures) {\n      this.inUseTextures = new Map();\n      this.idleTextures = new Map();\n      this.textureLookup = new Map();\n    }\n  }\n  createTextureFromLayout(\n    dataType: Tensor.DataType,\n    layout: TextureLayout,\n    data?: Tensor.NumberType,\n    usage?: EncoderUsage,\n  ) {\n    const textureDataType = this.toEncoderType(dataType);\n\n    const encoder = this.glContext.getEncoder(textureDataType, layout.channels || 1, usage);\n    if (layout.isPacked && usage === EncoderUsage.UploadOnly) {\n      throw new Error('not implemented');\n    }\n    const width = layout.width;\n    const height = layout.height;\n\n    let key: string | undefined;\n    let inUseTextures: WebGLTexture[] | undefined;\n    if (this.config.reuseTextures) {\n      key = `${width}x${height}_${encoder.format}_${encoder.internalFormat}_${encoder.textureType}`;\n      inUseTextures = this.inUseTextures.get(key);\n      if (!inUseTextures) {\n        inUseTextures = [];\n        this.inUseTextures.set(key, inUseTextures);\n      }\n\n      const idleTextures = this.idleTextures.get(key);\n      if (idleTextures && idleTextures.length > 0) {\n        const texture = idleTextures.pop()!;\n        inUseTextures.push(texture);\n        if (usage === EncoderUsage.UploadOnly) {\n          this.glContext.updateTexture(texture, width, height, encoder, this.toTextureData(dataType, data)!);\n        }\n        return texture;\n      }\n    }\n\n    Logger.verbose('TextureManager', `Creating new texture of size ${layout.width}x${layout.height}`);\n    const texture = this.glContext.allocateTexture(width, height, encoder, this.toTextureData(dataType, data));\n\n    if (this.config.reuseTextures) {\n      inUseTextures!.push(texture);\n      this.textureLookup.set(texture, key!);\n    }\n    return texture;\n  }\n  readTexture(td: TextureData, dataType: Tensor.DataType, channels?: number): Tensor.NumberType {\n    if (!channels) {\n      channels = 1;\n    }\n    return this.profiler.event('backend', 'TextureManager.readTexture', () => {\n      const dataSize = td.shape.reduce((a, b) => a * b) * channels!;\n      const data = this.glContext.readTexture(\n        td.texture,\n        td.width,\n        td.height,\n        dataSize,\n        this.toEncoderType(dataType),\n        channels!,\n      );\n      return this.toTensorData(dataType, data);\n    });\n  }\n  async readTextureAsync(td: TextureData, dataType: Tensor.DataType, channels?: number): Promise<Tensor.NumberType> {\n    const dataId = td.tensor.dataId;\n    if (!channels) {\n      channels = 1;\n    }\n    if (this.pendingRead.has(dataId)) {\n      const subscribers = this.pendingRead.get(dataId);\n      return new Promise<Tensor.NumberType>((resolve) => subscribers?.push(resolve));\n    }\n    return this.profiler.event('backend', 'TextureManager.readTextureAsync', async () => {\n      this.pendingRead.set(dataId, []);\n      const dataSize = td.shape.reduce((a, b) => a * b) * channels!;\n      // add a fence waiting for the data to be ready\n      await this.glContext.createAndWaitForFence();\n      const data = this.glContext.readTexture(\n        td.texture,\n        td.width,\n        td.height,\n        dataSize,\n        this.toEncoderType(dataType),\n        channels!,\n      );\n      const tensorData = this.toTensorData(dataType, data);\n      const subscribers = this.pendingRead.get(dataId);\n      this.pendingRead.delete(dataId);\n      subscribers?.forEach((resolve) => resolve(tensorData));\n      return tensorData;\n    });\n  }\n  readUint8TextureAsFloat(td: TextureData): Float32Array {\n    return this.profiler.event('backend', 'TextureManager.readUint8TextureAsFloat', () => {\n      const dataSize = td.shape.reduce((a, b) => a * b);\n      const data = this.glContext.readTexture(td.texture, td.width, td.height, dataSize * 4, 'byte', 4);\n      return new Float32Array(data.buffer, data.byteOffset, dataSize);\n    });\n  }\n  releaseTexture(textureData: TextureData, deleteTexture?: boolean): void {\n    let key: string | undefined;\n    if (this.config.reuseTextures) {\n      key = this.textureLookup.get(textureData.texture);\n      if (key) {\n        if (deleteTexture) {\n          this.textureLookup.delete(key);\n        }\n        const inUseTextures = this.inUseTextures.get(key);\n        if (inUseTextures) {\n          const index = inUseTextures.indexOf(textureData.texture);\n          if (index !== -1) {\n            inUseTextures.splice(index, 1);\n            let idleTextures = this.idleTextures.get(key);\n            if (!idleTextures) {\n              idleTextures = [];\n              this.idleTextures.set(key, idleTextures);\n            }\n            idleTextures.push(textureData.texture);\n          }\n        }\n      }\n    }\n\n    if (!key || deleteTexture) {\n      Logger.verbose('TextureManager', `Deleting texture of size ${textureData.width}x${textureData.height}`);\n      this.glContext.deleteTexture(textureData.texture);\n    }\n  }\n  toTensorData(dataType: Tensor.DataType, data: Encoder.DataArrayType): Tensor.NumberType {\n    switch (dataType) {\n      case 'int16':\n        return data instanceof Int16Array ? data : Int16Array.from(data);\n      case 'int32':\n        return data instanceof Int32Array ? data : Int32Array.from(data);\n      case 'int8':\n        return data instanceof Int8Array ? data : Int8Array.from(data);\n      case 'uint16':\n        return data instanceof Uint16Array ? data : Uint16Array.from(data);\n      case 'uint32':\n        return data instanceof Uint32Array ? data : Uint32Array.from(data);\n      case 'uint8':\n      case 'bool':\n        return data instanceof Uint8Array ? data : Uint8Array.from(data);\n      case 'float32':\n        return data instanceof Float32Array ? data : Float32Array.from(data);\n      case 'float64':\n        return data instanceof Float64Array ? data : Float64Array.from(data);\n      default:\n        throw new Error(`TensorData type ${dataType} is not supported`);\n    }\n  }\n  toTextureData(_dataType: Tensor.DataType, data: Tensor.NumberType | undefined): Encoder.DataArrayType | undefined {\n    if (!data) {\n      return undefined;\n    }\n    return data instanceof Float32Array ? data : new Float32Array(data);\n    /*\n    switch (dataType) {\n      case 'int16':\n      case 'int32':\n      case 'uint16':\n      case 'uint32':\n        return (data.constructor === Uint32Array) ? data as Uint32Array : new Uint32Array(data);\n      case 'int8':\n      case 'uint8':\n      case 'bool':\n        return (data.constructor === Uint8Array) ? data as Uint8Array : new Uint8Array(data);\n      case 'float32':\n      case 'float64':\n        return (data.constructor === Float32Array) ? data as Float32Array : new Float32Array(data);\n      default:\n        throw new Error(`TensorData type ${dataType} is not supported`);\n    }\n    */\n  }\n  toEncoderType(_dataType: Tensor.DataType): Encoder.DataType {\n    return 'float';\n    // switch (dataType) {\n    //   case 'int16':\n    //   case 'int32':\n    //   case 'uint16':\n    //   case 'uint32':\n    //     return 'int';\n    //   case 'uint8':\n    //   case 'bool':\n    //     return 'byte';\n    //   case 'float32':\n    //   case 'float64':\n    //     return 'float';\n    //   default:\n    //     throw new Error(`TensorData type ${dataType} is not supported`);\n    // }\n  }\n  clearActiveTextures(): void {\n    this.glContext.clearActiveTextures();\n  }\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { SessionHandler } from '../../backend';\nimport { Graph } from '../../graph';\nimport { Logger } from '../../instrument';\nimport { Operator } from '../../operators';\nimport { OpSet, resolveOperator } from '../../opset';\nimport { Session } from '../../session';\nimport { Tensor } from '../../tensor';\nimport { WebGLBackend } from '../backend-webgl';\n\nimport { WebGLInferenceHandler } from './inference-handler';\nimport { WEBGL_OP_RESOLVE_RULES } from './op-resolve-rules';\nimport { ProgramManager } from './program-manager';\nimport { PreferLogicalStrategy, TextureLayoutStrategy } from './texture-layout-strategy';\nimport { TextureManager } from './texture-manager';\nimport { TextureData } from './types';\n\nexport class WebGLSessionHandler implements SessionHandler {\n  programManager: ProgramManager;\n  textureManager: TextureManager;\n  layoutStrategy: TextureLayoutStrategy;\n  packedTextureDataCache: Map<Tensor.Id, TextureData>;\n  unpackedTextureDataCache: Map<Tensor.Id, TextureData>;\n  pack2unpackMap: Map<Tensor.Id, Tensor.Id>;\n  unpack2packMap: Map<Tensor.Id, Tensor.Id>;\n  initializers: Set<Tensor.Id>;\n  pack?: boolean;\n\n  constructor(\n    public readonly backend: WebGLBackend,\n    public readonly context: Session.Context,\n  ) {\n    this.layoutStrategy = new PreferLogicalStrategy(backend.glContext.maxTextureSize);\n    this.programManager = new ProgramManager(this.context.profiler, backend.glContext, this.layoutStrategy);\n    this.textureManager = new TextureManager(backend.glContext, this.layoutStrategy, this.context.profiler, {\n      reuseTextures: backend.textureCacheMode === 'full',\n    });\n    this.packedTextureDataCache = new Map();\n    this.unpackedTextureDataCache = new Map();\n    this.pack = backend.pack;\n    this.pack2unpackMap = new Map();\n    this.unpack2packMap = new Map();\n  }\n\n  createInferenceHandler() {\n    return new WebGLInferenceHandler(this);\n  }\n  onGraphInitialized(graph: Graph): void {\n    const initializers = graph\n      .getValues()\n      .filter((v) => v.from === -1 && v.tensor)\n      .map((v) => v.tensor!.dataId);\n    this.initializers = new Set(initializers);\n  }\n  isInitializer(tensorId: Tensor.Id): boolean {\n    return this.initializers ? this.initializers.has(tensorId) : false;\n  }\n  addInitializer(tensorId: Tensor.Id): void {\n    this.initializers.add(tensorId);\n  }\n  getTextureData(tensorId: Tensor.Id, isPacked: boolean): TextureData | undefined {\n    if (isPacked) {\n      return this.packedTextureDataCache.get(tensorId);\n    } else {\n      return this.unpackedTextureDataCache.get(tensorId);\n    }\n  }\n  setTextureData(tensorId: Tensor.Id, textureData: TextureData, isPacked = false): void {\n    Logger.verbose('WebGLSessionHandler', 'Storing Texture data in cache');\n    if (isPacked) {\n      this.packedTextureDataCache.set(tensorId, textureData);\n    } else {\n      this.unpackedTextureDataCache.set(tensorId, textureData);\n    }\n  }\n  dispose(): void {\n    this.programManager.dispose();\n    this.textureManager.clearActiveTextures();\n    this.packedTextureDataCache.forEach((td) => this.textureManager.releaseTexture(td, true));\n    this.packedTextureDataCache = new Map();\n    this.unpackedTextureDataCache.forEach((td) => this.textureManager.releaseTexture(td, true));\n    this.unpackedTextureDataCache = new Map();\n  }\n  resolve(node: Graph.Node, opsets: readonly OpSet[], graph: Graph): Operator {\n    const op = resolveOperator(node, opsets, WEBGL_OP_RESOLVE_RULES);\n    return { impl: op.opImpl, context: op.opInit ? op.opInit(node, graph) : node };\n  }\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { env } from 'onnxruntime-common';\n\nimport * as DataEncoders from './texture-data-encoder';\nimport { DataEncoder, Encoder, EncoderUsage } from './texture-data-encoder';\nimport { repeatedTry } from './utils';\n\nexport interface FenceContext {\n  query: WebGLSync | null;\n  isFencePassed(): boolean;\n}\n\ntype PollItem = {\n  isDoneFn: () => boolean;\n  resolveFn: () => void;\n};\n\nexport function linearSearchLastTrue(arr: Array<() => boolean>): number {\n  let i = 0;\n  for (; i < arr.length; ++i) {\n    const isDone = arr[i]();\n    if (!isDone) {\n      break;\n    }\n  }\n  return i - 1;\n}\n\n/**\n * Abstraction and wrapper around WebGLRenderingContext and its operations\n */\nexport class WebGLContext {\n  gl: WebGLRenderingContext;\n  version: 1 | 2;\n\n  private vertexbuffer: WebGLBuffer;\n  private framebuffer: WebGLFramebuffer;\n\n  // WebGL flags and vital parameters\n  private isFloatTextureAttachableToFrameBuffer: boolean;\n  isFloat32DownloadSupported: boolean;\n  isRenderFloat32Supported: boolean;\n  isBlendSupported: boolean;\n  maxTextureSize: number;\n  // private maxCombinedTextureImageUnits: number;\n  private maxTextureImageUnits: number;\n  // private maxCubeMapTextureSize: number;\n  // private shadingLanguageVersion: string;\n  // private webglVendor: string;\n  // private webglVersion: string;\n\n  // WebGL2 flags and vital parameters\n  // private max3DTextureSize: number;\n  // private maxArrayTextureLayers: number;\n  // private maxColorAttachments: number;\n  // private maxDrawBuffers: number;\n\n  // WebGL extensions\n  // eslint-disable-next-line camelcase\n  textureFloatExtension: OES_texture_float | null;\n  // eslint-disable-next-line camelcase\n  textureHalfFloatExtension: OES_texture_half_float | null;\n\n  // WebGL2 extensions\n  colorBufferFloatExtension: unknown | null;\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  disjointTimerQueryWebgl2Extension: { TIME_ELAPSED_EXT: GLenum; GPU_DISJOINT_EXT: GLenum } | null;\n\n  private disposed: boolean;\n  private frameBufferBound = false;\n\n  constructor(gl: WebGLRenderingContext, version: 1 | 2) {\n    this.gl = gl;\n    this.version = version;\n\n    this.getExtensions();\n    this.vertexbuffer = this.createVertexbuffer();\n    this.framebuffer = this.createFramebuffer();\n    this.queryVitalParameters();\n  }\n\n  allocateTexture(width: number, height: number, encoder: DataEncoder, data?: Encoder.DataArrayType): WebGLTexture {\n    const gl = this.gl;\n    // create the texture\n    const texture = gl.createTexture();\n    // bind the texture so the following methods effect this texture.\n    gl.bindTexture(gl.TEXTURE_2D, texture);\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);\n    const buffer = data ? encoder.encode(data, width * height) : null;\n    gl.texImage2D(\n      gl.TEXTURE_2D,\n      0, // Level of detail.\n      encoder.internalFormat,\n      width,\n      height,\n      0, // Always 0 in OpenGL ES.\n      encoder.format,\n      encoder.textureType,\n      buffer,\n    );\n    this.checkError();\n    return texture as WebGLTexture;\n  }\n  updateTexture(\n    texture: WebGLTexture,\n    width: number,\n    height: number,\n    encoder: DataEncoder,\n    data: Encoder.DataArrayType,\n  ): void {\n    const gl = this.gl;\n    gl.bindTexture(gl.TEXTURE_2D, texture);\n    const buffer = encoder.encode(data, width * height);\n    gl.texSubImage2D(\n      gl.TEXTURE_2D,\n      0, // level\n      0, // xoffset\n      0, // yoffset\n      width,\n      height,\n      encoder.format,\n      encoder.textureType,\n      buffer,\n    );\n    this.checkError();\n  }\n  attachFramebuffer(texture: WebGLTexture, width: number, height: number): void {\n    const gl = this.gl;\n    // Make it the target for framebuffer operations - including rendering.\n    gl.bindTexture(gl.TEXTURE_2D, texture);\n    gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);\n    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0); // 0, we aren't using MIPMAPs\n    this.checkError();\n    gl.viewport(0, 0, width, height);\n    gl.scissor(0, 0, width, height);\n  }\n  readTexture(\n    texture: WebGLTexture,\n    width: number,\n    height: number,\n    dataSize: number,\n    dataType: Encoder.DataType,\n    channels: number,\n  ): Encoder.DataArrayType {\n    const gl = this.gl;\n    if (!channels) {\n      channels = 1;\n    }\n    if (!this.frameBufferBound) {\n      this.attachFramebuffer(texture, width, height);\n    }\n    const encoder = this.getEncoder(dataType, channels);\n    const buffer = encoder.allocate(width * height);\n    // bind texture to framebuffer\n    gl.bindTexture(gl.TEXTURE_2D, texture);\n    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0); // 0, we aren't using MIPMAPs\n    // TODO: Check if framebuffer is ready\n    gl.readPixels(0, 0, width, height, gl.RGBA, encoder.textureType, buffer);\n    this.checkError();\n    // unbind FB\n    return encoder.decode(buffer, dataSize);\n  }\n\n  isFramebufferReady(): boolean {\n    // TODO: Implement logic to check if the framebuffer is ready\n    return true;\n  }\n  getActiveTexture(): string {\n    const gl = this.gl;\n    const n = gl.getParameter(this.gl.ACTIVE_TEXTURE);\n    return `TEXTURE${n - gl.TEXTURE0}`;\n  }\n  getTextureBinding(): WebGLTexture {\n    return this.gl.getParameter(this.gl.TEXTURE_BINDING_2D);\n  }\n  getFramebufferBinding(): WebGLFramebuffer {\n    return this.gl.getParameter(this.gl.FRAMEBUFFER_BINDING);\n  }\n  setVertexAttributes(positionHandle: number, textureCoordHandle: number): void {\n    const gl = this.gl;\n    gl.vertexAttribPointer(positionHandle, 3, gl.FLOAT, false, 20, 0);\n    gl.enableVertexAttribArray(positionHandle);\n    if (textureCoordHandle !== -1) {\n      gl.vertexAttribPointer(textureCoordHandle, 2, gl.FLOAT, false, 20, 12);\n      gl.enableVertexAttribArray(textureCoordHandle);\n    }\n    this.checkError();\n  }\n  createProgram(vertexShader: WebGLShader, fragShader: WebGLShader): WebGLProgram {\n    const gl = this.gl;\n    const program = gl.createProgram()!;\n\n    // the program consists of our shaders\n    gl.attachShader(program, vertexShader);\n    gl.attachShader(program, fragShader);\n    gl.linkProgram(program);\n    return program;\n  }\n  compileShader(shaderSource: string, shaderType: number): WebGLShader {\n    const gl = this.gl;\n    const shader = gl.createShader(shaderType);\n    if (!shader) {\n      throw new Error(`createShader() returned null with type ${shaderType}`);\n    }\n\n    gl.shaderSource(shader, shaderSource);\n    gl.compileShader(shader);\n    if (gl.getShaderParameter(shader, gl.COMPILE_STATUS) === false) {\n      throw new Error(`Failed to compile shader: ${gl.getShaderInfoLog(shader)}\nShader source:\n${shaderSource}`);\n    }\n    return shader;\n  }\n  deleteShader(shader: WebGLShader): void {\n    this.gl.deleteShader(shader);\n  }\n  bindTextureToUniform(texture: WebGLTexture, position: number, uniformHandle: WebGLUniformLocation): void {\n    const gl = this.gl;\n    gl.activeTexture(gl.TEXTURE0 + position);\n    this.checkError();\n    gl.bindTexture(gl.TEXTURE_2D, texture);\n    this.checkError();\n    gl.uniform1i(uniformHandle, position);\n    this.checkError();\n  }\n  draw(): void {\n    this.gl.drawArrays(this.gl.TRIANGLE_STRIP, 0, 4);\n    this.checkError();\n  }\n  checkError(): void {\n    if (env.debug) {\n      const gl = this.gl;\n      const error = gl.getError();\n      let label = '';\n      switch (error) {\n        case gl.NO_ERROR:\n          return;\n        case gl.INVALID_ENUM:\n          label = 'INVALID_ENUM';\n          break;\n        case gl.INVALID_VALUE:\n          label = 'INVALID_VALUE';\n          break;\n        case gl.INVALID_OPERATION:\n          label = 'INVALID_OPERATION';\n          break;\n        case gl.INVALID_FRAMEBUFFER_OPERATION:\n          label = 'INVALID_FRAMEBUFFER_OPERATION';\n          break;\n        case gl.OUT_OF_MEMORY:\n          label = 'OUT_OF_MEMORY';\n          break;\n        case gl.CONTEXT_LOST_WEBGL:\n          label = 'CONTEXT_LOST_WEBGL';\n          break;\n        default:\n          label = `Unknown WebGL Error: ${error.toString(16)}`;\n      }\n      throw new Error(label);\n    }\n  }\n  deleteTexture(texture: WebGLTexture): void {\n    this.gl.deleteTexture(texture);\n  }\n  deleteProgram(program: WebGLProgram): void {\n    this.gl.deleteProgram(program);\n  }\n  getEncoder(dataType: Encoder.DataType, channels: number, usage: EncoderUsage = EncoderUsage.Default): DataEncoder {\n    if (this.version === 2) {\n      return new DataEncoders.RedFloat32DataEncoder(this.gl as WebGL2RenderingContext, channels);\n    }\n\n    switch (dataType) {\n      case 'float':\n        if (usage === EncoderUsage.UploadOnly || this.isRenderFloat32Supported) {\n          return new DataEncoders.RGBAFloatDataEncoder(this.gl, channels);\n        } else {\n          return new DataEncoders.RGBAFloatDataEncoder(\n            this.gl,\n            channels,\n            this.textureHalfFloatExtension!.HALF_FLOAT_OES,\n          );\n        }\n      case 'int':\n        throw new Error('not implemented');\n      case 'byte':\n        return new DataEncoders.Uint8DataEncoder(this.gl, channels);\n      default:\n        throw new Error(`Invalid dataType: ${dataType}`);\n    }\n  }\n  clearActiveTextures(): void {\n    const gl = this.gl;\n    for (let unit = 0; unit < this.maxTextureImageUnits; ++unit) {\n      gl.activeTexture(gl.TEXTURE0 + unit);\n      gl.bindTexture(gl.TEXTURE_2D, null);\n    }\n  }\n  dispose(): void {\n    if (this.disposed) {\n      return;\n    }\n    const gl = this.gl;\n    gl.bindFramebuffer(gl.FRAMEBUFFER, null);\n    gl.deleteFramebuffer(this.framebuffer);\n    gl.bindBuffer(gl.ARRAY_BUFFER, null);\n    gl.deleteBuffer(this.vertexbuffer);\n    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);\n    gl.finish();\n    this.disposed = true;\n  }\n\n  private createDefaultGeometry(): Float32Array {\n    // Sets of x,y,z(=0),s,t coordinates.\n    return new Float32Array([\n      -1.0,\n      1.0,\n      0.0,\n      0.0,\n      1.0, // upper left\n      -1.0,\n      -1.0,\n      0.0,\n      0.0,\n      0.0, // lower left\n      1.0,\n      1.0,\n      0.0,\n      1.0,\n      1.0, // upper right\n      1.0,\n      -1.0,\n      0.0,\n      1.0,\n      0.0, // lower right\n    ]);\n  }\n  private createVertexbuffer(): WebGLBuffer {\n    const gl = this.gl;\n    const buffer = gl.createBuffer();\n    if (!buffer) {\n      throw new Error('createBuffer() returned null');\n    }\n    const geometry = this.createDefaultGeometry();\n    gl.bindBuffer(gl.ARRAY_BUFFER, buffer);\n    gl.bufferData(gl.ARRAY_BUFFER, geometry, gl.STATIC_DRAW);\n    this.checkError();\n    return buffer;\n  }\n  private createFramebuffer(): WebGLFramebuffer {\n    const fb = this.gl.createFramebuffer();\n    if (!fb) {\n      throw new Error('createFramebuffer returned null');\n    }\n    return fb;\n  }\n\n  private queryVitalParameters(): void {\n    const gl = this.gl;\n\n    this.isFloatTextureAttachableToFrameBuffer = this.checkFloatTextureAttachableToFrameBuffer();\n    this.isRenderFloat32Supported = this.checkRenderFloat32();\n    this.isFloat32DownloadSupported = this.checkFloat32Download();\n\n    if (this.version === 1 && !this.textureHalfFloatExtension && !this.isRenderFloat32Supported) {\n      throw new Error('both float32 and float16 TextureType are not supported');\n    }\n\n    this.isBlendSupported = !this.isRenderFloat32Supported || this.checkFloat32Blend();\n\n    // this.maxCombinedTextureImageUnits = gl.getParameter(gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS);\n    this.maxTextureSize = gl.getParameter(gl.MAX_TEXTURE_SIZE);\n    this.maxTextureImageUnits = gl.getParameter(gl.MAX_TEXTURE_IMAGE_UNITS);\n    // this.maxCubeMapTextureSize = gl.getParameter(gl.MAX_CUBE_MAP_TEXTURE_SIZE);\n    // this.shadingLanguageVersion = gl.getParameter(gl.SHADING_LANGUAGE_VERSION);\n    // this.webglVendor = gl.getParameter(gl.VENDOR);\n    // this.webglVersion = gl.getParameter(gl.VERSION);\n\n    if (this.version === 2) {\n      // this.max3DTextureSize = gl.getParameter(WebGL2RenderingContext.MAX_3D_TEXTURE_SIZE);\n      // this.maxArrayTextureLayers = gl.getParameter(WebGL2RenderingContext.MAX_ARRAY_TEXTURE_LAYERS);\n      // this.maxColorAttachments = gl.getParameter(WebGL2RenderingContext.MAX_COLOR_ATTACHMENTS);\n      // this.maxDrawBuffers = gl.getParameter(WebGL2RenderingContext.MAX_DRAW_BUFFERS);\n    }\n  }\n  private getExtensions(): void {\n    if (this.version === 2) {\n      this.colorBufferFloatExtension = this.gl.getExtension('EXT_color_buffer_float');\n      this.disjointTimerQueryWebgl2Extension = this.gl.getExtension('EXT_disjoint_timer_query_webgl2');\n    } else {\n      this.textureFloatExtension = this.gl.getExtension('OES_texture_float');\n      this.textureHalfFloatExtension = this.gl.getExtension('OES_texture_half_float');\n    }\n  }\n\n  private checkFloatTextureAttachableToFrameBuffer(): boolean {\n    // test whether Float32 texture is supported:\n    // STEP.1 create a float texture\n    const gl = this.gl;\n    const texture = gl.createTexture();\n    gl.bindTexture(gl.TEXTURE_2D, texture);\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    const internalFormat = this.version === 2 ? (gl as unknown as { RGBA32F: number }).RGBA32F : gl.RGBA;\n    gl.texImage2D(gl.TEXTURE_2D, 0, internalFormat, 1, 1, 0, gl.RGBA, gl.FLOAT, null);\n    // STEP.2 bind a frame buffer\n    const frameBuffer = gl.createFramebuffer();\n    gl.bindFramebuffer(gl.FRAMEBUFFER, frameBuffer);\n    // STEP.3 attach texture to framebuffer\n    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);\n    // STEP.4 test whether framebuffer is complete\n    const isComplete = gl.checkFramebufferStatus(gl.FRAMEBUFFER) === gl.FRAMEBUFFER_COMPLETE;\n    gl.bindTexture(gl.TEXTURE_2D, null);\n    gl.bindFramebuffer(gl.FRAMEBUFFER, null);\n    gl.deleteTexture(texture);\n    gl.deleteFramebuffer(frameBuffer);\n    return isComplete;\n  }\n\n  private checkRenderFloat32(): boolean {\n    if (this.version === 2) {\n      if (!this.colorBufferFloatExtension) {\n        return false;\n      }\n    } else {\n      if (!this.textureFloatExtension) {\n        return false;\n      }\n    }\n    return this.isFloatTextureAttachableToFrameBuffer;\n  }\n\n  private checkFloat32Download(): boolean {\n    if (this.version === 2) {\n      if (!this.colorBufferFloatExtension) {\n        return false;\n      }\n    } else {\n      if (!this.textureFloatExtension) {\n        return false;\n      }\n      if (!this.gl.getExtension('WEBGL_color_buffer_float')) {\n        return false;\n      }\n    }\n    return this.isFloatTextureAttachableToFrameBuffer;\n  }\n\n  /**\n   * Check whether GL_BLEND is supported\n   */\n  private checkFloat32Blend(): boolean {\n    // it looks like currently (2019-05-08) there is no easy way to detect whether BLEND is supported\n    // https://github.com/microsoft/onnxjs/issues/145\n\n    const gl = this.gl;\n\n    let texture: WebGLTexture | null | undefined;\n    let frameBuffer: WebGLFramebuffer | null | undefined;\n    let vertexShader: WebGLShader | null | undefined;\n    let fragmentShader: WebGLShader | null | undefined;\n    let program: WebGLProgram | null | undefined;\n\n    try {\n      texture = gl.createTexture();\n      frameBuffer = gl.createFramebuffer();\n      gl.bindTexture(gl.TEXTURE_2D, texture);\n\n      // eslint-disable-next-line @typescript-eslint/naming-convention\n      const internalFormat = this.version === 2 ? (gl as unknown as { RGBA32F: number }).RGBA32F : gl.RGBA;\n      gl.texImage2D(gl.TEXTURE_2D, 0, internalFormat, 1, 1, 0, gl.RGBA, gl.FLOAT, null);\n\n      gl.bindFramebuffer(gl.FRAMEBUFFER, frameBuffer);\n      gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);\n\n      gl.enable(gl.BLEND);\n\n      vertexShader = gl.createShader(gl.VERTEX_SHADER);\n      if (!vertexShader) {\n        return false;\n      }\n      gl.shaderSource(vertexShader, 'void main(){}');\n      gl.compileShader(vertexShader);\n\n      fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);\n      if (!fragmentShader) {\n        return false;\n      }\n      gl.shaderSource(fragmentShader, 'precision highp float;void main(){gl_FragColor=vec4(0.5);}');\n      gl.compileShader(fragmentShader);\n\n      program = gl.createProgram();\n      if (!program) {\n        return false;\n      }\n      gl.attachShader(program, vertexShader);\n      gl.attachShader(program, fragmentShader);\n      gl.linkProgram(program);\n      gl.useProgram(program);\n\n      gl.drawArrays(gl.POINTS, 0, 1);\n      return gl.getError() === gl.NO_ERROR;\n    } finally {\n      gl.disable(gl.BLEND);\n\n      if (program) {\n        gl.deleteProgram(program);\n      }\n      if (vertexShader) {\n        gl.deleteShader(vertexShader);\n      }\n      if (fragmentShader) {\n        gl.deleteShader(fragmentShader);\n      }\n      if (frameBuffer) {\n        gl.bindFramebuffer(gl.FRAMEBUFFER, null);\n        gl.deleteFramebuffer(frameBuffer);\n      }\n      if (texture) {\n        gl.bindTexture(gl.TEXTURE_2D, null);\n        gl.deleteTexture(texture);\n      }\n    }\n  }\n\n  beginTimer(): WebGLQuery {\n    if (this.version === 2 && this.disjointTimerQueryWebgl2Extension) {\n      const gl2 = this.gl as WebGL2RenderingContext;\n      const ext = this.disjointTimerQueryWebgl2Extension;\n\n      const query = gl2.createQuery() as WebGLQuery;\n      gl2.beginQuery(ext.TIME_ELAPSED_EXT, query);\n      return query;\n    } else {\n      // TODO: add webgl 1 handling.\n      throw new Error('WebGL1 profiling currently not supported.');\n    }\n  }\n\n  endTimer() {\n    if (this.version === 2 && this.disjointTimerQueryWebgl2Extension) {\n      const gl2 = this.gl as WebGL2RenderingContext;\n      const ext = this.disjointTimerQueryWebgl2Extension;\n      gl2.endQuery(ext.TIME_ELAPSED_EXT);\n      return;\n    } else {\n      // TODO: add webgl 1 handling.\n      throw new Error('WebGL1 profiling currently not supported');\n    }\n  }\n\n  isTimerResultAvailable(query: WebGLQuery): boolean {\n    let available = false,\n      disjoint = false;\n    if (this.version === 2 && this.disjointTimerQueryWebgl2Extension) {\n      const gl2 = this.gl as WebGL2RenderingContext;\n      const ext = this.disjointTimerQueryWebgl2Extension;\n\n      available = gl2.getQueryParameter(query, gl2.QUERY_RESULT_AVAILABLE);\n      disjoint = gl2.getParameter(ext.GPU_DISJOINT_EXT);\n    } else {\n      // TODO: add webgl 1 handling.\n      throw new Error('WebGL1 profiling currently not supported');\n    }\n\n    return available && !disjoint;\n  }\n\n  getTimerResult(query: WebGLQuery): number {\n    let timeElapsed = 0;\n    if (this.version === 2) {\n      const gl2 = this.gl as WebGL2RenderingContext;\n      timeElapsed = gl2.getQueryParameter(query, gl2.QUERY_RESULT);\n      gl2.deleteQuery(query);\n    } else {\n      // TODO: add webgl 1 handling.\n      throw new Error('WebGL1 profiling currently not supported');\n    }\n    // return milliseconds\n    return timeElapsed / 1000000;\n  }\n\n  async waitForQueryAndGetTime(query: WebGLQuery): Promise<number> {\n    await repeatedTry(() => this.isTimerResultAvailable(query));\n    return this.getTimerResult(query);\n  }\n\n  public async createAndWaitForFence(): Promise<void> {\n    const fenceContext = this.createFence(this.gl);\n    return this.pollFence(fenceContext);\n  }\n\n  private createFence(gl: WebGLRenderingContext): FenceContext {\n    let isFencePassed: () => boolean;\n    const gl2 = gl as WebGL2RenderingContext;\n    const query = gl2.fenceSync(gl2.SYNC_GPU_COMMANDS_COMPLETE, 0);\n    gl.flush();\n    if (query === null) {\n      isFencePassed = () => true;\n    } else {\n      isFencePassed = () => {\n        const status = gl2.clientWaitSync(query, 0, 0);\n        return status === gl2.ALREADY_SIGNALED || status === gl2.CONDITION_SATISFIED;\n      };\n    }\n    return { query, isFencePassed };\n  }\n\n  async pollFence(fenceContext: FenceContext) {\n    return new Promise<void>((resolve) => {\n      void this.addItemToPoll(\n        () => fenceContext.isFencePassed(),\n        () => resolve(),\n      );\n    });\n  }\n\n  private itemsToPoll: PollItem[] = [];\n\n  pollItems(): void {\n    // Find the last query that has finished.\n    const index = linearSearchLastTrue(this.itemsToPoll.map((x) => x.isDoneFn));\n    for (let i = 0; i <= index; ++i) {\n      const { resolveFn } = this.itemsToPoll[i];\n      resolveFn();\n    }\n    this.itemsToPoll = this.itemsToPoll.slice(index + 1);\n  }\n\n  private async addItemToPoll(isDoneFn: () => boolean, resolveFn: () => void) {\n    this.itemsToPoll.push({ isDoneFn, resolveFn });\n    if (this.itemsToPoll.length > 1) {\n      // We already have a running loop that polls.\n      return;\n    }\n    // Start a new loop that polls.\n    await repeatedTry(() => {\n      this.pollItems();\n      // End the loop if no more items to poll.\n      return this.itemsToPoll.length === 0;\n    });\n  }\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Logger } from '../../instrument';\n\nimport { WebGLContext } from './webgl-context';\n\nconst cache: { [contextId: string]: WebGLContext } = {};\n\n/**\n * This factory function creates proper WebGLRenderingContext based on\n * the current browsers capabilities\n * The order is from higher/most recent versions to most basic\n */\nexport function createWebGLContext(contextId?: 'webgl' | 'webgl2'): WebGLContext {\n  let context: WebGLContext | undefined;\n  if ((!contextId || contextId === 'webgl2') && 'webgl2' in cache) {\n    context = cache.webgl2;\n  } else if ((!contextId || contextId === 'webgl') && 'webgl' in cache) {\n    context = cache.webgl;\n  }\n\n  if (!context) {\n    try {\n      // try to create webgl context from an offscreen canvas\n      const offscreenCanvas = createOffscreenCanvas();\n      context = createNewWebGLContext(offscreenCanvas, contextId);\n    } catch {\n      // if failed, fallback to try to use a normal canvas element\n      const canvas = createCanvas();\n      context = createNewWebGLContext(canvas, contextId);\n    }\n  }\n\n  contextId = contextId || context.version === 1 ? 'webgl' : 'webgl2';\n  const gl = context.gl;\n\n  cache[contextId] = context;\n\n  if (gl.isContextLost()) {\n    delete cache[contextId];\n    return createWebGLContext(contextId);\n  }\n\n  gl.disable(gl.DEPTH_TEST);\n  gl.disable(gl.STENCIL_TEST);\n  gl.disable(gl.BLEND);\n  gl.disable(gl.DITHER);\n  gl.disable(gl.POLYGON_OFFSET_FILL);\n  gl.disable(gl.SAMPLE_COVERAGE);\n  gl.enable(gl.SCISSOR_TEST);\n  gl.enable(gl.CULL_FACE);\n  gl.cullFace(gl.BACK);\n\n  return context;\n}\n\nexport function createNewWebGLContext(canvas: HTMLCanvasElement, contextId?: 'webgl' | 'webgl2'): WebGLContext {\n  const contextAttributes: WebGLContextAttributes = {\n    alpha: false,\n    depth: false,\n    antialias: false,\n    stencil: false,\n    preserveDrawingBuffer: false,\n    premultipliedAlpha: false,\n    failIfMajorPerformanceCaveat: false,\n  };\n  let gl: WebGLRenderingContext | null;\n  const ca = contextAttributes;\n  if (!contextId || contextId === 'webgl2') {\n    gl = canvas.getContext('webgl2', ca);\n    if (gl) {\n      try {\n        return new WebGLContext(gl, 2);\n      } catch (err) {\n        Logger.warning('GlContextFactory', `failed to create WebGLContext using contextId 'webgl2'. Error: ${err}`);\n      }\n    }\n  }\n  if (!contextId || contextId === 'webgl') {\n    gl = canvas.getContext('webgl', ca) || (canvas.getContext('experimental-webgl', ca) as WebGLRenderingContext);\n    if (gl) {\n      try {\n        return new WebGLContext(gl, 1);\n      } catch (err) {\n        Logger.warning(\n          'GlContextFactory',\n          `failed to create WebGLContext using contextId 'webgl' or 'experimental-webgl'. Error: ${err}`,\n        );\n      }\n    }\n  }\n\n  throw new Error('WebGL is not supported');\n}\n\n// eslint-disable-next-line @typescript-eslint/naming-convention\ndeclare let OffscreenCanvas: { new (width: number, height: number): HTMLCanvasElement };\n\nfunction createCanvas(): HTMLCanvasElement {\n  if (typeof document === 'undefined') {\n    throw new TypeError('failed to create canvas: document is not supported');\n  }\n  const canvas: HTMLCanvasElement = document.createElement('canvas');\n  canvas.width = 1;\n  canvas.height = 1;\n  return canvas;\n}\n\nfunction createOffscreenCanvas(): HTMLCanvasElement {\n  if (typeof OffscreenCanvas === 'undefined') {\n    throw new TypeError('failed to create offscreen canvas: OffscreenCanvas is not supported');\n  }\n  return new OffscreenCanvas(1, 1);\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { env } from 'onnxruntime-common';\n\nimport { Backend, SessionHandler } from '../backend';\nimport { Logger } from '../instrument';\nimport { Session } from '../session';\n\nimport { WebGLSessionHandler } from './webgl/session-handler';\nimport { WebGLContext } from './webgl/webgl-context';\nimport { createWebGLContext } from './webgl/webgl-context-factory';\n\n/**\n * WebGLBackend is the entry point for all WebGL operations\n * When it starts it created the WebGLRenderingContext\n * and other main framework components such as Program and Texture Managers\n */\nexport class WebGLBackend implements Backend {\n  glContext: WebGLContext;\n\n  get contextId(): 'webgl' | 'webgl2' | undefined {\n    return env.webgl.contextId;\n  }\n  set contextId(value: 'webgl' | 'webgl2' | undefined) {\n    env.webgl.contextId = value;\n  }\n\n  get matmulMaxBatchSize(): number | undefined {\n    return env.webgl.matmulMaxBatchSize;\n  }\n  set matmulMaxBatchSize(value: number | undefined) {\n    env.webgl.matmulMaxBatchSize = value;\n  }\n\n  get textureCacheMode(): 'initializerOnly' | 'full' | undefined {\n    return env.webgl.textureCacheMode;\n  }\n  set textureCacheMode(value: 'initializerOnly' | 'full' | undefined) {\n    env.webgl.textureCacheMode = value;\n  }\n\n  get pack(): boolean | undefined {\n    return env.webgl.pack;\n  }\n  set pack(value: boolean | undefined) {\n    env.webgl.pack = value;\n  }\n\n  get async(): boolean | undefined {\n    return env.webgl.async;\n  }\n  set async(value: boolean | undefined) {\n    env.webgl.async = value;\n  }\n\n  initialize(): boolean {\n    try {\n      this.glContext = createWebGLContext(this.contextId);\n      if (typeof this.matmulMaxBatchSize !== 'number') {\n        this.matmulMaxBatchSize = 16;\n      }\n      if (typeof this.textureCacheMode !== 'string') {\n        this.textureCacheMode = 'full';\n      }\n      if (typeof this.pack !== 'boolean') {\n        this.pack = false;\n      }\n      if (typeof this.async !== 'boolean') {\n        this.async = false;\n      }\n\n      Logger.setWithEnv(env);\n\n      if (!env.webgl.context) {\n        Object.defineProperty(env.webgl, 'context', { value: this.glContext.gl });\n      }\n\n      Logger.verbose(\n        'WebGLBackend',\n        `Created WebGLContext: ${typeof this.glContext} with matmulMaxBatchSize: ${\n          this.matmulMaxBatchSize\n        }; textureCacheMode: ${this.textureCacheMode}; pack: ${this.pack}; async: ${this.async}.`,\n      );\n      return true;\n    } catch (e) {\n      Logger.warning('WebGLBackend', `Unable to initialize WebGLBackend. ${e}`);\n      return false;\n    }\n  }\n  createSessionHandler(context: Session.Context): SessionHandler {\n    return new WebGLSessionHandler(this, context);\n  }\n  dispose(): void {\n    this.glContext.dispose();\n  }\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { WebGLBackend } from './backends/backend-webgl';\nimport { Graph } from './graph';\nimport { Operator } from './operators';\nimport { OpSet } from './opset';\nimport { Session } from './session';\n\nexport interface InferenceHandler {\n  /**\n   * dispose the inference handler. it will be called as the last step in Session.run()\n   */\n  dispose(): void;\n}\n\nexport interface SessionHandler {\n  /**\n   * transform the graph at initialization time\n   * @param graphTransformer the graph transformer to manipulate the model graph\n   */\n  transformGraph?(graphTransformer: Graph.Transformer): void;\n\n  /**\n   * create an instance of InferenceHandler to use in a Session.run() call\n   */\n  createInferenceHandler(): InferenceHandler;\n\n  /**\n   * dispose the session handler. it will be called when a session is being disposed explicitly\n   */\n  dispose(): void;\n\n  /**\n   * Resolves the operator from the name and opset version; backend specific\n   * @param node the node to resolve\n   * @param opsets a list of opsets that exported from the model\n   * @param graph the completely initialized graph\n   */\n  resolve(node: Graph.Node, opsets: readonly OpSet[], graph: Graph): Operator;\n\n  /**\n   * This method let's the sessionHandler know that the graph initialization is complete\n   * @param graph the completely initialized graph\n   */\n  onGraphInitialized?(graph: Graph): void;\n\n  /**\n   * a reference to the corresponding backend\n   */\n  readonly backend: Backend;\n\n  /**\n   * a reference to the session context\n   */\n  readonly context: Session.Context;\n}\n\nexport interface Backend {\n  /**\n   * initialize the backend. will be called only once, when the first time the\n   * backend it to be used\n   */\n  initialize(): boolean | Promise<boolean>;\n\n  /**\n   * create an instance of SessionHandler to use in a Session object's lifecycle\n   */\n  createSessionHandler(context: Session.Context): SessionHandler;\n\n  /**\n   * dispose the backend. currently this will not be called\n   */\n  dispose(): void;\n}\n\n// caches all initialized backend instances\nconst backendsCache: Map<string, Backend> = new Map();\n\nexport const backend: { [name: string]: Backend } = {\n  webgl: new WebGLBackend(),\n};\n\n/**\n * Resolve a reference to the backend. If a hint is specified, the corresponding\n * backend will be used.\n */\nexport async function resolveBackend(hint?: string | readonly string[]): Promise<Backend> {\n  if (!hint) {\n    return resolveBackend(['webgl']);\n  } else {\n    const hints = typeof hint === 'string' ? [hint] : hint;\n\n    for (const backendHint of hints) {\n      const cache = backendsCache.get(backendHint);\n      if (cache) {\n        return cache;\n      }\n\n      const backend = await tryLoadBackend(backendHint);\n      if (backend) {\n        return backend;\n      }\n    }\n  }\n\n  throw new Error('no available backend to use');\n}\n\nasync function tryLoadBackend(backendHint: string): Promise<Backend | undefined> {\n  const backendObj = backend;\n\n  if (typeof backendObj[backendHint] !== 'undefined' && isBackend(backendObj[backendHint])) {\n    const backend = backendObj[backendHint];\n    let init = backend.initialize();\n    if (typeof init === 'object' && 'then' in init) {\n      init = await init;\n    }\n    if (init) {\n      backendsCache.set(backendHint, backend);\n      return backend;\n    }\n  }\n\n  return undefined;\n}\n\nfunction isBackend(obj: unknown) {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const o = obj as any;\n\n  // check if an object is a Backend instance\n  if (\n    'initialize' in o &&\n    typeof o.initialize === 'function' && // initialize()\n    'createSessionHandler' in o &&\n    typeof o.createSessionHandler === 'function' && // createSessionHandler()\n    'dispose' in o &&\n    typeof o.dispose === 'function' // dispose()\n  ) {\n    return true;\n  }\n\n  return false;\n}\n\nexport type BackendType = Backend;\nexport type SessionHandlerType = ReturnType<BackendType['createSessionHandler']>;\nexport type InferenceHandlerType = ReturnType<SessionHandlerType['createInferenceHandler']>;\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { SessionHandler } from './backend';\nimport { Graph } from './graph';\nimport { Logger, Profiler } from './instrument';\nimport { Operator } from './operators';\nimport { Tensor } from './tensor';\n\nclass KernelOp {\n  constructor(\n    public op: Operator,\n    public node: Graph.Node,\n  ) {}\n}\n\nexport class ExecutionPlan {\n  constructor(\n    private graph: Graph,\n    ops: Operator[],\n    private profiler: Readonly<Profiler>,\n  ) {\n    this.initialize(ops);\n  }\n\n  initialize(ops: Operator[]) {\n    this.profiler.event('session', 'ExecutionPlan.initialize', () => {\n      const graphNodes = this.graph.getNodes();\n      if (graphNodes.length !== ops.length) {\n        throw new Error('The size of nodes and OPs do not match.');\n      }\n\n      this._ops = ops.map((op, i) => new KernelOp(op, graphNodes[i]));\n      this.reset();\n\n      // look for starter node(s)\n      this._starter = [];\n      this._ops.forEach((op, i) => {\n        let resolved = true;\n        for (const input of op.node.inputs) {\n          if (\n            !this._values[input] && // not an initialized input\n            this.graph.getInputIndices().indexOf(input) === -1 // not model input\n          ) {\n            resolved = false;\n            break;\n          }\n        }\n        if (resolved) {\n          this._starter.push(i);\n        }\n      });\n    });\n  }\n\n  reset() {\n    this._values = this.graph.getValues().map((i) => i.tensor);\n  }\n\n  async execute(sessionHandler: SessionHandler, modelInputs: Tensor[]): Promise<Tensor[]> {\n    return this.profiler.event('session', 'ExecutionPlan.execute', async () => {\n      // reset mediem result\n      this.reset();\n\n      // create inference handler\n      const inferenceHandler = sessionHandler.createInferenceHandler();\n\n      // populate inputs value\n      const graphInputs = this.graph.getInputIndices();\n      if (modelInputs.length !== graphInputs.length) {\n        throw new Error(\n          `number of input tensors don't match the number of inputs to the model: actual: ${\n            modelInputs.length\n          } expected: ${graphInputs.length}`,\n        );\n      }\n\n      modelInputs.forEach((input, i) => {\n        const index = graphInputs[i];\n        this._values[index] = input;\n      });\n\n      // prepare running sequence\n      const sequence: number[] = this._starter.slice(0);\n\n      // execution iterations\n      const graphValues = this.graph.getValues();\n      const graphNodes = this.graph.getNodes();\n\n      let rear = 0;\n      while (rear < sequence.length) {\n        const thisOpIndex = sequence[rear++];\n        const thisOp = this._ops[thisOpIndex];\n\n        // check input\n        const inputList = thisOp.node.inputs.map((i) => this._values[i]);\n        if (inputList.indexOf(undefined) !== -1) {\n          throw new Error(`unresolved input detected: op: ${thisOp.node}`);\n        }\n\n        // run\n        const inputTensors = inputList as Tensor[];\n        Logger.verbose(\n          'ExecPlan',\n          `Running op:${thisOp.node.name} (${inputTensors\n            .map((t, i) => `'${thisOp.node.inputs[i]}': ${t.type}[${t.dims.join(',')}]`)\n            .join(', ')})`,\n        );\n\n        const outputList = await this.profiler.event('node', thisOp.node.name, async () =>\n          thisOp.op.impl(inferenceHandler, inputTensors, thisOp.op.context),\n        );\n\n        // check output\n        if (outputList.length !== thisOp.node.outputs.length) {\n          throw new Error('the size of output does not match model definition.');\n        }\n\n        // fill value\n        outputList.forEach((output, i) => {\n          const j = thisOp.node.outputs[i];\n          if (this._values[j]) {\n            throw new Error(`output [${j}] already has value: op:${thisOp.node.name}`);\n          }\n          this._values[j] = output;\n        });\n\n        // resolve downstream nodes\n        const downstreamNodes = new Set<number>();\n        outputList.forEach((_output, i) => {\n          const j = thisOp.node.outputs[i];\n          for (const currentDownstreamNodeIndex of graphValues[j].to) {\n            const currentDownstreamNode = graphNodes[currentDownstreamNodeIndex];\n            let resolved = true;\n            for (const k of currentDownstreamNode.inputs) {\n              if (!this._values[k]) {\n                resolved = false;\n                break;\n              }\n            }\n            if (resolved) {\n              downstreamNodes.add(currentDownstreamNodeIndex);\n            }\n          }\n        });\n        sequence.push(...downstreamNodes);\n      }\n\n      const output: Tensor[] = [];\n      for (let i = 0; i < this.graph.getOutputIndices().length; i++) {\n        const outputIndex = this.graph.getOutputIndices()[i];\n        const outputTensor = this._values[outputIndex];\n        if (outputTensor === undefined) {\n          throw new Error(`required output [${outputIndex}] does not have value`);\n        }\n        if (outputIndex === 0) {\n          await outputTensor.getData();\n        } else {\n          void outputTensor.data;\n        }\n        output.push(outputTensor);\n      }\n      Logger.verbose('ExecPlan', 'disposing of inferenceHandler');\n      inferenceHandler.dispose();\n      return output;\n    });\n  }\n\n  _values: Array<Tensor | undefined>;\n  _ops: KernelOp[];\n  _starter: number[];\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport Long from 'long';\n\nimport * as ortFbs from './ort-schema/flatbuffers/ort-generated';\nimport { onnx } from './ort-schema/protobuf/onnx';\nimport { Tensor } from './tensor';\nimport { decodeUtf8String, LongUtil } from './util';\n\nexport declare namespace Attribute {\n  export interface DataTypeMap {\n    float: number;\n    int: number;\n    string: string;\n    tensor: Tensor;\n    floats: number[];\n    ints: number[];\n    strings: string[];\n    tensors: Tensor[];\n  }\n\n  export type DataType = keyof DataTypeMap;\n}\n\ntype ValueTypes = Attribute.DataTypeMap[Attribute.DataType];\n\ntype Value = [ValueTypes, Attribute.DataType];\n\nexport class Attribute {\n  constructor(attributes: onnx.IAttributeProto[] | ortFbs.Attribute[] | null | undefined) {\n    this._attributes = new Map();\n    if (attributes !== null && attributes !== undefined) {\n      for (const attr of attributes) {\n        if (attr instanceof onnx.AttributeProto) {\n          this._attributes.set(attr.name, [Attribute.getValue(attr), Attribute.getType(attr)]);\n        } else if (attr instanceof ortFbs.Attribute) {\n          this._attributes.set(attr.name()!, [Attribute.getValue(attr), Attribute.getType(attr)]);\n        }\n      }\n      if (this._attributes.size < attributes.length) {\n        throw new Error('duplicated attribute names');\n      }\n    }\n  }\n\n  set(key: string, type: Attribute.DataType, value: ValueTypes): void {\n    this._attributes.set(key, [value, type]);\n  }\n  delete(key: string): void {\n    this._attributes.delete(key);\n  }\n  getFloat(key: string, defaultValue?: Attribute.DataTypeMap['float']) {\n    return this.get(key, 'float', defaultValue);\n  }\n\n  getInt(key: string, defaultValue?: Attribute.DataTypeMap['int']) {\n    return this.get(key, 'int', defaultValue);\n  }\n\n  getString(key: string, defaultValue?: Attribute.DataTypeMap['string']) {\n    return this.get(key, 'string', defaultValue);\n  }\n\n  getTensor(key: string, defaultValue?: Attribute.DataTypeMap['tensor']) {\n    return this.get(key, 'tensor', defaultValue);\n  }\n\n  getFloats(key: string, defaultValue?: Attribute.DataTypeMap['floats']) {\n    return this.get(key, 'floats', defaultValue);\n  }\n\n  getInts(key: string, defaultValue?: Attribute.DataTypeMap['ints']) {\n    return this.get(key, 'ints', defaultValue);\n  }\n\n  getStrings(key: string, defaultValue?: Attribute.DataTypeMap['strings']) {\n    return this.get(key, 'strings', defaultValue);\n  }\n\n  getTensors(key: string, defaultValue?: Attribute.DataTypeMap['tensors']) {\n    return this.get(key, 'tensors', defaultValue);\n  }\n\n  private get<V extends Attribute.DataTypeMap[Attribute.DataType]>(\n    key: string,\n    type: Attribute.DataType,\n    defaultValue?: V,\n  ): V {\n    const valueAndType = this._attributes.get(key);\n    if (valueAndType === undefined) {\n      if (defaultValue !== undefined) {\n        return defaultValue;\n      }\n      throw new Error(`required attribute not found: ${key}`);\n    }\n    if (valueAndType[1] !== type) {\n      throw new Error(`type mismatch: expected ${type} but got ${valueAndType[1]}`);\n    }\n    return valueAndType[0] as V;\n  }\n\n  private static getType(attr: onnx.IAttributeProto | ortFbs.Attribute): Attribute.DataType {\n    const type = attr instanceof onnx.AttributeProto ? attr.type : (attr as ortFbs.Attribute).type();\n    switch (type) {\n      case onnx.AttributeProto.AttributeType.FLOAT:\n        return 'float';\n      case onnx.AttributeProto.AttributeType.INT:\n        return 'int';\n      case onnx.AttributeProto.AttributeType.STRING:\n        return 'string';\n      case onnx.AttributeProto.AttributeType.TENSOR:\n        return 'tensor';\n      case onnx.AttributeProto.AttributeType.FLOATS:\n        return 'floats';\n      case onnx.AttributeProto.AttributeType.INTS:\n        return 'ints';\n      case onnx.AttributeProto.AttributeType.STRINGS:\n        return 'strings';\n      case onnx.AttributeProto.AttributeType.TENSORS:\n        return 'tensors';\n      default:\n        throw new Error(`attribute type is not supported yet: ${onnx.AttributeProto.AttributeType[type]}`);\n    }\n  }\n\n  private static getValue(attr: onnx.IAttributeProto | ortFbs.Attribute) {\n    const attrType = attr instanceof onnx.AttributeProto ? attr.type : (attr as ortFbs.Attribute).type();\n    if (attrType === onnx.AttributeProto.AttributeType.GRAPH || attrType === onnx.AttributeProto.AttributeType.GRAPHS) {\n      throw new Error('graph attribute is not supported yet');\n    }\n\n    const value = this.getValueNoCheck(attr);\n\n    // cast LONG to number\n    if (attrType === onnx.AttributeProto.AttributeType.INT && LongUtil.isLong(value)) {\n      return LongUtil.longToNumber(value as bigint | Long);\n    }\n\n    // cast LONG[] to number[]\n    if (attrType === onnx.AttributeProto.AttributeType.INTS) {\n      const arr = value as Array<number | Long | bigint>;\n      const numberValue: number[] = new Array<number>(arr.length);\n\n      for (let i = 0; i < arr.length; i++) {\n        const maybeLong = arr[i];\n        numberValue[i] = LongUtil.longToNumber(maybeLong);\n      }\n\n      return numberValue;\n    }\n\n    // cast onnx.TensorProto to onnxjs.Tensor\n    if (attrType === onnx.AttributeProto.AttributeType.TENSOR) {\n      return attr instanceof onnx.AttributeProto\n        ? Tensor.fromProto(value as onnx.ITensorProto)\n        : Tensor.fromOrtTensor(value as ortFbs.Tensor);\n    }\n\n    // cast onnx.TensorProto[] to onnxjs.Tensor[]\n    if (attrType === onnx.AttributeProto.AttributeType.TENSORS) {\n      if (attr instanceof onnx.AttributeProto) {\n        const tensorProtos = value as onnx.ITensorProto[];\n        return tensorProtos.map((value) => Tensor.fromProto(value));\n      } else if (attr instanceof ortFbs.Attribute) {\n        const tensorProtos = value as ortFbs.Tensor[];\n        return tensorProtos.map((value) => Tensor.fromOrtTensor(value));\n      }\n    }\n\n    // cast Uint8Array to string\n    if (attrType === onnx.AttributeProto.AttributeType.STRING) {\n      // string in onnx attribute is of uint8array type, so we need to convert it to string below. While in ort format,\n      // string attributes are returned as string, so no conversion is needed.\n      if (attr instanceof onnx.AttributeProto) {\n        const utf8String = value as Uint8Array;\n        return decodeUtf8String(utf8String);\n      }\n    }\n\n    // cast Uint8Array[] to string[]\n    if (attrType === onnx.AttributeProto.AttributeType.STRINGS) {\n      // strings in onnx attribute is returned as uint8array[], so we need to convert it to string[] below. While in ort\n      // format strings attributes are returned as string[], so no conversion is needed.\n      if (attr instanceof onnx.AttributeProto) {\n        const utf8Strings = value as Uint8Array[];\n        return utf8Strings.map(decodeUtf8String);\n      }\n    }\n\n    return value as ValueTypes;\n  }\n\n  private static getValueNoCheck(attr: onnx.IAttributeProto | ortFbs.Attribute) {\n    return attr instanceof onnx.AttributeProto\n      ? this.getValueNoCheckFromOnnxFormat(attr)\n      : this.getValueNoCheckFromOrtFormat(attr as ortFbs.Attribute);\n  }\n\n  private static getValueNoCheckFromOnnxFormat(attr: onnx.IAttributeProto) {\n    switch (attr.type!) {\n      case onnx.AttributeProto.AttributeType.FLOAT:\n        return attr.f;\n      case onnx.AttributeProto.AttributeType.INT:\n        return attr.i;\n      case onnx.AttributeProto.AttributeType.STRING:\n        return attr.s;\n      case onnx.AttributeProto.AttributeType.TENSOR:\n        return attr.t;\n      case onnx.AttributeProto.AttributeType.GRAPH:\n        return attr.g;\n      case onnx.AttributeProto.AttributeType.FLOATS:\n        return attr.floats;\n      case onnx.AttributeProto.AttributeType.INTS:\n        return attr.ints;\n      case onnx.AttributeProto.AttributeType.STRINGS:\n        return attr.strings;\n      case onnx.AttributeProto.AttributeType.TENSORS:\n        return attr.tensors;\n      case onnx.AttributeProto.AttributeType.GRAPHS:\n        return attr.graphs;\n      default:\n        throw new Error(`unsupported attribute type: ${onnx.AttributeProto.AttributeType[attr.type!]}`);\n    }\n  }\n\n  private static getValueNoCheckFromOrtFormat(attr: ortFbs.Attribute) {\n    switch (attr.type()) {\n      case ortFbs.AttributeType.FLOAT:\n        return attr.f();\n      case ortFbs.AttributeType.INT:\n        return attr.i();\n      case ortFbs.AttributeType.STRING:\n        return attr.s();\n      case ortFbs.AttributeType.TENSOR:\n        return attr.t();\n      case ortFbs.AttributeType.GRAPH:\n        return attr.g();\n      case ortFbs.AttributeType.FLOATS:\n        return attr.floatsArray();\n      case ortFbs.AttributeType.INTS: {\n        const ints = [];\n        for (let i = 0; i < attr.intsLength(); i++) {\n          ints.push(attr.ints(i)!);\n        }\n        return ints;\n      }\n      case ortFbs.AttributeType.STRINGS: {\n        const strings = [];\n        for (let i = 0; i < attr.stringsLength(); i++) {\n          strings.push(attr.strings(i));\n        }\n        return strings;\n      }\n      case ortFbs.AttributeType.TENSORS: {\n        const tensors = [];\n        for (let i = 0; i < attr.tensorsLength(); i++) {\n          tensors.push(attr.tensors(i)!);\n        }\n        return tensors;\n      }\n      // case ortFbs.AttributeType.GRAPHS:\n      // TODO: Subgraph not supported yet.\n      // const graphs = [];\n      // for (let i = 0; i < attr.graphsLength(); i++) {\n      //   graphs.push(attr.graphs(i)!);\n      // }\n      // return graphs;\n      default:\n        throw new Error(`unsupported attribute type: ${ortFbs.AttributeType[attr.type()]}`);\n    }\n  }\n\n  protected _attributes: Map<string, Value>;\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Attribute } from './attribute';\nimport * as ortFbs from './ort-schema/flatbuffers/ort-generated';\nimport { onnx } from './ort-schema/protobuf/onnx';\nimport { Tensor } from './tensor';\nimport { LongUtil, MAX_CLIP, MIN_CLIP, ProtoUtil } from './util';\n\nexport declare namespace Graph {\n  export interface Shape {\n    readonly dims: readonly number[];\n  }\n  export interface ValueType {\n    readonly tensorType: Tensor.DataType;\n    readonly shape: Shape;\n  }\n  export interface Value {\n    // the tensor data. empty for non-initialized inputs\n    readonly tensor?: Tensor;\n\n    // index to the Node where the value comes from. -1 for initializer.\n    readonly from: number;\n\n    // indices to the Nodes where the values go to.\n    readonly to: readonly number[];\n\n    // value type specification. empty for non-input values.\n    readonly type?: ValueType;\n  }\n  export interface Node {\n    // name of the node\n    readonly name: string;\n\n    // the operator type\n    readonly opType: string;\n\n    // indices to the Values where the inputs come from.\n    readonly inputs: readonly number[];\n\n    // indices to the Values where the outpus go to.\n    readonly outputs: readonly number[];\n\n    // the attributes that used by the operator\n    readonly attributes: Attribute;\n  }\n\n  /**\n   * a Transformer is an instance that allows all possible transformation operations that applied to a graph\n   */\n  export interface Transformer {\n    removeAllIdentityNodes(): void;\n    removeAllDropoutNodes(): void;\n    fuseConvActivationNodes(): void;\n    // TODO: add generic functions to manipulate the graph\n  }\n\n  // an initializer can use transformer to transform the graph\n  export interface Initializer {\n    transformGraph(transformer: Transformer): void;\n  }\n}\n\n// eslint-disable-next-line @typescript-eslint/no-redeclare\nexport interface Graph {\n  getInputIndices(): readonly number[];\n  getInputNames(): readonly string[];\n  getOutputIndices(): readonly number[];\n  getOutputNames(): readonly string[];\n  getValues(): readonly Graph.Value[];\n  getNodes(): readonly Graph.Node[];\n}\n\n// eslint-disable-next-line @typescript-eslint/naming-convention, @typescript-eslint/no-redeclare\nexport const Graph = {\n  /**\n   * construct a graph from a graph protobuf type\n   */\n  from: (graphProto: onnx.IGraphProto | ortFbs.Graph, initializer?: Graph.Initializer) =>\n    new GraphImpl(graphProto, initializer),\n};\n\nclass Value implements Graph.Value {\n  constructor(valueInfo?: onnx.IValueInfoProto) {\n    this._from = undefined;\n    this._to = [];\n    this.tensor = undefined;\n    this.type = undefined;\n\n    if (valueInfo) {\n      this.type = ProtoUtil.tensorValueTypeFromProto(valueInfo.type!.tensorType!);\n    }\n  }\n\n  _from?: number; // -1 represent from initializer\n  get from() {\n    return this._from!;\n  }\n  _to: number[];\n  get to() {\n    return this._to;\n  }\n  type?: Graph.ValueType;\n  tensor?: Tensor;\n}\n\nclass Node implements Graph.Node {\n  constructor(_nodeProto: onnx.INodeProto | ortFbs.Node, name?: string) {\n    if (_nodeProto instanceof onnx.NodeProto) {\n      this.name = _nodeProto.name;\n      this.opType = _nodeProto.opType;\n      this.attributes = new Attribute(_nodeProto.attribute);\n    } else if (_nodeProto instanceof ortFbs.Node) {\n      this.name = name ?? _nodeProto.name()!;\n      this.opType = _nodeProto.opType()!;\n      this.attributes = new Attribute(ProtoUtil.tensorAttributesFromORTFormat(_nodeProto));\n    }\n\n    this.inputs = [];\n    this.outputs = [];\n    this.executeNode = true;\n  }\n\n  name: string;\n  opType: string;\n  inputs: number[];\n  outputs: number[];\n  attributes: Attribute;\n  executeNode: boolean;\n}\n\nclass GraphImpl implements Graph, Graph.Transformer {\n  private _allData: Value[];\n\n  private _allInputIndices: number[];\n  private _allInputNames: string[];\n\n  private _allOutputIndices: number[];\n  private _allOutputNames: string[];\n\n  private _nodes: Node[];\n\n  constructor(graph: onnx.IGraphProto | ortFbs.Graph, graphInitializer?: Graph.Initializer) {\n    if (!graph) {\n      throw new TypeError('graph is empty');\n    }\n\n    // build the graph - will throw exceptions if something fatal is detected\n    this.buildGraph(graph);\n\n    // execute any transformation logic for the graph (if applicable)\n    this.transformGraph(graphInitializer);\n\n    // check for cycles and other inconsistencies - will throw exceptions if something fatal is detected\n    this.checkIsAcyclic();\n  }\n\n  getInputIndices(): readonly number[] {\n    return this._allInputIndices;\n  }\n\n  getInputNames(): readonly string[] {\n    return this._allInputNames;\n  }\n\n  getOutputIndices(): readonly number[] {\n    return this._allOutputIndices;\n  }\n\n  getOutputNames(): readonly string[] {\n    return this._allOutputNames;\n  }\n\n  getValues(): readonly Graph.Value[] {\n    return this._allData;\n  }\n\n  getNodes(): readonly Graph.Node[] {\n    return this._nodes;\n  }\n\n  private buildGraph(graph: onnx.IGraphProto | ortFbs.Graph) {\n    // build the graph - will throw exceptions if something fatal is detected\n    if (graph instanceof onnx.GraphProto) {\n      this.buildGraphFromOnnxFormat(graph);\n    } else if (graph instanceof ortFbs.Graph) {\n      this.buildGraphFromOrtFormat(graph);\n    } else {\n      throw new TypeError('Graph type is not supported.');\n    }\n  }\n  private buildGraphFromOnnxFormat(graph: onnx.IGraphProto) {\n    const dataIndices = new Map<string, number>();\n    this._allData = [];\n\n    this._allInputIndices = [];\n    this._allInputNames = [];\n\n    this._allOutputIndices = [];\n    this._allOutputNames = [];\n\n    this._nodes = [];\n\n    const nodesIndices = new Map<string, number>();\n\n    // scan all inputs\n    if (!graph.input) {\n      throw new Error('missing information in graph: input');\n    }\n    const inputValueNames = [];\n    for (const i of graph.input) {\n      if (dataIndices.has(i.name!)) {\n        throw new Error(`duplicated input name: ${i.name}`);\n      }\n      const currentIndex = this._allData.push(new Value(i)) - 1;\n      dataIndices.set(i.name!, currentIndex);\n      inputValueNames.push(i.name!);\n    }\n\n    // scan all initializers\n    if (!graph.initializer) {\n      throw new Error('missing information in graph: initializer');\n    }\n    for (const i of graph.initializer) {\n      let index = dataIndices.get(i.name!);\n      if (index === undefined) {\n        const value = new Value();\n        value.type = {\n          shape: { dims: ProtoUtil.tensorDimsFromProto(i.dims!) },\n          tensorType: ProtoUtil.tensorDataTypeFromProto(i.dataType!),\n        };\n        index = this._allData.push(value) - 1;\n        dataIndices.set(i.name!, index);\n      }\n      this._allData[index]._from = -1;\n      this._allData[index].tensor = Tensor.fromProto(i);\n    }\n\n    // filter out input indices\n    for (let i = 0; i < this._allData.length; i++) {\n      if (!this._allData[i].tensor) {\n        this._allInputIndices.push(i);\n        this._allInputNames.push(inputValueNames[i]);\n      }\n    }\n\n    // scan all outputs\n    if (!graph.output) {\n      throw new Error('missing information in graph: output');\n    }\n    for (const i of graph.output) {\n      if (dataIndices.has(i.name!)) {\n        throw new Error(`duplicated output name: ${i.name}`);\n      }\n      const currentIndex = this._allData.push(new Value(i)) - 1;\n      dataIndices.set(i.name!, currentIndex);\n      this._allOutputIndices.push(currentIndex);\n      this._allOutputNames.push(i.name!);\n    }\n\n    // scan all nodes\n    if (!graph.node) {\n      throw new Error('missing information in graph: node');\n    }\n    for (const nodeProto of graph.node) {\n      if (!nodeProto.name) {\n        // assign a name to the node if it doesn't have one\n        for (let pick = 0; ; pick++) {\n          const name = `unnamed_${nodeProto.opType}_${pick}`;\n          if (!nodesIndices.has(name)) {\n            nodeProto.name = name;\n            break;\n          }\n        }\n      }\n\n      if (nodesIndices.has(nodeProto.name)) {\n        throw new Error(`duplicated node name: ${nodeProto.name}`);\n      }\n      const currentIndex = this._nodes.push(new Node(nodeProto)) - 1;\n      nodesIndices.set(nodeProto.name, currentIndex);\n    }\n\n    // scan node's outputs\n    for (let i = 0; i < this._nodes.length; i++) {\n      const node = this._nodes[i];\n      const nodeProto = graph.node[i];\n      if (!nodeProto.output) {\n        throw new Error(`missing output for node: ${nodeProto.name}`);\n      }\n      for (const output of nodeProto.output) {\n        let dataIndex = dataIndices.get(output);\n        if (typeof dataIndex === 'undefined') {\n          dataIndex = this._allData.push(new Value()) - 1;\n          dataIndices.set(output, dataIndex);\n        }\n        node.outputs.push(dataIndex);\n\n        if (this._allData[dataIndex]._from !== undefined) {\n          throw new Error(`multiple nodes output to one data value: ${dataIndex}`);\n        }\n        this._allData[dataIndex]._from = i;\n\n        // for the 'Constant' operator, just create a new edge in the graph corresponding to the 'output' of the\n        // operator and ignore the node from the graph\n        if (nodeProto.opType === 'Constant') {\n          if (!nodeProto.attribute || nodeProto.attribute.length !== 1 || !nodeProto.attribute[0].t) {\n            throw new Error('missing attributes or missing tensor value in attributes for this Constant operator');\n          }\n          if (!nodeProto.output || nodeProto.output.length !== 1) {\n            throw new Error('missing output or incorrect number of outputs for this Constant operator');\n          }\n          node.outputs.pop();\n          node.executeNode = false;\n\n          this._allData[dataIndex]._from = -1;\n          this._allData[dataIndex].tensor = Tensor.fromProto(nodeProto.attribute[0].t);\n        }\n      }\n    }\n\n    // scan node's inputs\n    for (let i = 0; i < this._nodes.length; i++) {\n      const node = this._nodes[i];\n      const nodeProto = graph.node[i];\n\n      if (!nodeProto.input) {\n        throw new Error(`missing input for node: ${nodeProto.name}`);\n      }\n      for (const input of nodeProto.input) {\n        const dataIndex = dataIndices.get(input);\n        if (typeof dataIndex === 'undefined') {\n          // handle exception when opset > 9 and roi / scales not given\n          if (\n            input === '' &&\n            (nodeProto.input.length === 3 || nodeProto.input.length === 4) &&\n            nodeProto.opType === 'Resize'\n          ) {\n            continue;\n          }\n          throw new Error(`unrecognized input '${input}' for node: ${nodeProto.name}`);\n        }\n        node.inputs.push(dataIndex);\n\n        this._allData[dataIndex]._to.push(i);\n      }\n    }\n\n    return true;\n  }\n\n  private buildGraphFromOrtFormat(graph: ortFbs.Graph) {\n    const dataIndices = new Map<string, number>();\n    this._allData = [];\n\n    this._allInputIndices = [];\n    this._allInputNames = [];\n\n    this._allOutputIndices = [];\n    this._allOutputNames = [];\n\n    this._nodes = [];\n\n    const nodesIndices = new Map<string, number>();\n\n    // scan all inputs\n    const inputValueNames = [];\n    for (let i = 0; i < graph.inputsLength(); i++) {\n      const inputName = graph.inputs(i);\n      if (dataIndices.has(inputName)) {\n        throw new Error(`duplicated input name: ${inputName}`);\n      }\n      // Find the input typeInfo from nodeargs\n      for (let j = 0; j < graph.nodeArgsLength(); j++) {\n        if (graph.nodeArgs(j)?.name() === inputName) {\n          const value = new Value();\n          const valueType = graph.nodeArgs(j)?.type()?.valueType();\n          if (valueType !== ortFbs.TypeInfoValue.tensor_type) {\n            throw new Error('Unexpected value type for the nodeArg.');\n          }\n          const valueInfo = graph.nodeArgs(j)!.type()!.value(new ortFbs.TensorTypeAndShape())!;\n          const type = ProtoUtil.tensorDataTypeFromProto(valueInfo.elemType());\n          const shape = valueInfo.shape()!;\n          const dims = [];\n          for (let k = 0; k < shape.dimLength()!; k++) {\n            dims.push(LongUtil.longToNumber(shape.dim(k)!.value()!.dimValue()!));\n          }\n          value.type = { shape: { dims }, tensorType: type };\n          const currentIndex = this._allData.push(value) - 1;\n          dataIndices.set(inputName, currentIndex);\n          inputValueNames.push(inputName);\n        }\n      }\n    }\n    // check initializers\n    for (let i = 0; i < graph.initializersLength(); i++) {\n      const initializer = graph.initializers(i)!;\n      let index = dataIndices.get(initializer.name()!);\n      if (index === undefined) {\n        const value = new Value();\n        const dims = ProtoUtil.tensorDimsFromORTFormat(initializer);\n        const type = ProtoUtil.tensorDataTypeFromProto(initializer.dataType());\n        value.type = { shape: { dims }, tensorType: type };\n        index = this._allData.push(value) - 1;\n        dataIndices.set(initializer.name()!, index);\n      }\n      this._allData[index]._from = -1;\n      this._allData[index].tensor = Tensor.fromOrtTensor(initializer);\n    }\n\n    // filter out input indices\n    for (let i = 0; i < this._allData.length; i++) {\n      if (!this._allData[i].tensor) {\n        this._allInputIndices.push(i);\n        this._allInputNames.push(inputValueNames[i]);\n      }\n    }\n\n    // scan all outputs\n    for (let i = 0; i < graph.outputsLength(); i++) {\n      const outputName = graph.outputs(i);\n      if (dataIndices.has(outputName)) {\n        throw new Error(`duplicated output name: ${outputName}`);\n      }\n      const currentIndex = this._allData.push(new Value()) - 1;\n      dataIndices.set(outputName, currentIndex);\n      this._allOutputIndices.push(currentIndex);\n      this._allOutputNames.push(outputName);\n    }\n\n    // scan all nodes\n    if (!graph.nodes) {\n      throw new Error('missing information in graph: node');\n    }\n    for (let i = 0; i < graph.nodesLength(); i++) {\n      const nodeProto = graph.nodes(i);\n      let name = nodeProto!.name();\n      if (!name) {\n        // assign a name to the node if it doesn't have one\n        for (let pick = 0; ; pick++) {\n          name = `unnamed_${nodeProto!.opType()}_${pick}`;\n          if (!nodesIndices.has(name)) {\n            // an unique name is found. break.\n            break;\n          }\n        }\n      }\n\n      if (nodesIndices.has(name)) {\n        throw new Error(`duplicated node name: ${name}`);\n      }\n      const currentIndex = this._nodes.push(new Node(nodeProto!, name)) - 1;\n      nodesIndices.set(name, currentIndex);\n    }\n\n    // scan node's outputs\n    for (let i = 0; i < this._nodes.length; i++) {\n      const node = this._nodes[i];\n      const nodeProto = graph.nodes(i);\n      if (nodeProto == null) {\n        throw new Error(`No node exists at index ${i}`);\n      }\n      if (nodeProto?.outputsLength() === 0) {\n        throw new Error(`missing output for node: ${nodeProto.name}`);\n      }\n      for (let j = 0; j < nodeProto?.outputsLength(); j++) {\n        const output = nodeProto?.outputs(j);\n        let dataIndex = dataIndices.get(output);\n        if (typeof dataIndex === 'undefined') {\n          dataIndex = this._allData.push(new Value()) - 1;\n          dataIndices.set(output, dataIndex);\n        }\n        node.outputs.push(dataIndex);\n\n        if (this._allData[dataIndex]._from !== undefined) {\n          throw new Error(`multiple nodes output to one data value: ${dataIndex}`);\n        }\n        this._allData[dataIndex]._from = i;\n\n        // for the 'Constant' operator, just create a new edge in the graph corresponding to the 'output' of the\n        // operator and ignore the node from the graph\n        if (nodeProto.opType() === 'Constant') {\n          if (nodeProto.attributesLength() !== 1 || !nodeProto.attributes(0)!.t()) {\n            throw new Error('missing attributes or missing tensor value in attributes for this Constant operator');\n          }\n          if (nodeProto.outputsLength() !== 1) {\n            throw new Error('missing output or incorrect number of outputs for this Constant operator');\n          }\n          node.outputs.pop();\n          node.executeNode = false;\n\n          this._allData[dataIndex]._from = -1;\n          this._allData[dataIndex].tensor = Tensor.fromOrtTensor(nodeProto.attributes(0)!.t()!);\n        }\n      }\n    }\n\n    // scan node's inputs\n    for (let i = 0; i < this._nodes.length; i++) {\n      const node = this._nodes[i];\n      const nodeProto = graph.nodes(i)!;\n\n      if (nodeProto.inputsLength() === 0) {\n        throw new Error(`missing input for node: ${nodeProto.name}`);\n      }\n      for (let j = 0; j < nodeProto.inputsLength()!; j++) {\n        const input = nodeProto.inputs(j)!;\n        const dataIndex = dataIndices.get(input);\n        if (typeof dataIndex === 'undefined') {\n          throw new Error(`unrecognized input '${input}' for node: ${nodeProto!.name()}`);\n        }\n        node.inputs.push(dataIndex);\n\n        this._allData[dataIndex]._to.push(i);\n      }\n    }\n  }\n\n  private checkIsAcyclic() {\n    // go through the graph and check for cycles or other fatal inconsistencies\n    const starters: Set<number> = new Set<number>();\n    this._allInputIndices.forEach((i) => {\n      const data = this._allData[i];\n      data._to.forEach((j) => {\n        starters.add(j);\n      });\n    });\n\n    // Iterative DFS to check for cycles\n    const nodesStack = Array.from(starters);\n    const nodesState = new Array<string>(this._nodes.length).fill('white');\n\n    while (nodesStack.length > 0) {\n      const nodeIndex = nodesStack.pop()!;\n      // this node has now been processed completely. Mark this node 'black' to denote this.\n      if (nodesState[nodeIndex] === 'gray') {\n        nodesState[nodeIndex] = 'black';\n      } else {\n        // this node is under processing stage. mark this node 'gray' to denote this.\n        nodesStack.push(nodeIndex);\n        nodesState[nodeIndex] = 'gray';\n\n        this._nodes[nodeIndex].outputs.forEach((outgoingEdgeIndex) => {\n          const data = this._allData[outgoingEdgeIndex];\n          if (typeof data.tensor !== 'undefined') {\n            throw new Error('node outputs should not be initialized');\n          }\n          if (data._from !== nodeIndex) {\n            throw new Error(\"from property of the Value object doesn't match index of Node being processed\");\n          }\n          data._to.forEach((downstreamNodeIndex) => {\n            // back edge found - cyclic\n            if (nodesState[downstreamNodeIndex] === 'gray') {\n              throw new Error('model graph is cyclic');\n            }\n            // tree edge found - continue processing by adding it to stack\n            else if (nodesState[downstreamNodeIndex] === 'white') {\n              nodesStack.push(downstreamNodeIndex);\n            }\n          });\n        });\n      }\n    }\n  }\n\n  private transformGraph(graphInitializer?: Graph.Initializer): void {\n    // apply common transform\n    this.removeAllIdentityNodes();\n    this.removeAllDropoutNodes();\n    this.fuseConvActivationNodes();\n    // apply initializer specific transform\n    if (graphInitializer) {\n      graphInitializer.transformGraph(this);\n    }\n\n    // finalize graph\n    this.finalizeGraph();\n  }\n\n  /**\n   * finalize the graph.\n   *\n   * this function should be called after all the transformation completed.\n   * this function removes all unnecessary nodes and values from the graph\n   */\n  finalizeGraph() {\n    let offset = 0;\n    // delete all nodes that are not being executed\n    // The graph is represented using these two arrays\n    // this._nodes - Array holding the kernels to execute - each entry is a kernel pointing to this._allData\n    // this._allData - hold 2 fields - to [] & from - these feileds hold the graph map for inputs and outputs per node\n    // newIndices - remapping the graph after reading the flag 'executeNode'\n    const newIndices = new Array<number>(this._nodes.length, 0);\n    let nodePossition = 0;\n\n    for (let i = 0; i < this._nodes.length; i++) {\n      // giving new indexes to the nodes based on execution flag\n      newIndices[i] = nodePossition;\n      if (this._nodes[i].executeNode) {\n        if (nodePossition !== i) {\n          this._nodes[nodePossition] = this._nodes[i];\n        }\n        nodePossition++;\n      } else {\n        // delete all output values\n        this._nodes[i].outputs.forEach((ind) => {\n          this._allData[ind]._from = -2;\n        });\n      }\n    }\n\n    // removing the unused nodes\n    this._nodes.splice(nodePossition, this._nodes.length - nodePossition);\n\n    // Updating this._allData according to the new this._nodes\n    for (let i = 0; i < this._allData.length; i++) {\n      const currentData = this._allData[i];\n      if (currentData._from !== undefined && currentData._from !== -1 && currentData._from !== -2) {\n        currentData._from = newIndices[currentData._from];\n      }\n\n      for (let j = 0; j < currentData._to.length; j++) {\n        if (currentData._to[j] >= 0) {\n          currentData._to[j] = newIndices[currentData._to[j]];\n        } else {\n          throw new Error('Trying to update a removed node');\n        }\n      }\n    }\n\n    offset = 0;\n    // delete all values that are not being referenced\n    for (let i = 0; i < this._allData.length; i++) {\n      // if current value is neither linked to next node, nor an output value, remove it.\n      if (this._allData[i].from === -2 && this._allOutputIndices.indexOf(i + offset) === -1) {\n        offset++;\n        this._allData.splice(i, 1);\n        i--;\n        continue;\n      }\n      if (offset > 0) {\n        let ind = -1;\n        // if current value is neither an input value nor an initializer, find the node it's\n        // coming from and update the corresponding node output\n        if (this._allData[i].from !== undefined && this._allData[i].from !== -1) {\n          ind = this._nodes[this._allData[i].from].outputs.indexOf(i + offset);\n          if (ind !== -1) {\n            this._nodes[this._allData[i].from].outputs[ind] = i;\n          }\n        } else {\n          // if current value is an input value, update its reference in inputIndices\n          ind = this._allInputIndices.indexOf(i + offset);\n          if (ind !== -1) {\n            this._allInputIndices[ind] = i;\n          }\n        }\n\n        // find the node that the current value is linking to and update its input reference\n        this._allData[i].to.forEach((node) => {\n          ind = this._nodes[node].inputs.indexOf(i + offset);\n          if (ind !== -1) {\n            this._nodes[node].inputs[ind] = i;\n          }\n        });\n        if (this._allData[i].to.length === 0) {\n          // if current value is a graph output, update its reference in outputIndices\n          ind = this._allOutputIndices.indexOf(i + offset);\n          if (ind !== -1) {\n            this._allOutputIndices[ind] = i;\n          }\n        }\n      }\n    }\n  }\n\n  /**\n   * Delete the specified node. Assume the node has one incoming input and the first output connected to other nodes.\n   * An input validation must be done before calling this function.\n   * @param nodeIndex The index of node to be deleted\n   */\n  private deleteNode(nodeIndex: number) {\n    const node = this._nodes[nodeIndex];\n    if (node.outputs.length > 1) {\n      for (let i = 1; i < node.outputs.length; i++) {\n        if (this._allData[node.outputs[i]].to.length > 0) {\n          throw new Error('Node deletion with more than one output connected to other nodes is not supported. ');\n        }\n      }\n    }\n\n    // this node wil not be executed\n    node.executeNode = false;\n    const inputValueIndex = node.inputs[0];\n    const outputValueIndex = node.outputs[0];\n    const nodesConsumingOutput = this._allData[outputValueIndex].to;\n\n    // remove this node from the to property of the input Value\n    for (let i = 0; i < node.inputs.length; i++) {\n      const delIndex = this._allData[node.inputs[i]].to.indexOf(nodeIndex);\n      // should not happen\n      if (delIndex === -1) {\n        throw new Error(\"The Value object doesn't have the current Node in it's 'to' property \");\n      }\n      this._allData[node.inputs[i]].to.splice(delIndex, 1);\n    }\n\n    // clear node indices consuming this output Value\n    this._allData[outputValueIndex]._to = [];\n\n    // if the output of this node is a graph output, adjust the index appropriately\n    const index = this._allOutputIndices.indexOf(outputValueIndex);\n    if (index !== -1) {\n      this._allOutputIndices[index] = inputValueIndex;\n    }\n\n    // override the inputs for nodes consuming this node's output with the input to this node\n    if (nodesConsumingOutput && nodesConsumingOutput.length > 0) {\n      for (const nodeIndex of nodesConsumingOutput) {\n        const replaceIndex = this._nodes[nodeIndex].inputs.indexOf(outputValueIndex);\n        // should not happen\n        if (replaceIndex === -1) {\n          throw new Error(\"The Node object doesn't have the output Value in it's 'inputs' property \");\n        }\n        this._nodes[nodeIndex].inputs[replaceIndex] = inputValueIndex;\n        this._allData[inputValueIndex].to.push(nodeIndex);\n      }\n    }\n  }\n\n  removeAllDropoutNodes() {\n    let nodeIndex = 0;\n    for (const node of this._nodes) {\n      // weed out 'Dropout' nodes so that no time is wasted in execution\n      if (node.opType === 'Dropout') {\n        // the node should have exactly 1 input and 1 or 2 outputs\n        if (node.inputs.length !== 1) {\n          throw new Error('Dropout nodes should only contain one input. ');\n        }\n        if (node.outputs.length !== 1 && node.outputs.length !== 2) {\n          throw new Error('Dropout nodes should contain either 1 or 2 output(s)');\n        }\n        // the second output should not be referenced by any other node\n        if (node.outputs.length === 2 && this._allData[node.outputs[1]]._to.length !== 0) {\n          throw new Error(\"Dropout nodes's second output should not be referenced by other nodes\");\n        }\n        this.deleteNode(nodeIndex);\n      }\n      nodeIndex++;\n    }\n  }\n\n  removeAllIdentityNodes() {\n    let nodeIndex = 0;\n    for (const node of this._nodes) {\n      // weed out 'Identity' nodes so that no time is wasted in execution\n      if (node.opType === 'Identity') {\n        this.deleteNode(nodeIndex);\n      }\n      nodeIndex++;\n    }\n  }\n\n  isActivation(n: Node): boolean {\n    switch (n.opType) {\n      // TODO: add other activation methods\n      case 'Relu':\n      case 'Sigmoid':\n      case 'Clip':\n        return true;\n      default:\n        return false;\n    }\n  }\n\n  fuseConvActivationNodes() {\n    for (const node of this._nodes) {\n      if (node.opType === 'Conv') {\n        const next = this._allData[node.outputs[0]]._to;\n        if (next.length === 1 && this.isActivation(this._nodes[next[0]])) {\n          const child = this._nodes[next[0]];\n          if (child.opType === 'Clip') {\n            if (child.inputs.length === 1) {\n              try {\n                node.attributes.set('activation_params', 'floats', [\n                  child.attributes.getFloat('min'),\n                  child.attributes.getFloat('max'),\n                ]);\n              } catch {\n                node.attributes.set('activation_params', 'floats', [MIN_CLIP, MAX_CLIP]);\n              }\n            } else if (\n              child.inputs.length >= 3 &&\n              this._allData[child.inputs[1]].tensor !== undefined &&\n              this._allData[child.inputs[2]].tensor !== undefined\n            ) {\n              node.attributes.set('activation_params', 'floats', [\n                this._allData[child.inputs[1]].tensor!.floatData[0],\n                this._allData[child.inputs[2]].tensor!.floatData[0],\n              ]);\n            } else {\n              // Skip fusion with clip node since clip min and clip max are not coming from initializer\n              continue;\n            }\n          }\n          node.attributes.set('activation', 'string', child.opType);\n          this.deleteNode(next[0]);\n        }\n      }\n    }\n  }\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport * as flatbuffers from 'flatbuffers';\n\nimport { Graph } from './graph';\nimport { OpSet } from './opset';\nimport * as ortFbs from './ort-schema/flatbuffers/ort-generated';\nimport { onnx } from './ort-schema/protobuf/onnx';\nimport { LongUtil } from './util';\n\nexport class Model {\n  // empty model\n  constructor() {}\n\n  load(buf: Uint8Array, graphInitializer?: Graph.Initializer, isOrtFormat?: boolean): void {\n    let onnxError: Error | undefined;\n    if (!isOrtFormat) {\n      // isOrtFormat === false || isOrtFormat === undefined\n      try {\n        this.loadFromOnnxFormat(buf, graphInitializer);\n        return;\n      } catch (e) {\n        if (isOrtFormat !== undefined) {\n          throw e;\n        }\n        onnxError = e;\n      }\n    }\n\n    try {\n      this.loadFromOrtFormat(buf, graphInitializer);\n    } catch (e) {\n      if (isOrtFormat !== undefined) {\n        throw e;\n      }\n      // Tried both formats and failed (when isOrtFormat === undefined)\n      throw new Error(`Failed to load model as ONNX format: ${onnxError}\\nas ORT format: ${e}`);\n    }\n  }\n\n  private loadFromOnnxFormat(buf: Uint8Array, graphInitializer?: Graph.Initializer): void {\n    const modelProto = onnx.ModelProto.decode(buf);\n    const irVersion = LongUtil.longToNumber(modelProto.irVersion);\n    if (irVersion < 3) {\n      throw new Error('only support ONNX model with IR_VERSION>=3');\n    }\n\n    this._opsets = modelProto.opsetImport.map((i) => ({\n      domain: i.domain as string,\n      version: LongUtil.longToNumber(i.version!),\n    }));\n\n    this._graph = Graph.from(modelProto.graph!, graphInitializer);\n  }\n\n  private loadFromOrtFormat(buf: Uint8Array, graphInitializer?: Graph.Initializer): void {\n    const fb = new flatbuffers.ByteBuffer(buf);\n    const ortModel = ortFbs.InferenceSession.getRootAsInferenceSession(fb).model()!;\n    const irVersion = LongUtil.longToNumber(ortModel.irVersion());\n    if (irVersion < 3) {\n      throw new Error('only support ONNX model with IR_VERSION>=3');\n    }\n    this._opsets = [];\n    for (let i = 0; i < ortModel.opsetImportLength(); i++) {\n      const opsetId = ortModel.opsetImport(i)!;\n      this._opsets.push({ domain: opsetId?.domain() as string, version: LongUtil.longToNumber(opsetId.version()!) });\n    }\n\n    this._graph = Graph.from(ortModel.graph()!, graphInitializer);\n  }\n\n  private _graph: Graph;\n  get graph(): Graph {\n    return this._graph;\n  }\n\n  private _opsets: OpSet[];\n  get opsets(): readonly OpSet[] {\n    return this._opsets;\n  }\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { resolveBackend, SessionHandlerType } from './backend';\nimport { ExecutionPlan } from './execution-plan';\nimport { Graph } from './graph';\nimport { Profiler } from './instrument';\nimport { Model } from './model';\nimport { Operator } from './operators';\nimport { Tensor } from './tensor';\n\nexport declare namespace Session {\n  export interface Config {\n    backendHint?: string;\n    profiler?: Profiler.Config;\n  }\n\n  export interface Context {\n    profiler: Readonly<Profiler>;\n    graphInputTypes?: Tensor.DataType[];\n    graphInputDims?: Array<readonly number[]>;\n  }\n}\n\nexport class Session {\n  constructor(config: Session.Config = {}) {\n    this._initialized = false;\n    this.backendHint = config.backendHint;\n    this.profiler = Profiler.create(config.profiler);\n    this.context = { profiler: this.profiler, graphInputTypes: [], graphInputDims: [] };\n  }\n\n  get inputNames(): readonly string[] {\n    return this._model.graph.getInputNames();\n  }\n  get outputNames(): readonly string[] {\n    return this._model.graph.getOutputNames();\n  }\n\n  startProfiling() {\n    this.profiler.start();\n  }\n\n  endProfiling() {\n    this.profiler.stop();\n  }\n\n  async loadModel(uri: string): Promise<void>;\n  async loadModel(buffer: ArrayBuffer, byteOffset?: number, length?: number): Promise<void>;\n  async loadModel(buffer: Uint8Array): Promise<void>;\n  async loadModel(arg: string | ArrayBuffer | Uint8Array, byteOffset?: number, length?: number): Promise<void> {\n    await this.profiler.event('session', 'Session.loadModel', async () => {\n      // resolve backend and session handler\n      const backend = await resolveBackend(this.backendHint);\n      this.sessionHandler = backend.createSessionHandler(this.context);\n\n      this._model = new Model();\n      if (typeof arg === 'string') {\n        const isOrtFormat = arg.endsWith('.ort');\n        if (typeof process !== 'undefined' && process.versions && process.versions.node) {\n          // node\n          const { readFile } = require('node:fs/promises');\n          const buf = await readFile(arg);\n          this.initialize(buf, isOrtFormat);\n        } else {\n          // browser\n          const response = await fetch(arg);\n          const buf = await response.arrayBuffer();\n          this.initialize(new Uint8Array(buf), isOrtFormat);\n        }\n      } else if (!ArrayBuffer.isView(arg)) {\n        // load model from ArrayBuffer\n        const arr = new Uint8Array(arg, byteOffset || 0, length || arg.byteLength);\n        this.initialize(arr);\n      } else {\n        // load model from Uint8array\n        this.initialize(arg);\n      }\n    });\n  }\n\n  private initialize(modelProtoBlob: Uint8Array, isOrtFormat?: boolean): void {\n    if (this._initialized) {\n      throw new Error('already initialized');\n    }\n\n    this.profiler.event('session', 'Session.initialize', () => {\n      // load graph\n      const graphInitializer = this.sessionHandler.transformGraph\n        ? (this.sessionHandler as Graph.Initializer)\n        : undefined;\n      this._model.load(modelProtoBlob, graphInitializer, isOrtFormat);\n\n      // graph is completely initialzied at this stage , let the interested handlers know\n      if (this.sessionHandler.onGraphInitialized) {\n        this.sessionHandler.onGraphInitialized(this._model.graph);\n      }\n      // initialize each operator in the graph\n      this.initializeOps(this._model.graph);\n\n      // instantiate an ExecutionPlan object to be used by the Session object\n      this._executionPlan = new ExecutionPlan(this._model.graph, this._ops, this.profiler);\n    });\n\n    this._initialized = true;\n  }\n\n  async run(inputs: Map<string, Tensor> | Tensor[]): Promise<Map<string, Tensor>> {\n    if (!this._initialized) {\n      throw new Error('session not initialized yet');\n    }\n\n    return this.profiler.event('session', 'Session.run', async () => {\n      const inputTensors = this.normalizeAndValidateInputs(inputs);\n\n      const outputTensors = await this._executionPlan.execute(this.sessionHandler, inputTensors);\n\n      return this.createOutput(outputTensors);\n    });\n  }\n\n  private normalizeAndValidateInputs(inputs: Map<string, Tensor> | Tensor[]): Tensor[] {\n    const modelInputNames = this._model.graph.getInputNames();\n\n    // normalize inputs\n    // inputs: Tensor[]\n    if (Array.isArray(inputs)) {\n      if (inputs.length !== modelInputNames.length) {\n        throw new Error(`incorrect input array length: expected ${modelInputNames.length} but got ${inputs.length}`);\n      }\n    }\n    // convert map to array\n    // inputs: Map<string, Tensor>\n    else {\n      if (inputs.size !== modelInputNames.length) {\n        throw new Error(`incorrect input map size: expected ${modelInputNames.length} but got ${inputs.size}`);\n      }\n\n      const sortedInputs = new Array<Tensor>(inputs.size);\n      let sortedInputsIndex = 0;\n      for (let i = 0; i < modelInputNames.length; ++i) {\n        const tensor = inputs.get(modelInputNames[i]);\n        if (!tensor) {\n          throw new Error(`missing input tensor for: '${name}'`);\n        }\n        sortedInputs[sortedInputsIndex++] = tensor;\n      }\n\n      inputs = sortedInputs;\n    }\n\n    // validate dims requirements\n    // First session run - graph input data is not cached for the session\n    if (\n      !this.context.graphInputTypes ||\n      this.context.graphInputTypes.length === 0 ||\n      !this.context.graphInputDims ||\n      this.context.graphInputDims.length === 0\n    ) {\n      const modelInputIndices = this._model.graph.getInputIndices();\n      const modelValues = this._model.graph.getValues();\n\n      const graphInputDims = new Array<readonly number[]>(modelInputIndices.length);\n\n      for (let i = 0; i < modelInputIndices.length; ++i) {\n        const graphInput = modelValues[modelInputIndices[i]];\n        graphInputDims[i] = graphInput.type!.shape.dims;\n\n        // cached for second and subsequent runs.\n        // Some parts of the framework works on the assumption that the graph and types and shapes are static\n        this.context.graphInputTypes!.push(graphInput.type!.tensorType);\n        this.context.graphInputDims!.push(inputs[i].dims);\n      }\n\n      this.validateInputTensorDims(graphInputDims, inputs, true);\n    }\n\n    // Second and subsequent session runs - graph input data is cached for the session\n    else {\n      this.validateInputTensorDims(this.context.graphInputDims, inputs, false);\n    }\n\n    // validate types requirement\n    this.validateInputTensorTypes(this.context.graphInputTypes!, inputs);\n\n    return inputs;\n  }\n\n  private validateInputTensorTypes(graphInputTypes: Tensor.DataType[], givenInputs: Tensor[]) {\n    for (let i = 0; i < givenInputs.length; i++) {\n      const expectedType = graphInputTypes[i];\n      const actualType = givenInputs[i].type;\n      if (expectedType !== actualType) {\n        throw new Error(`input tensor[${i}] check failed: expected type '${expectedType}' but got ${actualType}`);\n      }\n    }\n  }\n\n  private validateInputTensorDims(\n    graphInputDims: Array<readonly number[]>,\n    givenInputs: Tensor[],\n    noneDimSupported: boolean,\n  ) {\n    for (let i = 0; i < givenInputs.length; i++) {\n      const expectedDims = graphInputDims[i];\n      const actualDims = givenInputs[i].dims;\n      if (!this.compareTensorDims(expectedDims, actualDims, noneDimSupported)) {\n        throw new Error(\n          `input tensor[${i}] check failed: expected shape '[${expectedDims.join(',')}]' but got [${actualDims.join(\n            ',',\n          )}]`,\n        );\n      }\n    }\n  }\n\n  private compareTensorDims(\n    expectedDims: readonly number[],\n    actualDims: readonly number[],\n    noneDimSupported: boolean,\n  ): boolean {\n    if (expectedDims.length !== actualDims.length) {\n      return false;\n    }\n\n    for (let i = 0; i < expectedDims.length; ++i) {\n      if (expectedDims[i] !== actualDims[i] && (!noneDimSupported || expectedDims[i] !== 0)) {\n        // data shape mismatch AND not a 'None' dimension.\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  private createOutput(outputTensors: Tensor[]): Map<string, Tensor> {\n    const modelOutputNames = this._model.graph.getOutputNames();\n    if (outputTensors.length !== modelOutputNames.length) {\n      throw new Error('expected number of outputs do not match number of generated outputs');\n    }\n\n    const output = new Map<string, Tensor>();\n    for (let i = 0; i < modelOutputNames.length; ++i) {\n      output.set(modelOutputNames[i], outputTensors[i]);\n    }\n\n    return output;\n  }\n\n  private initializeOps(graph: Graph): void {\n    const nodes = graph.getNodes();\n    this._ops = new Array(nodes.length);\n\n    for (let i = 0; i < nodes.length; i++) {\n      this._ops[i] = this.sessionHandler.resolve(nodes[i], this._model.opsets, graph);\n    }\n  }\n\n  private _model: Model;\n  private _initialized: boolean;\n\n  private _ops: Operator[];\n  private _executionPlan: ExecutionPlan;\n\n  private backendHint?: string;\n\n  private sessionHandler: SessionHandlerType;\n  private context: Session.Context;\n  private profiler: Readonly<Profiler>;\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { InferenceSession, InferenceSessionHandler, SessionHandler, Tensor } from 'onnxruntime-common';\n\nimport { Session } from './session';\nimport { Tensor as OnnxjsTensor } from './tensor';\n\nexport class OnnxjsSessionHandler implements InferenceSessionHandler {\n  constructor(private session: Session) {\n    this.inputNames = this.session.inputNames;\n    this.outputNames = this.session.outputNames;\n  }\n\n  get inputMetadata(): readonly InferenceSession.ValueMetadata[] {\n    throw new Error('Getting model metadata is not supported in webgl backend.');\n  }\n\n  get outputMetadata(): readonly InferenceSession.ValueMetadata[] {\n    throw new Error('Getting model metadata is not supported in webgl backend.');\n  }\n\n  async dispose(): Promise<void> {}\n  inputNames: readonly string[];\n  outputNames: readonly string[];\n  async run(\n    feeds: SessionHandler.FeedsType,\n    _fetches: SessionHandler.FetchesType,\n    _options: InferenceSession.RunOptions,\n  ): Promise<SessionHandler.ReturnType> {\n    const inputMap = new Map<string, OnnxjsTensor>();\n    for (const name in feeds) {\n      if (Object.hasOwnProperty.call(feeds, name)) {\n        const feed = feeds[name];\n        inputMap.set(\n          name,\n          new OnnxjsTensor(\n            feed.dims,\n            feed.type as OnnxjsTensor.DataType,\n            undefined,\n            undefined,\n            feed.data as OnnxjsTensor.NumberType,\n          ),\n        );\n      }\n    }\n    const outputMap = await this.session.run(inputMap);\n    const output: SessionHandler.ReturnType = {};\n    outputMap.forEach((tensor, name) => {\n      output[name] = new Tensor(tensor.type, tensor.data, tensor.dims);\n    });\n    return output;\n  }\n  startProfiling(): void {\n    this.session.startProfiling();\n  }\n  endProfiling(): void {\n    this.session.endProfiling();\n  }\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Backend, InferenceSession, InferenceSessionHandler } from 'onnxruntime-common';\n\nimport { Session } from './onnxjs/session';\nimport { OnnxjsSessionHandler } from './onnxjs/session-handler-inference';\n\nclass OnnxjsBackend implements Backend {\n  // eslint-disable-next-line @typescript-eslint/no-empty-function\n  async init(): Promise<void> {}\n\n  async createInferenceSessionHandler(\n    pathOrBuffer: string | Uint8Array,\n    options?: InferenceSession.SessionOptions,\n  ): Promise<InferenceSessionHandler> {\n    // NOTE: Session.Config(from onnx.js) is not compatible with InferenceSession.SessionOptions(from\n    // onnxruntime-common).\n    //       In future we should remove Session.Config and use InferenceSession.SessionOptions.\n    //       Currently we allow this to happen to make test runner work.\n    const session = new Session(options as unknown as Session.Config);\n\n    // typescript cannot merge method override correctly (so far in 4.2.3). need if-else to call the method.\n    if (typeof pathOrBuffer === 'string') {\n      await session.loadModel(pathOrBuffer);\n    } else {\n      await session.loadModel(pathOrBuffer);\n    }\n\n    return new OnnxjsSessionHandler(session);\n  }\n}\n\nexport const onnxjsBackend = new OnnxjsBackend();\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n/* eslint-disable @typescript-eslint/no-var-requires, @typescript-eslint/no-require-imports */\n\n// We use \"require\" instead of \"import\" here because import statement must be put in top level. Our current code does\n// not allow bundler to tree-shaking code as expected because some codes are treated as having side effects.\n// So we import code inside the if-clause to allow bundler remove the code safely.\n\nexport * from 'onnxruntime-common';\nimport * as ort from 'onnxruntime-common';\nexport default ort;\n\nimport { registerBackend, env } from 'onnxruntime-common';\nimport { version } from './version';\n\nif (!BUILD_DEFS.DISABLE_WEBGL) {\n  const onnxjsBackend = require('./backend-onnxjs').onnxjsBackend;\n  registerBackend('webgl', onnxjsBackend, -10);\n}\n\nif (!BUILD_DEFS.DISABLE_JSEP && !BUILD_DEFS.DISABLE_WEBGPU) {\n  throw new Error(\n    'The current build is specified to enable both JSEP and WebGPU EP. This is not a valid configuration. ' +\n      'JSEP and WebGPU EPs cannot be enabled at the same time.',\n  );\n}\n\nif (!BUILD_DEFS.DISABLE_WEBNN && BUILD_DEFS.DISABLE_JSEP && BUILD_DEFS.DISABLE_WEBGPU) {\n  throw new Error(\n    'The current build is specified to enable WebNN EP without JSEP or WebGPU EP. This is not a valid configuration. ' +\n      'WebNN EP requires either JSEP or WebGPU EP to be enabled.',\n  );\n}\n\nif (!BUILD_DEFS.DISABLE_WASM) {\n  const wasmBackend = require('./backend-wasm').wasmBackend;\n  if (!BUILD_DEFS.DISABLE_JSEP || !BUILD_DEFS.DISABLE_WEBGPU) {\n    registerBackend('webgpu', wasmBackend, 5);\n  }\n  if (!BUILD_DEFS.DISABLE_WEBNN) {\n    registerBackend('webnn', wasmBackend, 5);\n  }\n  registerBackend('cpu', wasmBackend, 10);\n  registerBackend('wasm', wasmBackend, 10);\n}\n\nObject.defineProperty(env.versions, 'web', { value: version, enumerable: true });\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n// This file is generated by /js/scripts/update-version.ts\n// Do not modify file content manually.\n\nexport const version = '1.30.0';\n"],
  "mappings": "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;AAAA,YAAG;AAAA,YAAK;AAAA,YAAI;AAAA,YAAG;AAAA,YAAK;AAAA,YAAI;AAAA,YAAI;AAAA,YAAK;AAAA,YAAK;AAAA,YAAI;AAAA,YAAG;AAAA,YAAK;AAAA,YACrE;AAAA,YAAG;AAAA,YAAK;AAAA,YAAI;AAAA,YAAI;AAAA,YAAK;AAAA,YAAK;AAAA,YAAK;AAAA,YAAI;AAAA,YAAG;AAAA,YAAI;AAAA,YAAI;AAAA,YAAK;AAAA,YAAK;AAAA,YAAI;AAAA,YAAG;AAAA,YAAI;AAAA,YACnE;AAAA,YAAK;AAAA;AAAA,YAEL;AAAA,YAAI;AAAA,YAAG;AAAA,YAAG;AAAA,YAAK;AAAA,YAAI;AAAA,YAAG;AAAA,YAAK;AAAA,YAAI;AAAA,YAAG;AAAA,YAAK;AAAA,YAAI;AAAA,YAAI;AAAA,YAAK;AAAA,YAAK;AAAA,YAAI;AAAA,YAAG;AAAA,YAAK;AAAA,YACrE;AAAA,YAAG;AAAA,YAAK;AAAA,YAAI;AAAA,YAAI;AAAA,YAAK;AAAA,YAAK;AAAA,YAAK;AAAA,YAAI;AAAA,YAAG;AAAA,YAAI;AAAA,YAAI;AAAA,YAAK;AAAA,YAAK;AAAA,YAAI;AAAA,YAAG;AAAA,YAAI;AAAA,YACnE;AAAA,YAAK;AAAA;AAAA,YAEL;AAAA,YAAI;AAAA,YAAG;AAAA,YAAG;AAAA,YAAK;AAAA,YAAI;AAAA,YAAG;AAAA,YAAK;AAAA,YAAI;AAAA,YAAG;AAAA,YAAK;AAAA,YAAI;AAAA,YAAI;AAAA,YAAK;AAAA,YAAK;AAAA,YAAI;AAAA,YAAG;AAAA,YAAK;AAAA,YACrE;AAAA,YAAG;AAAA,YAAK;AAAA,YAAI;AAAA,YAAI;AAAA,YAAK;AAAA,YAAK;AAAA,YAAK;AAAA,YAAI;AAAA,YAAG;AAAA,YAAI;AAAA,YAAI;AAAA,YAAK;AAAA,YAAK;AAAA,YAAI;AAAA,YAAG;AAAA,YAAI;AAAA,YACnE;AAAA,YAAK;AAAA;AAAA,YAEL;AAAA,YAAI;AAAA,YAAG;AAAA,YAAG;AAAA,YAAK;AAAA,YAAI;AAAA,YAAG;AAAA,YAAK;AAAA,YAAI;AAAA,YAAG;AAAA,YAAK;AAAA,YAAI;AAAA,YAA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AAAA,gBAAI;AAAA,gBAAG;AAAA,gBAAK;AAAA,gBAAI;AAAA,gBAAI;AAAA,gBAAK;AAAA,gBAAK;AAAA,gBAAI;AAAA,gBAAG;AAAA,gBAChE;AAAA,gBAAI;AAAA,gBAAG;AAAA,gBAAK;AAAA,gBAAI;AAAA,gBAAI;AAAA,gBAAK;AAAA,gBAAK;AAAA,gBAAK;AAAA,gBAAI;AAAA,gBAAG;AAAA,gBAAI;AAAA,gBAAI;AAAA,gBAAK;AAAA,gBAAK;AAAA,gBAAI;AAAA,gBAChE;AAAA,gBAAI;AAAA,gBAAG;AAAA,gBAAK;AAAA;AAAA,gBAEZ;AAAA,gBAAI;AAAA,gBAAG;AAAA,gBAAG;AAAA,gBAAK;AAAA,gBAAI;AAAA,gBAAG;AAAA,gBAAK;AAAA,gBAAI;AAAA,gBAAG;AAAA,gBAAK;AAAA,gBAAI;AAAA,gBAAI;AAAA,gBAAK;AAAA,gBAAK;AAAA,gBAAI;AAAA,gBAAG;AAAA,gBAChE;AAAA,gBAAI;AAAA,gBAAG;AAAA,gBAAK;AAAA,gBAAI;AAAA,gBAAI;AAAA,gBAAK;AAAA,gBAAK;AAAA,gBAAK;AAAA,gBAAI;AAAA,gBAAG;AAAA,gBAAI;AAAA,gBAAI;AAAA,gBAAK;AAAA,gBAAK;AAAA,gBAAI;AAAA,gBAChE;AAAA,gBAAI;AAAA,gBAAG;AAAA,gBAAK;AAAA;AAAA,gBAEZ;AAAA,gBAAI;AAAA,gBAAG;AAAA,gBAAG;AAAA,gBAAK;AAAA,gBAAI;AAAA,gBAAG;AAAA,gBAAK;AAAA,gBAAI;AAAA,gBAAG;AAAA,gBAAK;AAAA,gBAAI;AAAA,gBAAI;AAAA,gBAAK;AAAA,gBAAK;AAAA,gBAAI;AAAA,gBAAG;AAAA,gBAChE;AAAA,gBAAI;AAAA,gBAAG;AAAA,gBAAK;AAAA,gBAAI;AAAA,gBAAI;AAAA,gBAAK;AAAA,gBAAK;AAAA,gBAAK;AAAA,gBAAI;AAAA,gBAAG;AAAA,gBAAI;AAAA,gBAAI;AAAA,gBAAK;AAAA,gBAAK;AAAA,gBAAI;AAAA,gBAChE;AAAA,gBAAI;AAAA,gBAAG;AAAA,gBAAK;AAAA;AAAA,gBAEZ;AAAA,gBAAI;AAAA,gBAAG;AAAA,gBAAG;AA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",
  "names": ["name", "backend", "i", "env", "createCanvas", "Tensor", "Tensor", "name", "backend", "InferenceSession", "InferenceSession", "Tensor", "env", "log", "env", "name", "version", "Guid", "cache", "div", "log2", "ArgType", "Encoding", "ByteBuffer", "o", "flatbuffers", "AttributeType", "NodeType", "o", "flatbuffers", "EdgeEnd", "o", "flatbuffers", "o", "flatbuffers", "o", "flatbuffers", "o", "flatbuffers", "o", "flatbuffers", "TensorDataType", "o", "flatbuffers", "o", "flatbuffers", "o", "flatbuffers", "o", "flatbuffers", "DimensionValueType", "o", "flatbuffers", "o", "flatbuffers", "o", "flatbuffers", "o", "flatbuffers", "TypeInfoValue", "o", "flatbuffers", "o", "flatbuffers", "o", "flatbuffers", "o", "flatbuffers", "o", "flatbuffers", "o", "flatbuffers", "o", "flatbuffers", "o", "flatbuffers", "o", "flatbuffers", "o", "flatbuffers", "o", "flatbuffers", "o", "flatbuffers", "o", "flatbuffers", "o", "flatbuffers", "o", "flatbuffers", "import_tensor", "params", "offset", "i", "exports", "slice", "size", "fromNumber", "toNumber", "global", "exports", "wasm", "Long", "isLong", "ctz32", "INT_CACHE", "UINT_CACHE", "fromInt", "cache", "fromBits", "fromNumber", "UZERO", "ZERO", "TWO_PWR_64_DBL", "MAX_UNSIGNED_VALUE", "TWO_PWR_63_DBL", "MIN_VALUE", "MAX_VALUE", "TWO_PWR_32_DBL", "pow_dbl", "fromString", "fromValue", "TWO_PWR_16_DBL", "TWO_PWR_24_DBL", "TWO_PWR_24", "ONE", "UONE", "NEG_ONE", "LongPrototype", "toInt", "toNumber", "toString", "div", "getHighBits", "getHighBitsUnsigned", "getLowBits", "getLowBitsUnsigned", "getNumBitsAbs", "isSafeInteger", "isZero", "isNegative", "isPositive", "isOdd", "isEven", "equals", "notEquals", "lessThan", "lessThanOrEqual", "greaterThan", "greaterThanOrEqual", "compare", "negate", "add", "subtract", "multiply", "divide", "log2", "modulo", "not", "countLeadingZeros", "countTrailingZeros", "and", "or", "xor", "shiftLeft", "shiftRight", "shiftRightUnsigned", "rotateLeft", "rotateRight", "toSigned", "toUnsigned", "toBytes", "toBytesLE", "toBytesBE", "fromBytes", "fromBytesLE", "fromBytesBE", "Buffer", "Long", "name", "i", "create", "create_array", "create", "buffer", "self", "err", "require_minimal", "onnx", "Dimension", "Tensor", "Map", "SparseTensor", "init_tensor", "Tensor", "shape", "split", "import_onnx", "Tensor", "init_tensor", "cache", "version", "name", "shape", "shape", "shape", "init_tensor", "shape", "Tensor", "name", "name", "name", "add", "and", "or", "xor", "glsl", "shaderSource", "validateInputs", "shift", "validateInputs", "name", "log", "not", "validateInputs", "validateInputs", "validateInputs", "validateInputs", "name", "validateInputs", "validateInputs", "validateInputs", "validateInputs", "validateInputs", "validateInputs", "validateInputs", "shape", "validateInputs", "sum", "validateInputs", "name", "inputs", "validateInputs", "dim", "validateInputs", "validateInputs", "init_tensor", "Tensor", "validateInputs", "validateInputs", "validateInputs", "split", "validateInputs", "validateInputs", "validateInputs", "validateInputs", "validateInputsV13", "add", "and", "log", "not", "or", "xor", "name", "shape", "shape", "name", "source", "packedSampler", "texNumR", "texNumC", "transpose", "name", "shape", "i", "name", "name", "env", "name", "texture", "backend", "version", "env", "env", "cache", "backend", "init_backend", "output", "import_onnx", "Attribute", "init_tensor", "Tensor", "value", "import_onnx", "Graph", "Node", "init_tensor", "name", "Attribute", "Tensor", "shape", "nodeIndex", "import_onnx", "Model", "Graph", "init_backend", "backend", "Model", "init_tensor", "name", "Tensor", "version", "onnxjsBackend", "env", "version"]
}
